Programador profissional de jogos tem vida social?

Haha, parece brincadeira, mas uma mulher (esposa) de um programador de jogos da EA colocou no seu blog um desabafo contra seu marido porque ele é programador da Eletronic Arts (EA). Veja o monte de comentários que a dita cuja recebeu. A maioria de apoio! Uns até chegaram a dizer que não comprariam mais jogos da EA. Enfim, a vida de programador não é das melhores. E olhe que os de lá ganham muito mais que os daqui.

Ah, claro que concordo com essa mulher. Programadores sempre foram explorados pelas empresas, com raras exceções. Se o cara não aguenta, cai fora. Se o cara é bom, ele ganha pouco. O que podemos fazer? Estudar, estudar e estudar...

Compilador AGraphs

Minha monografia tem o objetivo de estudar a aplicabilidade dos AGraphs em sistemas de transformações de grafos. Clique aqui para saber mais sobre os Agraphs.

O projeto AGraphs tem como principal objetivo representar informações (dados). Para representar tais informações, ele se utiliza de grafos. O passo técnico necessário para tal representação é desenvolver um gerador de AGraphs. O gerador já foi desenvolvido com sucesso e tem como objetivo automatizar o processo de criação de um grafo que represente a informação desejada. Falarei melhor sobre o gerador depois, mas vamos ter em mente que ele recebe como entrada um modelo de grafo, em XML, e tem como saída uma biblioteca que possibilita a manipulação de informações presentes no grafo.

Uma das melhores partes do desenvolvimento da minha monografia está sendo a criação de um compilador. Este compilador tem o objetivo de traduzir um texto em outro texto. O texto de entrada é a gramática de um sistema de transformações de grafos enquanto que o texto de saída é o código gerado correspondente a entrada no gerador de AGraphs, isto é, o XML de entrada. Conseguindo cumprir este objetivo da minha monografia, facilitaria, e muito, a utilização dos AGraphs pela comunidade afora :)

Para fazer tal compilador (ou tradutor, na verdade), estou realizando os seguintes passos:

1. Obter exemplos de modelos de grafos no sistema de transformações de grafos que quero representar com os AGraphs.

2. Obtidos esses exemplos, realizar um estudo para obter a gramática do sistema de transformações de grafos.

3. Com a gramática em mãos, o compilador (parser) já pode ser gerado.

3.1 A primeira fase da geração do parser é gerar um analisador léxico. Para isso, utilizei a ferramenta Lex (ou Flex).

3.2 A segunda fase é construir um analisador sintático. Para isso, utilizei a ferramenta Yacc (ou Bison).

3.3 A terceira e última fase, falando simplicadamente, é desenvolver um analisador semântico e a parte responsável pela geração de código.

Meu jogo em XNA - parte 2

Este post é a continuação da série "Meu jogo em XNA". Veja a parte 1 aqui. Na primeira parte, falamos basicamente sobre as funções básicas do XNA: Initialize(), LoadGraphicsContent(), Update() e Draw(). Agora, vamos falar um pouco de alguns tipos de objetos básicos para desenvolvermos jogos em XNA, como por exemplo: GraphicsDeviceManager, ContentManager, MousePointer, Texture2D, SpriteBatch e SpriteFont.

Vamos falar na ordem descrita acima. GraphicsDeviceManager é um tipo de objeto que possibilita o gerenciamento e a configuração do dispositivo gráfico especificado para o jogo, como o monitor do PC, por exemplo. A linha:

GraphicsDeviceManager graphics;

declara um objeto chamado "graphics" do tipo "GraphicsDeviceManager".

Se eu quiser definir que meu jogo inicie com uma resolução 640x480, o que devo fazer? Bem, vamos pensar: a resolução tem que ser definida antes que o jogo comece. Então eu já sei que tem que ser na função Initialize(). E qual objeto gerencia a resolução de tela? O objeto graphics!

Assim, as linhas de código que configuram a resolução de tela é algo assim:

