O XNA Game Studio 2.0 foi finalmente lançado! :D
Com muitos novos recursos - a possibilidade de desenvolver jogos multiplayers e também de suportar todas as versões (e não só a Express) do Visual Studio 2005 são os melhores exemplos de tais recursos que posso citar - o framework XNA promete finalmente decolar. Para pegar sua cópia e obter todas as informações necessárias , clique aqui.
Para mais informações, visite o XNA Team Blog.
As classes que resolvi implementar no meu joguinho Shooter são:
tiro: classe principal do jogo. Contém os princiais métodos explicados aqui (parte 1).
content: super-classe dos objetos do jogo. Contém os métodos em comum a todos as outras classes. Tudo feito para centralizar tudo numa classe, facilitando, assim, as mudanças futuras no jogo, bem como facilitando, também, o aprendizado.
nave: classe com métodos que tratam a nave, como por exemplo a atualização da posição na tela.
target: classe com métodos que tratam o alvo, como por exemplo a atualização da posição na tela.
missel: classe com métodos que tratam o míssel, como por exemplo a atualização da posição na tela.
Por mais que as classes missel, nave e target tratem da posição dos respectivos objetos na tela, como eu disse acima, não vi como colocar esse método na classe content, visto que o alvo se mexe com velocidade e direção diferentes do míssel, por exemplo. Na classe content há métodos universais como draw() e declarações de variáveis usadas nas classes que herdam de content, como uma variável pra guardar a posição.
Também estou criando uma classe pra tratar da explosão do alvo, ou seja, pra ser chamada quando o míssel colide com o alvo, mas estou enfrentando dificuldades. Se eu realmente conseguir fazer o que quero, postarei aqui informações.
Não falei da classe que há em todo jogo: program. Mas essa classe dispensa comentários, pois serve apenas pra rodar o jogo. O framework a cria automaticamente.
Não falarei neste post sobre a classe do mouse, nem a classe sound. Farei um post específico para o tratamento do mouse e do som.
Até mais.
Já faz 4 dias, mas só estou postando agora esta notícia porque estava ocupado fazendo um compilador pra uma disciplina da minha faculdade.
Mas... Saiu a versão 2.0 do XNA! Ainda é um beta, mas a equipe do XNA Team Blog disse que resta pouco pra lançar a versão final.
Pelo que vi, ainda falta alguns recursos que estarão na versão final. Mas a maior parte deles já está implementado no beta. Outra coisa é que a versão 2.0 é compatível com qualquer Visual Studio, seja Professional, Express, ou qualquer outra. Outra ótima notícia é que podemos ter as duas versões, 1.0 e a 2.0, instaladas no computador sem conflito algum! Enfim, tem muitos recursos novos, como a possibilidade de desenvolver jogos multiplayer, e minha opinião é que com essa versão o XNA vai definitivamente decolar.
Apesar de tudo, eu ainda vou continuar com a versão 1.0, pois ainda estou na fase de estudo e não tem pra quê tantos recursos, pelo menos por enquanto. Quando sair a versão final, aí sim será hora de migrar.
Qualquer outra novidade sobre a versão 2.0 estarei postando aqui, incluindo as mudanças que tem que ser feitas nos códigos já feitos (parece que a Microsoft disponibilizará um conversor da versão 1.0 para a 2.0, justamente pra evitar esse trabalho, o que vai ajudar bastante!).
Valeu!
A Farseer Physics Engine é um engine de efeitos de física para jogos 2D desenvolvidos em XNA e Silverlight. Parece que ela é bastante fácil de usar, focando na usabilidade, simplicidade, permitindo a criação de jogos bem feitos. Suporta vários tipos de colisão, entre outros recursos. E o melhor: é open-source! O que significa open-source pra mim? Estudar! :)
Enfim, baixei aqui no meu PC e já está na listinha de itens a estudar nas férias :D
Achei uma entrevista do designer da Farseer.
Mais informações no site oficial.
Achei bem estranho no início o modo como se imprime textos no jogo feito em XNA. Acha que era algo como
FunçãoImprimirTexto("texto a imprimir");
Será que não sou amante de C? Ainda bem que não é a assim :D
O processo é semelhante a colocar um objeto na tela. Nos meus estudos de XNA, fazendo meu joguinho Shooter, queria imprimir algum texto na tela, não porque é importante ao jogo, mas para o estudo mesmo. Por exemplo, quando clicamos sobre a nave, eu queria que um texto fosse impresso na tela ("mouse colidiu com nave"). Além do estudo de XNA em si, é importante eu saber que o mouse está interagindo de alguma forma com o objeto nave (ou ET, o alvo) para posteriormente eu, quem sabe, desenvolver o recurso de seleção de objetos (como num jogo de estratégia, onde clicamos numa unidade e dizemos aonde queremos que ela vá).
Enfim, além do exemplo do meu joguinho Shooter, o tutorial How to Print Simple Text onto the Screen explica muito bem essa parte. Boa leitura!
Mais sobre meu joguinho: estive comentando o código e disponibilizarei em breve...
As texturas são parte fundamental de um jogo. Não preciso explicar porquê, né? Coloco aqui as texturas do Shooter, meu joguinho que estou fazendo para estudar XNA.
Nave principal
Alvo principal (me arranjem uma figura melhor!)
Background (textura de fundo)
Míssel
Para salvar no seu computador, clique nelas para abri-las no tamanho original, e só depois salve.
Claro que você pode ter suas próprias texturas. Basta fazer as mudanças necessárias para usá-las.
Nos próximos posts estarei falando sobre a parte do Audio em XNA que estudei esta semana. Antes de explicar o audio, porém, talvez eu explique cada classe que criei. Eu disse talvez porque não tenho uma sequência pronta do que postar. Vou fazendo em "tempo real". Aceito sugestões. Só no fim que postarei o código.
Acabou de ser anunciado o II Microsoft XNA Challenge. Este ano o tema é “Meio Ambiente Sustentável”. O ganhador deste ano participará do Microsoft Academic Days on Game Development in Computer Science Education (http://www.microsoft4me.com/faculty/events/adgd2008/), evento acadêmico sobre o desenvolvimento de jogos em cursos de Ciência da Computação que será realizado a bordo do Celebry Century, num cruzeiro marítimo saindo de Miami, nos EUA com destino a Port Key e Cozumel, com as despesas de transporte e hospedagem totalmente pagas. Muito bom, né? Pena que não vou participar, pois meu conhecimento ainda é pequeno em XNA.
Um dos principais conceitos envolvidos no desenvolvimento de jogos é a colisão. Há várias maneiras de se tratar colisões em XNA, como a colisão por retângulos e por pixel. The Road Not Taken é um tutorial passo-a-passo que explica colisões por cores. Mas, hein? Colisão por cores é quando um objeto não pode ficar junto (ou separado) de uma cor. Não sei se deu pra entender. Mas no exemplo desse tutorial isso funciona muito bem, pois quando o carrinho sai da cor cinza, ele "colide". Enfim, boa leitura! :)
Saiu o site de gerenciamento das Células Acadêmicas prometido pela Microsoft - o Microsoft Net Cell 2.0. Acesse-o para cadastrar sua célula e começar a gerenciar as atividades dela.
Pra quem ainda não sabe o que é uma Célula Acadêmica, coloco aqui um trecho retirado do FAQ do site:
"Uma Célula é um grupo de estudo formado por estudantes e professores, unidos em torno do objetivo comum de desenvolver, aprender e alavancar suas carreiras de uma maneira eficaz. Mais que simples grupos de estudo, as Células oferecem uma oportunidade única de aprender ou de reforçar conceitos e técnicas que são exigidas no mercado de trabalho, que já dão valor às Células e os profissionais que nelas são formados. As Células recebem a assessoria direta da Microsoft mediante recursos acadêmicos online, programas acadêmicos, competições e outros guias."
Até mais!
Um tutorial foi lançado estes dias por Nick Gravelyn sobre o efeito de refração em sprites 2D em XNA. Refração é o desvio da trajetória da luz. Por exemplo, quando a luz passa por um vidro, lente de óculos, água ou até uma superfície quente. Isso é bastante útil em muitos jogos.
Acesse aqui o tutorial e boa leitura.
Cops and Robbers é um joguinho relativamente simples. Relativamente porque ele é bem simples ao ponto de você jogar e dizer: que jogo inútil! Mas, por outro lado, ele é muitíssimo útil para aprender alguns conceitos de programação de jogos em XNA :D
Na XCell, célula acadêmica da Microsoft na qual faço parte, foi decidido na última reunião os pontos-chave para desenvolvermos um joguinho do mesmo nível que sirva futuramente (o mais breve possível) para darmos um curso de extensão sobre jogos na universidade. Não vou entrar em detalhes agora (a XCell terá uma página em breve com todos os detalhes), mas a primeira das etapas é estudarmos alguns conceitos, e é aí onde pode entrar esse joguinho. Eu disse pode, porque de repente eu acho outro melhor.
Bem, os conceitos basicamente foram divididos em três partes: telas (como tela do jogo, menus, etc.), audio e a lógica do jogo. Eu, por enquanto, vou estudar a parte do audio e esse joguinho me parece ótimo pra começar! Ele possui som ambiente e sons eventuais (quando algum evento acontece no jogo).
É isso, espero que essa parte não me dê muito trabalho. Não sei de nada de audio por enquanto, mas quero logo resolver isso pra poder ajudar o amigo que ficou com a lógica do jogo, beeem mais interessante :)
A biblioteca XNA Post Processing Library é uma biblioteca para pós-processamento em imagens, escrita em C# para XNA por um tal de Mahdi Khodadadi Fard. Apesar de está ainda em desenvolvimento, já faz um monte de coisas, como por exemplo, o efeito de "ondas de choque", que talvez seja útil para a XCell (célula acadêmica da Microsoft a qual faço parte).
O mesmo Mahdi Khodadadi Fard lançou também a XNA Gif Animation Library, também escrita em C# para XNA, que facilita o gerenciamento de Gifs (imagens animadas). Um exemplo do uso de um gif, que talvez seja útil a XCell, pode ser um objeto explodindo, como um asteróide, onde você tem uma única imagem já com toda a sequência de movimentos (a explosão em si), e a carrega num momento oportuno.
Segundo o autor, as bibliotecas (muito melhor falar libs) têm como objetivo tornar o uso do poder gráfico da GPU - unidade gráfica de processamento - mais fácil e intuitivo.
Como o paradigma de programação orientada à objetos (POO) é muitíssimo importante para a criação de jogos em XNA, aqui vai um tutorial bem simples, hospedado no GdH, e que achei legal :)
Tenho lido o livro Use a Cabeça! Java e ele tem se mostrado o melhor livro de POO que já vi. Apesar dele ensinar POO em Java, os conceitos de POO em C# são idênticos!
Olá...
Neste link há alguns livros de computação disponíveis gratuitamente para download :D
Há livros de C, C#, Python, Lisp, etc... Vejam lá!
Há também outros links acessíveis a partir desta página:
Business-Software-Books.us
CAD-CAM-Books.us
Computer-Books.us
Database-Books.us
Java-Books.us
Linux-Books.us
Vamos aproiveitar! Valeu!
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...
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.
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.
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.
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!
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! 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 :)
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.
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!
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!
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!
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! :)
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.
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.
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
Microsoft(R) XNA(TM) Unleashed
Microsoft® XNA Game Studio Creators Guide
C#:
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!
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! :)
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:
Alguns vídeos vc pode até baixar para assisti-los off-line.
Talvez eu comente algum vídeo depois.
Valeu!
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.
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
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#.
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! :)
O site PCMechanic publicou um vídeo sobre como iniciar na plataforma de desenvolvimento XNA. Começa com uma busca no Google, mostra o XNA Developer Center, onde faz download, onde você faz isso, aquilo, etc. Enfim, pra quem está totalmente perdido sobre como iniciar a desenvolver seus próprios jogos [para plataformas Microsoft], este vídeo é muito bom!
Não sei, não deve ser um bug, mas alguém tem alguma idéia do que possa ser?
Eu publiquei um post com o marcador 'Monografia'. Só que o meu blog não "pegou" este marcador. Tentei de tudo (acho), inclusive editar o marcador, repostar o dito cujo, enfim... Aí, hoje, ainda agora, eu publiquei mais um post sobre minha monografia e o marcador apareceu! Menos mau! Mas ainda conta somente como '1' post com tal marcador sem-noção :( O estranho é que se vc clicar no marcador, aparece os dois posts, eliminando a possibilidade de erro de digitação na identificação do marcador (caso vc tenha pensando nisso).
Enfim, acho difícil ser um bug porque se fosse, não teria acontecido só comigo e aí os responsáveis na Blogger já teriam tomado ciência e solucionado o problema. Se alguém souber resolver isso, posta aqui.
Como minha monografia tem o objetivo de estudar a aplicabilidade dos AGraphs em sistemas de transformações de grafos, antes de entrar efetivamente em transformações de grafos, venho aqui dar uma introdução básica a grafos.
Grafos são um dos mais importantes objetos de estudos na ciência da computação. São formados por nós (na figura, os nós são os círculos) e arestas que interligam esses nós. Basicamente, eles são capazes de representar uma informação qualquer. Por exemplo, um mapa de estradas é muito bem representado por um grafo. Nesse caso, os nós seriam as cidades e as arestas seriam as estradas que interligam essas cidades. Outros exemplos podem ser: uma rede de computadores (cpu e cabos de rede), uma estrutura de um site (páginas html e links que ligam a outros html´s), o Orkut (o que seriam os nós e o que seriam as arestas?), enfim, tudo que possui uma dependência entre elementos e dados pode ser representado por um grafo.
Mais formalmente, um grafo consiste de um conjunto de vértices V e um conjunto de arestas E, direcionadas ou não, onde cada aresta 'e' em E tem um vértice origem s(e) e um vértice alvo t(e) em V. Uma aresta não direcionada que sai do vértice A e chega ao vértice B é igual a uma aresta que sai de B e chega em A. Já num grafo direcionado, que chamamos de digrafo, as duas direções são contadas como sendo arestas distintas.
Assim como toda estrutura de dados na ciência da computação, grafos armazenam informações. Se eles armazenam, também tem que ser possível acessar tais informações. A tarefa de acessar um dado se resume em varrer o grafo, nó a nó, enquanto não encontramos o dado buscado.
Enfim, os grafos têm como uma das principais vantagens a representação visual de informações. Eles também já foram estudados em demasiado e já são muito bem compreendidos pelos pesquisadores. Como já disse, fornecem uma abordagem simples e poderosa a uma variedade de problemas típicos na ciência da computação, permitindo manipulações eficientes das informações neles armazenadas.
Provavelmente, o próximo post será sobre transformações de grafos. Na verdade, esse é o principal alvo da minha monografia, mas para chegar aí, eu tive de dar uma introdução básica a grafos.
Até o próximo post!
Olá,
resolvi postar algumas maneiras de se pesquisar material em XNA. Veja bem, não são sites, mas pesquisas (incluindo blogs, feeds, indexadores, etc.):
Grandes buscadores:
- Google (retorna 6 milhões de resultados)
- Live Search (190 mil resultados)
- Yahoo (quase 5 milhões de resultados)
- (...)
Indexadores de blogs:
- BlogBlogs (não entendi porque o site não acha nada procurando 'xna' em blog - acha somente em posts)
- Technorati (197 blogs no resultado da pesquisa. O primeiro resultado, Ziggyware, é um blog muito bom!)
- Google Pesquisa de Blogs (retorna 88 mil postagens de blogs)
- (...)
Pesquisar por feeds:
- Live Search Feeds (9 mil e 500 resultados do termo 'xna' em feeds)
- (...)
Grupos:
- Google Groups (mais de 80 mil resultados)
- Yahoo Grupos (12 resultados, a maioria de células acadêmicas que estudam o XNA)
- (...)
Sites importantes:
- Coding4Fun (esse site me pareceu o mais completo que achei até agora)
- TurboSquid (esse site me pareceu o segundo mais completo :)
- CodePlex (repositório de códigos, incluindo de XNA, C#, etc... Muito bom!)
- (...)
Básicos:
- MSDN/XNA (pesquisa sobre 'XNA' no repositório MSDN. Tem coisa demais!)
- XNA Frequently Asked Questions
- Begginner Developer Learning Center
- Microsoft XNA Game Studio Express 1.0 Refresh
- (...)
Obs.: "(...)" significa que você pode indicar alguma referência :)
Espero que ajude...
O Plantão INFO publicou sobre o CB Model Pro, um programa gratuito que desenha em 3D. Mais um opção!
Valeu!
Olá...
A proposta deste meu blog pessoal é falar das minhas atividades acadêmicas. Uma delas, a mais importante no momento, é a minha monografia. Infelizmente, o tempo não deixa eu entrar em muitos detalhes, mas farei o melhor que puder.
O primeiro post sobre meu relatório de fim de curso será, obviamente, a descrição do trabalho em si. Na verdade, uma pequena descrição :)
Para quem está antenado às tendências da tecnologia computacional nos dias de hoje, é sabido que há uma crescente necessidade de representação de informações (dados). Com isso, surgiu a necessidade de formatos (padrões?) que permitam o intercâmbio dessas informações.
Isso posto, o formato AGraphs[1] nasceu com esse objetivo no departamento de informática (DIMAp) da minha faculdade (UFRN). Para cumprir os objetivos expostos acima, os AGraphs usam grafos tipados e direcionados, possuindo bibliotecas de funções que possibilitam a manipulação da estrutura de dados.
A minha monografia é parte de um estudo proposto sobre o formato AGraphs. O objetivo do estudo é verificar a sua aplicabilidade nas transformações de grafos (onde falarei num post futuro), um paradigma da computação que descreve sistemas de software desde a especificação até seu uso, e que tem grande potencial.
Por enquanto, é só :)
No próximo post, vou falar um pouco de grafos. Depois, aí sim, entrarei em transformações de grafos! Até mais!
Nota:
1. SENA, Demóstenes. AGraphs: definição, implementação e suas ferramentas. Tese (Mestrado) - DIMAP, UFRN, 2006.
Excelente lista de sites web 2.0 fora dos EUA.
Web 2.0 em todos os cantos: Parte 1, Parte 2 e Parte 3.
Fonte: MeioBit
Com relação aos sites web 2.0 brasileiros, o site Lista 2.0 BR fornece uma boa lista também.
O XNA é uma nova plataforma de desenvolvimento de jogos para Windows (PC) e XBOX360, ambos da Microsoft. A plataforma possui um conjunto de ferramentas disponibilizadas que facilitam o desenvolvimento e gerenciamento de jogos. Possui também um extenso conjunto de bibliotecas específicas, o que facilita bastante o reuso de código-fonte.
Para começarmos a desenvolver em XNA, precisamos da sua principal ferramenta, que é o XNA Game Studio Express, uma IDE voltada para o uso do XNA - e consequentemente para o desenvolvimento de jogos. Apesar do XNA Game Studio Express, todo o desenvolvimento em si é feito pelo Microsoft Visual C# Express, sendo o XNA Game Studio Express uma instância do Visual C#, como se fosse um plugin ou uma biblioteca. Portanto, por enquanto só é possível desenvolver em XNA usando a linguagem C#.
Basta baixar e instalar as ferramentas citadas para iniciarmos o desenvolvimento em XNA. Após iniciar o Visual C#, basta clicar em "Create/Project" ou "File/New Project" e clicar na opção desejada - "Windows Game", como por exemplo.
Observe que um projeto básico foi criado, onde a partir dele é que faremos o resto. Se vc pressionar F5 (compilar e executar projeto), verá uma tela sem nada pra fazer. Isso já é muita coisa! :)
Vou terminando por aqui. Acredito que consegui dar uma visão geral do que seria esse XNA. Nos próximos posts irei entrar em mais detalhes. Qualquer dúvida, entre em contato!
Uma das linguagens que estou estudando este semestre é Java (sim! Estudar Java e C# ao mesmo tempo é bem complicado, mas antes fosse só isso: também estou vendo C). Conhecia o bom livro dos Deitel, Java Como Programar, mas não o tinha. Então fui pesquisar um outro livro, mais barato e menos detalhado (ou seria mais direto?).
Pesquisei e encontrei o livro Use a Cabeça! Java. À primeira vista, eu já me identifiquei com ele. É um livro ótimo de ler, dando bastante ênfase no projeto orientado a objeto, etc., e o que eu mais queria: direto!
Recomendo!
Olá...
este é um post inaugural :)
Neste meu blog, irei colocar detalhes das minhas atividades acadêmicas. Entre as que darei mais ênfase estão (1) a minha monografia e (2) as atividades da célula acadêmica da Microsoft sobre o framework XNA.
Nos próximos posts irei detalhar cada uma dessas atividades supracitadas. Aguardem...