graphics.PreferredBackBufferWidth = 640; // resolução da largura...
graphics.PreferredBackBufferHeight = 480; // resolução da altura...
graphics.ApplyChanges(); // aplicar mudanças...

Se quiser ver mais detalhes sobre o tipo GraphicsDeviceManager, basta ir na documentação MSDN da Microsoft.

Agora, vamos ver o tipo ContentManager. O tipo ContentManager é um componente que carrega os objetos do jogo. E ele faz todo esse gerenciamento em tempo de execução. Sua declaração é:

ContentManager content;

Para ver mais detalhes sobre o ContentManager, visite a documentação MSDN.

Esse dois objetos já explicados são declarados automaticamente pelo código gerado do framework XNA. Por que? Porque todo projeto de um jogo em XNA usa esses dois objetos e o framework facilita isso pra nós.

Assim como especifica a programação orientada à objeto (POO), teremos que criar um construtor para os objetos GraphicsDeviceManager e ContentManager para mais tarde para podermos usá-los. As linhas do construtor dos objetos graphics e content ficam assim:

public Shooting()
{
graphics = new GraphicsDeviceManager(this);
content = new ContentManager(Services);
}

Os próximos tipos de objetos são mais simples de entender (não que os anteriores sejam difíceis).

MousePointer é tipo que declara que o objeto é pra ser manipulado como um ponteiro de um mouse. Ou seja, se você quiser que o seu jogo tenha um mouse, esse mouse tem que ser um objeto do tipo MousePointer. A sua declaração é:

MousePointer mousePointer;

Texture2D é um tipo que declara que o objeto seja manipulado pelo framework como uma textura 2D. Declaração:

Texture2D fundo;

SpriteBatch é um tipo que declara que o objeto instanciado é pra ser manipulado como um sprite (uma imagem ou animação integrada à cena do jogo). Declaração:

SpriteBatch sb;

E, finalmente, SpriteFont é tipo que declara que alguma coisa é pra ser manipulada como uma fonte (para poder imprimir algo na tela). No meu jogo Shooting, eu declaro assim:

SpriteFont scoreFont;

Vou terminando a parte 2 por aqui. Não sei o que será a parte 3 por enquanto, mas vou começar já a comentar o código para que todos possam entender o que eu fiz e o que o XNA faz pra mim :)

Caso queira ver a parte 1, clique aqui.

Análise Sintática

Na ciência da computação, análise sintática (ou parsing) é o processo de analisar uma sequência de entrada (geralmente um texto, como um código-fonte, por exemplo) para determinar sua estrutura gramatical segundo determinadas regras. Essa análise faz parte do processo de compilação, junto com a análise léxica, etapa anterior, e análise semântica, posterior.

Na saída da análise sintática temos, geralmente, uma árvore sintática, como na figura abaixo (poderia ser aqui outra estrutura de dados, mas as árvores caem como uma luva), o que é bastante conveniente para o processamento posterior, pois esta árvore é mais um passo de abstração para o computador. Tudo acaba em abstração, não é? Como eu já expliquei aqui, na análise léxica é obtido um grupo de tokens, e esse grupo é usado pelo analisador sintático que possui um conjunto de regras para construção de uma árvore sintática da estrutura.

O conjunto de regras que eu disse acima é uma gramática. Vamos a um exemplo:

" 'pronome' 'verbo' 'adjetivo' " é uma regra de uma gramática simples que eu acabei de criar pra uma linguagem própria (que acabei de inventar). Assim, tudo que não estiver de acordo com esta gramática está errado e o analisador sintático retronará uma mensagem de erro.

Exemplo correto: "eu sou bonito", porque é um conjunto de 3 palavras, onde a primeira é um pronome, a segunda é um verbo e a terceira um adjetivo.

Exemplo errado: "bonito sou eu", porque apesar de ser um conjunto de 3 palavras, a primeira não é um pronome. Nesse ponto, não importa o resto da entrada, o analisador sintático já retorna um erro neste ponto.

Assim, o analisador sintático verifica se os tokens estão localizados num contexto correto.

Ah, você pode estar perguntando: como o analisador sintático sabe que "bonito" é um adjetivo? Resposta: por causa do analisador léxico! O analisador léxico possui uma informação que "bonito" é um adjetivo e que, portanto, ele retorna ao analisador sintático que o símbolo "bonito" é um token "adjetivo".

Pronto... E assim os analisadores léxico e sintático ficam trocando informações, um envia pra outro e outro envia pra um, até varrer todo o código-fonte.

Review do livro XNA Game Studio Creator's Guide

Mykres fez uma pequena análise do livro XNA Game Studio Creator's Guide, um dos que eu queria comprar :)

Sou totalmente a favor dos livros! E espero que algum sobre XNA seja lançado aqui no Brasil! Vamos torcer!

Análise Léxica

Tudo é uma questão de abstração. É mais fácil tratar um texto a partir de cada letra ou a partir de cada palavra? Quando você lê um texto (este post, por exemplo), você lê letra a letra ou palavra a palavra? Claro que vc trata o texto como uma sequência de palavras, isto é, como uma sequência de símbolos léxicos (tokens).

A análise léxica é um processo que analisa uma entrada de dados, geralmente um código-fonte de um programa, e tem como saída uma sequência de tokens. Mas pra quê isso? A palavra-chave é: abstração! E assim como toda abstração, tudo isso é feito para facilitar (ou até viabilizar) o trabalho de alguém, nesse caso o do analisador sintático (ou parser). No caso da leitura deste post, a abstração de letras em palavras é para viabilizar o processo de leitura de textos.

Um código-fonte de um programa é, em princípio, uma sequência de caracteres sem sentido para um computador. O computador não entende a sequência de caracteres "i" seguido de "f", mas um analisador léxico apropriado retorna que "i" + "f" pode ser abstraído para o símbolo (token) "if", e isso é útil ao analisador sintático. E ao nosso cérebro! :)

Talvez seja necessário entrar em mais detalhes sobre a etapa da análise técnica, mas por enquanto isso basta. O analisador léxico é a primeira etapa de um compilador. Veremos melhor porque disso no próximo post quando eu falar sobre a análise sintática, e só depois a análise semântica.

Nem tudo é XNA

Nem tudo é XNA! Apesar de eu ter passado um tempo postando somente sobre o framework XNA, sem postar algo sobre outra atividade do meu curso de ciências da computação, tenho dado alguns passos no desenvolvimento da minha monografia, por exemplo. Também estou pagando outras disciplinas, onde, além de provas, são passados trabalhos práticos.

O importante é eu continuar estudando desenvolvimento de jogos em XNA e conseguir prosseguir no estudo de caso sobre a aplicabilidade dos AGraphs a um sistema de transformação de grafos, tema da minha monografia.

Também preciso falar sobre a XCell UFRN, a célula acadêmica da Microsoft, da qual faço parte, criada há um mês e pouco, motivo pelo qual eu ando estudando XNA. Mas isso fica pra depois. Por enquanto, quero logo que o grupo lance a página oficial e aí, sim, eu falo dela aqui :)

Meu jogo em XNA - parte 1

Bem, aqui eu começo uma série de posts sobre o meu jogo (joguinho na verdade) em XNA, feito com o objetivo de aprender os conceitos básicos de desenvolvimento de jogos com o framework da Microsoft.

Antes de eu começar a desenvolver um joguinho, ou melhor, de qualquer um começar a desenvolver um jogo, temos que pensar em como ele será exatamente. Claro que não pensei em criar um jogo 3D. Isso não tinha nem discussão. A discussão era sobre o estilo. Há também outras coisas a se discutir, mas vamos por partes! Aproveitei, então, uma idéia de um jogo minimamente interessante e decidi fazer um de estilo parecido, cujo objetivo é acertar um alvo (que escolhi ser um extraterrestre) com um míssel, disparado a partir de uma coisa, que escolhi ser uma nave. Calma, lá... falando assim, parece até que o jogo é O tal. Mas ele é o mais simples que pode ser. Literalmente!

O nome eu decidi depois que decidi qual o estilo do jogo, obviamente. Nome escolhido: Shooting.

Para atingir o objetivo do Shooting (ao longo do tempo vou adicionando novas características), tive que catar 3 figurinhas na Internet, a saber: a nave espacial, o alvo (um E.T.) e um míssel. Você também pode fazer seus próprios desenhos, mas como eu não tenho dotes artísticos, peguei na net mesmo. Ah, também peguei na net uma textura para o ponteiro do mouse.

Com as texturas em mãos, vamos refletir um pouco sobre as funções básicas do framework XNA, a saber: Initialize(), LoadGraphicsContent(), Update() e Draw(). Este post visa única e exclusivamente discutir introdutoriamente essas funções básicas a todos os jogos feitos em XNA.

Cada função já é razoavelmente bem explicada pelo próprio código gerado por padrão a partir do framework XNA assim que todo projeto é iniciado. Assim, temos o seguinte para a função Initialize():

"Allows the game to perform any initialization it needs to before starting to run. This is where it can query for any required services and load any non-graphic related content. Calling base.Initialize will enumerate through any components and initialize them as well."

Apertando a tecla SAP, isso significa: nesta função é onde o framework vai inicializar tudo que é necessário antes que o jogo comece a ser executado, como por exemplo, a configuração da resolução da janela em que o jogo vai executar (640x480?), as texturas, que no caso do meu jogo são a nave e o alvo (o míssil não é inicializado assim que o jogo começa, mas somente quando o jogador dispara algum evento num dispositivo de entrada, entendeu?), etc.

Na função LoadGraphicsContent(), o código gerado automaticamente pelo framework nos diz:

"Load your graphics content. If loadAllContent is true, you should load content from both ResourceManagementMode pools. Otherwise, just load ResourceManagementMode.Manual content."

Apertando a tecla SAP, isso significa: essa função é responsável por carregar no framework o conteúdo gráfico necessários ao jogo, como, por exemplo, a textura do mouse, textura do fundo de tela, etc...

Na função Update(), o framework no diz:

"Allows the game to run logic such as updating the world, checking for collisions, gathering input and playing audio."

Isto é, essa função é responsável pelo Loop principal do jogo. Aliás, todo jogo tem loop. Não importa se ele foi o primeiro jogo desenvolvido para um computador ou o último, todos têm um loop principal. Esta é uma das principais funções do jogo, pois faz a parte pesada do jogo, como detectar colisões.

Na função Draw(), o framework XNA nos diz:

"This is called when the game should draw itself."

Isto é, Draw é a função que desenha na tela de saída (monitor) o que a lógica do jogo diz que está acontecendo.

Este post, como eu já disse, visa somente mostrar um introdução sobre essas 4 funções básicas. Nos posts seguintes, discutiremos os conceitos envolvidos na lógica do jogo. Além disso, colocarei o fonte pra vocês. O importante é ir indo passo-a-passo, sem pressa, até porque também estou aprendendo.

Camadas do XNA

Pois bem... Uma ótima maneira de entender melhor sobre o que há por trás do XNA ou o quê a plataforma XNA faz para ajudar aos programadores de jogos a abstrair alguns conceitos é um estudo sobre as camadas do XNA.

Quanto mais baixa a camada a ser observada, mais baixo nível sua implementação se torna. E o que significa uma implementação de baixo nível? No que tange a este artigo, significa que você perde um tempo relativamente grande pra dar um passo relativamente pequeno no desenvolvimento da sua aplicação. Já tentou programar em Assembly? Assembly é uma linguagem de baixo nível. Códigos em assembly são difíceis de se ler, mas o pior é programar mesmo, pois são necessárias muitas linhas de código pra fazer, por exemplo, um "a + b", enquanto que em uma lingaugem de alto nível, uma operação "a + b" é... "a + b"! :)

Continuando, o XNA nos provê já muita coisa para abstrairmos as camadas de mais baixo nível dos jogos. Eu disse "mais baixo nível", e não "baixo nível" porque o objetivo do XNA é ser uma API para programar sobre o DirectX, que já tem o objetivo de ser uma API sobre uma programação de ainda mais baixo nível! Isto é, o XNA está um nível de abstração mais alto que o DirectX. E isso só ajuda a popularizar o desenvolvimento de aplicações, no caso aplicações de jogos.

É como o Windows. Ele é ruim? Depende. Ruim pra quem? Pra quem sabe ou quem não sabe? Pra quem "não sabe de nada", ele é ótimo. E o resultado? Todo mundo usa! XNA é ruim? Não sei. Me parece que não. E tem tudo pra dar certo. Mas uma coisa é certa: todo mundo vai usar! :D

Então vamos às camadas!

A camada mais abaixo é a camada do DirectX, ou melhor, o conjunto de API´s do DirectX: Direct3D, que é a camada responsável pelos gráficos 3D, XACT, a API responsável pelo gerencimento do áudio, XINPUT, que gerencia os dispositivos de entrada, como mouse, teclado e gamepad, XCONTENT, que gerencia o conteúdo da aplicação.

Por cima dessa camada do DirectX, há o núcleo do framework XNA, responsável pelo gerenciamento dos gráficos, sons, entrada, etc. Esse gerenciamento é feito por algoritmos e que para nós, em princípio, não interessa como são implementados, pois essa é a idéia de um framework: abstrair detalhes de implementação que não são da lógica do negócio para otimizar a produtividade.

Indo a mais um nível acima, temos as extensões do framework XNA, como os modelos de aplicações. Isso é ótimo porque o framework já nos fornece um jogo pronto, porém vazio, sem nada! (execute um projeto assim que for criado. Você verá uma tela azul durante a execução, isto é, um jogo que mostra somente uma tela azul, sem nenhuma interatividade). Assim, essas extenções do framework já adiantam muitas coisas na hora de começar um projeto.

Na camada mais acima, finalmente, é onde nós vamos programar colocando nosso fonte, classes, componentes, etc., onde de fato está o nosso trabalho, onde nossos neurônios vão trabalhar, tendo todo o resto abstraído, desocupando nossas cabeças e nos dando a possibilidade de se concentrar somente no jogo em si! Veja o tamanho da abstração! Valeu, Microsoft!

Figura retirada do WorkShop de AFurtado.

História do XNA

Tudo começou com o DirectX. DirectX é uma coleção de API´s para gerenciar tarefas relacionadas a multimídia, como os jogos. Ah, jogos para plataformas Microsoft (Windows, XBox, etc.). O nome DirectX vem do padrão de nomes no projeto inicial, onde cada uma das API´s começava com Direct, como por exemplo, Direct3D, DirectDraw, DirectSound, etc. DirectX, então, surgiu da união desses nomes num único pacote.

O resto é história. O DirectX se tornou a principal API utilizada para desenvolvimento de jogos. Foi universalmente aceito na indústria de jogos, principalmente por causa da API Direct3D, que possibilita a criação de gráficos tridimensionais em aplicações onde o desempenho é importante, como os jogos.

Os aplicativos são desenvolvidos utilizando a linguagem C++, que, dizem, é a melhor linguagem para se desenvolver jogos. Porém, como alguns de vocês já podem ter percebido, programar um jogo "do nada" em C++ não é pra normais.

Daí, a Microsoft, em 2002, teve uma idéia de criar uma API por cima do DirectX que possibilitasse programadores tirar as vantagens do DirectX a partir da plataforma .NET. Assim, surgiu a API Managed DirectX (MDX), que conseguiu a façanha de ter 98% do desempenho de uma aplicação DirectX nativa! Isso é um "feito"! Em 2006 saiu vários updates para o Managed DirectX, chegando até a versão 2.0.

O passo seguinte foi a criação do XNA: uma API construída utilizando como base o MDX, que possibilita a criação de aplicativos em C#, tanto para XBOX360 e Windows. O MDX 2.0 está descontinuado e a bola da vez é o XNA, que está em constante atualização!

Não sei se deixei claro, mas a moral da história é: desenvolver em XNA é ótimo para os iniciantes, pois possibilita ao programador se abstrair de detalhes de baixo nível, o que o DirectX não faz tanto assim! Isso significa que os grandes jogos, das grandes indústrias, não usam XNA para desenvolver seus jogos, mas DirectX puro.

Ah, só reforçando a mensagem: XNA está por cima do DirectX, o que implica que XNA é rápido, abrangente e tem muito potencial!

Meu joguinho em XNA

Olá, amigos,

passei ontem e hoje fazendo um joguinho simples em XNA. Já tinha feito alguma coisa parecida, mas tudo meio que às cegas, bagunçado, sem entender onde e como usar o quê, enfim. Foi um erro que cometi devido a minha pressa em aprender.

Então... nesses últimos dois dias eu estive fazendo e, principalmente, pensando o porque de cada linha desse meu joguinho. Se eu não entendesse alguma coisa, eu queimava os neurônios até conseguir entender, sem pressa.

Consegui entender muitos conceitos, tais como os métodos mais básicos de XNA (Initialize, Update, Draw, etc.), colisão simples usando retângulos, tratamento de entrada (mouse e teclado), entre outras coisas.

Em breve, explicarei cada detalhe do meu joguinho, passo a passo. Tentarei postar uma vez ao dia. No fim da "série", disponibilizo o código fonte pra vcs testarem e aprimorarem.

O que achei legal é que com os conceitos que usei nesse joguinho dá pra fazer muita coisa! Com colisão, vc pode criar vários joguinhos simples até uns mais avançados, do PacMan a um jogo de tiro (no caso, em 2D).

Outra coisa que aprendi e vou tentar passar pra vcs é como o XNA trabalha. Nada técnico, mas muito importante pra um estudante de computação.

É isso... Até mais!

Microsoft e os estudantes

A Microsoft está me surpreendendo. Ela tem disponibiizado muita coisa para os estudantes aprenderem suas tecnologias! Qual o programador que nunca ouviu falar do portal MSDN? (E há mais coisas no portal "original")

Pois bem, neste mesmo portal, há um fórum para a discussão e sugestões sobre o conteúdo técnico MSDN. Vale a pena se cadastrar nele e dá uma olhada de vez em quando.

Um outro fórum de discussões bastante interessante é o Creators Club Online (inglês). Além de discussões, como por exemplo, design, algoritmos, etc, o site possui muitos tutoriais, exemplos, starter´s kit, artigos, etc. Vale a pena favoritá-lo.

Ainda bem que é certo que a Microsoft irá continuar a "patrocinar" os estudantes com sites deste tipo, afinal ela é uma empresa altamente capitalista, que depende diretamente do uso de suas tecnologias.

Só quem ganha somos nós! :)

XNA Workshop 2.2 por AFurtado

O campeao mundial da Imagine Cup 2005/2007 e do XNA Challenge Brazil 07 publicou um Workshop muito interessante para os aprendizes, como eu.

Veja o post dele abaixo:

____

Com grande satisfação compartilho com vocês o XNA Workshop 2.0 no SharpGames. São cerca de 130 slides (em português) e referências para código-fonte, vídeos e outros recursos que justificam, introduzem, explicam e demonstram na prática o XNA.

O workshop deve ser utilizado tanto por replicadores da tecnologia XNA quanto por aqueles que desejem se capacitar em geral.

Registro aqui meus agradecimentos ao Jalf e ao Bruno Evangelista pelo apoio na criação dessa segunda versão do workshop. Solicito a todos feedback e contribuições para que possamos continuar evoluindo o material e disseminar o uso do XNA em nossa comunidade.

Favor repassar aos interessados e bom proveito!

[]s
-- AFurtado
http://afurtado1980.spaces.live.com

O workshop está disponível para download aqui, temporariamente (enquanto checo meu problema com o uploader do SharpGames).

Update 09/10/2007: versão 2.1 evoluiu para 2.2. Adicionadas informações sobre a categoria de games XNA na Imagine Cup 2008.

Update 09/10/2007: versão 2.0 evoluiu para 2.1. Adicionadas informações sobre mais starter kits, mini-games e samples, de modo a refletir melhor os recursos oferecidos pelo creators.xna.com.

Framework... Frame o quê?

De vez em quando faço uso da palavra "framework" aqui neste blog para falar da tecnologia XNA. Afinal, o XNA é um framework! .NET é um framework! Eu já tive dificuldade com essa palavra (no que ela significa). E entender o que é um framework ajuda a entender um pouco mais o seu código quando vc estiver desenvolvendo seus jogos. Conhecimento nunca é demais.

Pois bem, procurei pra vcs um artigo ou qualquer outra coisa que descrevesse de uma maneira simples e intuitiva o que seria um framework, enfatizando a diferença entre ele e as bibliotecas - pois pra mim um framework era uma biblioteca.

A conclusão que podemos tirar ao ler este artigo é que os frameworks são feitos com a intenção de facilitar o desenvolvimento de softwares, permitindo aos desenvolvedores se concentrarem na lógica de negócio (alto nível da aplicação) em vez de perder tempo nas implementações de baixo nível, geralmente complexas. Os frameworks também limitam as escolhas durante o desenvolvimento e isso faz com que tenhamos ganho de produtividade, muito importante nos sistemas complexos.

A diferença entre um framework e uma biblioteca é, basicamente, que a biblioteca me permite reaproveitar apenas o código. Já um framework permite reuso de análise, design, código, etc.

Bibliotecas são o "velho" conceito e elas são apenas um conjunto de classes/métodos para seu código chamar e ter alguma funcionalidade. Frameworks, por outro lado, contém alguma funcionalidade em comum da aplicação, chamando nosso código (e não o nosso código chamando).

Outras vantagens dos frameworks são a flexibilidade e extensibilidade. Já como desvantagem, um framework com muita funcionalidade pode causar um aumento da complexidade da aplicação.

Leia o artigo aqui.

Livros sobre C# e XNA

Claro, não podemos dispensar os livros. Com eles a gente pode pesquisar a qualquer hora, independente de um PC. Eles também possui uma lógica na explicação das coisas (ou pelo menos, essa seria a intenção do cap. 2 ser depois do 1), além de empolgar (a mim, pelo menos).

Aqui vai uma lista (de desejos?) de livros sobre XNA, seguida de uma lista de C#, que eu julguei serem os melhores.

 

XNA:

Professional XNA Game Programming

XNA Game Programming Recipes

Microsoft(R) XNA(TM) Unleashed

Microsoft® XNA Game Studio Creators Guide

 

C#:

Programming C#

Professional C# 2005

Accelerated C# 2005

C# Cookbook

Microsoft® Visual C#® 2005 Step by Step

 

Enquanto que meu AdSense não vinga, no momento estou sem livros de XNA (só com a Internet) e com um e-book grátis de C# - .Net Book Zero. Nada de livros pagos.

Valeu!

Código fonte do jogo Pong

No post 10 passos para fazer seu jogo em XNA!, o 8º passo é estudar/fazer o joguinho Pong (veja o vídeo abaixo). Esse passo é muito importante para aqueles que querem ver mais de perto como a coisa funciona. Há vários exemplos do jogo Pong na net, como o postado anteriormente, mas este link, além do fonte, tem um tutorial sobre o jogo Pong, incluindo explicações sobre os métodos mais básicos! :)

 

Vídeos de XNA no Channel 9

O Channel 9 é mais uma via de acesso a conteúdo sobre tecnologias da Microsoft, como C#, por exemplo. Lá, há alguns vídeos sobre o framework XNA. Vale a pena dar uma olhada, principalmente se vc souber "ouvir" em inglês :)

Alguns links:

• XNA Development Part 1: Getting Started with the XNA Framework
• XNA Development Part 2: Differences Between Windows and XBOX Game Development
• XNA Development Part 3: The Five Essential Gaming Methods
• XNA Development Part 4: Facing (or Aiming at) Your Opponent
• Looking at XNA - Part One
• Looking at XNA - Part Two
• Jeff Henshaw and David Alles - Xbox 360 and Media Center: Living room of the future
• Michael Tipping - Machine learning research for use on Xbox

Alguns vídeos vc pode até baixar para assisti-los off-line.

Talvez eu comente algum vídeo depois.

Valeu!

XNASharpNES - Emulador NES em XNA

XNASharpNES é um Emulador NES (Nintendo Entertainment System) para Xbox 360 usando XNA. Ainda não suporta alguns jogos, mas a equipe está trabalhando para finalizá-lo em breve.

O emulador já suporta a emulação básica, e um bom número de roms. Ainda falta adicionar algum suporte, como o teclado e o Gamepad (controle do videogame), uma customização dos controles do Gamepad, entre outras coisas.

Vamos esperar as próximas versões!

Abaixo, um vídeo demonstrativo do emulador executando algumas roms.

Visite a págna oficial para mais informações.

10 passos para fazer seu jogo em XNA!

1. Baixe o Visual C# Express: é o ambiente do desenvolvedor XNA. Baixe e instale antes de qualquer outro programa.

2. Baixe o XNA Game Studio Express: baixe e instale. Isso vai adicionar recursos ao Visual C# para programar em XNA.

3. Baixe o framework XNA: baixe e instale para poder rodar (e testar) seus jogos no seu próprio Windows.

4. Aprenda C#: C# é a linguagem de programação usada na plataforma XNA. Procure na Internet que tem muitos exemplos. Por exemplo, o repositório MSDN tem uma série de vídeos para aprender C#. São mais de 10 horas de treinamento! Há também eBooks grátis! :)

5. Verifique os exemplos do XNA GSE: o jogo Space War, por exemplo. Basta criar um novo projeto e escolher o "Spacewar Windows Stater Kit".

6. Aprenda XNA: use a Internet novamente para procurar por vídeos, livros, tutoriais sobre XNA.

7. Aprenda mais XNA: Nunca se superestime :)

8. Estude/Faça o jogo Pong: após o jogo Space War, verifique o Pong (há vários exemplos do jogo Pong na Internet).

9. Estude bem os códigos: verifique os códigos de outras pessoas. Há sites repositórios onde podemos verificar como outros desenvolvedores trabalham em seus jogos.

10. Publique seu jogo e seu código-fonte comentado! :D

C# vs. Java

Olá,

Aqui vai um link atualmente útil para mim nos meus estudos da faculdade: comparação da sintaxe entre C# e Java. Há muitos artigos que comparam essas duas linguagens, mas a maioria sempre tem um monte de textos. Como eu estou meio sem tempo, esse link serve porque é direto.

Abaixo, o Hello World nas duas linguagens retirado do site:

Java:

class Hello
{
public static void main(String[] args)

    {
    System.out.println("hello, world");
}
}

//you must save the file with .java extension
//from command line to compile it
>javac Hello.java
//generate a Hello.class file and run it
>java Hello

C#:

class Hello
{
static void Main()      {
    System.Console.WriteLine("hello, world");
}
}
//by convention, save the file with .cs extension
//from command line to compile it
>csc Hello.cs
//generate a Hello.exe file and run it
>Hello

Não esquecendo que os jogos em XNA são feitos em C#.

Valeu!

Página pública do meu Google Reader

Olá,

voltei :) Após mais de uma semana sem postar, eu voltei. Agora, as atualizações voltaram ao normal, espero.

Este post visa publicar a página "pública" do meu Google Reader. Assino cerca de 60 feeds (ou blogs, como queira), a maioria esmagadora de tecnologia. Quando leio algo que acho interessante, eu compartilho neste link aqui (para compartilhar no Reader, basta, na notícia, clicar em "share"). Enfim, uma página pública (de acesso a todos) em que compartilho o que leio. E ela contém um feed. Assinem! :)