Olá galera, neste pequeno tutorial iremos aprender como colocar texto na tela do jogo (SpriteFont), recurso muito utilizado nos jogos para informar quantidade de vida, de munição, posição dos jogadores, etc…

Nosso objetivo neste tutorial, vai ser colocar uma informação da posição X e Y do fantasma que criamos na aula passada. Para aqueles que não acompanharam, basta fazer download do projeto aqui.

Vamos começar então.

Passo 1: Abra o projeto do fantasma e vamos  primeiramente criar um Sprite Font que é um arquivo XML que contém informações sobre a fonte, tamanho, espaçamento entre letras, etc… Para criar um Sprite Font, clique com o botão direito sobre a pasta Content e selecione a opção Add -> New Item. Selecione o Template Sprite Font e por fim de um nome a esse arquivo. Vamos dar o nome de Arial (pois vamos usar a font arial).

Passo 2: Abra o arquivo Sprite Font criado e faça as seguintes modificações:

<FontName>Arial</FontName>

Passo 3: Uma vez configurado nosso arquivo de fonte vamos então voltar para a classe do jogo e criar os objetos responsáveis por ler e interpretar nosso arquivo. Abra o arquivo Game1.cs e dentro da classe crie o objeto SpriteFont fontArial.

namespace MeuPrimeiroMovimento
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        // Textura que vai ser desenhada na tela
        Texture2D fatasma;
        // Posicao da textura na tela. x = 100, y = 100
        Vector2 position = new Vector2(100, 100);
        // Teclado a ser usado
        KeyboardState keysboardState;
        // A velocidade que vamos movimentar a textura
        float speed = 5.0f;
        SpriteFont fontArial;
        .
        .
        .

Passo 4: A classe SpriteFont é responsável por gerenciar o conteúdo carregado do nosso arquivo de fonte. Da mesma forma como carregamos uma textura, vamos carregar nossa fonte em nosso objeto no método LoadContent():

protected override void LoadContent()
{
    spriteBatch = new SpriteBatch(GraphicsDevice);

    // Carregando a textura do fastama .PNG
    fantasma = Content.Load<Texture2D>("fantasma");
    fontArial = Content.Load<SpriteFont>("Arial");
}

Passo 5: Agora tudo o que precisamos fazer é desenhar o texto na tela através do método Draw(). Para isso vamos usar o método DrawString.

protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.CornflowerBlue);
    spriteBatch.Begin();
    spriteBatch.Draw(fantasma, position, Color.White);
    spriteBatch.DrawString(fontArial, "Posicao X = " + position.X.ToString(), new Vector2(10, 10), Color.White);
    spriteBatch.DrawString(fontArial, "Posicao Y = " + position.Y.ToString(), new Vector2(10, 30), Color.White);
    spriteBatch.End();
    base.Draw(gameTime);
}

Pronto, agora é só compilar e ver o resultado.

Segue o código completo:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;
<pre>namespace MeuPrimeiroMovimento
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        // Textura que vai ser desenhada na tela
        Texture2D fatasma;
        // Posicao da textura na tela. x = 100, y = 100
        Vector2 position = new Vector2(100, 100);
        // Teclado a ser usado
        KeyboardState keysboardState;
        // A velocidade que vamos movimentar a textura
        float speed = 5.0f;
        SpriteBatch fontArial;

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

        protected override void Initialize()
        {
            base.Initialize();
        }

        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);
            // Carregando a textura do fastama .PNG
            fantasma = Content.Load<Texture2D>("fantasma");
            fontArial = Content.Load<SpriteFont>("Arial");
        }

        protected override void UnloadContent()
        {

        }
        protected override void Update(GameTime gameTime)
        {
            // Declaramos o teclado
            keysboardState = Keyboard.GetState();
            // Tecla para cima
            if (keysboardState.IsKeyDown(Keys.Up))
            {
                position.Y -= speed;
            }
            // Tecla para baixo
            if (keysboardState.IsKeyDown(Keys.Down))
            {
                position.Y += speed;
            }
            // Tecla para esquerda
            if (keysboardState.IsKeyDown(Keys.Left))
            {
                position.X -= speed;
            }
            // Tecla para direita
            if (keysboardState.IsKeyDown(Keys.Right))
            {
                position.X += speed;
            }

            base.Update(gameTime);
        }
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);
            spriteBatch.Begin();
            spriteBatch.Draw(fantasma, position, Color.White);
            spriteBatch.DrawString(fontArial, "Posicao X = " + position.X.ToString(), new Vector2(10, 10), Color.White);
            spriteBatch.DrawString(fontArial, "Posicao Y = " + position.Y.ToString(), new Vector2(10, 30), Color.White);
            spriteBatch.End();
            base.Draw(gameTime);
        }
    }
}

Abraços, espero que tenham gostado.

Neste rápido tutorial você verá como mover um sprite pela tela. Vamos começar então ?

Passo 1: Inicie um novo projeto e chame-o de MeuPrimeiroMovimento, e copie a imagem abaixo para dentro da pasta Content do projeto. E adicione a imagem ao projeto do jogo.

fantasma.png

Passo 2: Faça as seguintes declarações na classe principal do jogo (“Game1.cs”)

namespace MeuPrimeiroMovimento
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        // Textura que vai ser desenhada na tela
        Texture2D fatasma;
        // Posicao da textura na tela. x = 100, y = 100
        Vector2 position = new Vector2(100, 100);
        // Teclado a ser usado
        KeyboardState keysboardState;
        // A velocidade que vamos movimentar a textura
        float speed = 5.0f;
        .
        .
        .

Passo 3: Carregue a textura (imagem) no método LoadContent()

protected override void LoadContent()
{
    spriteBatch = new SpriteBatch(GraphicsDevice);

    // Carregando a textura do fastama .PNG
    fantasma = Content.Load<Texture2D>("fantasma");
}

Passo 4: No método Update(GameTime gameTime), vamos inserir toda lógica de movimento do sprite

protected override void Update(GameTime gameTime)
{
    // Declaramos o teclado
    keysboardState = Keyboard.GetState();
    // Tecla para cima
    if (keysboardState.IsKeyDown(Keys.Up))
    {
        position.Y -= speed;
    }
    // Tecla para baixo
    if (keysboardState.IsKeyDown(Keys.Down))
    {
        position.Y += speed;
    }
    // Tecla para esquerda
    if (keysboardState.IsKeyDown(Keys.Left))
    {
        position.X -= speed;
    }
    // Tecla para direita
    if (keysboardState.IsKeyDown(Keys.Right))
    {
        position.X += speed;
    }

    base.Update(gameTime);
}

Passo 5: Vamos desenhar o sprite no método Draw(GameTime gameTime)

protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.CornflowerBlue);
    spriteBatch.Begin();
    spriteBatch.Draw(fantasma, position, Color.White);
    spriteBatch.End();
    base.Draw(gameTime);
}

Pronto, agora é só executar o programa e ver o resultado.

Segue código completo do tutorial:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;
<pre>namespace MeuPrimeiroMovimento
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        // Textura que vai ser desenhada na tela
        Texture2D fatasma;
        // Posicao da textura na tela. x = 100, y = 100
        Vector2 position = new Vector2(100, 100);
        // Teclado a ser usado
        KeyboardState keysboardState;
        // A velocidade que vamos movimentar a textura
        float speed = 5.0f;
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

        protected override void Initialize()
        {
            base.Initialize();
        }

        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);
            // Carregando a textura do fastama .PNG
            fantasma = Content.Load<Texture2D>("fantasma");
        }

        protected override void UnloadContent()
        {

        }
        protected override void Update(GameTime gameTime)
        {
            // Declaramos o teclado
            keysboardState = Keyboard.GetState();
            // Tecla para cima
            if (keysboardState.IsKeyDown(Keys.Up))
            {
                position.Y -= speed;
            }
            // Tecla para baixo
            if (keysboardState.IsKeyDown(Keys.Down))
            {
                position.Y += speed;
            }
            // Tecla para esquerda
            if (keysboardState.IsKeyDown(Keys.Left))
            {
                position.X -= speed;
            }
            // Tecla para direita
            if (keysboardState.IsKeyDown(Keys.Right))
            {
                position.X += speed;
            }

            base.Update(gameTime);
        }
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);
            spriteBatch.Begin();
            spriteBatch.Draw(fantasma, position, Color.White);
            spriteBatch.End();
            base.Draw(gameTime);
        }
    }
}

Você pode fazer o download do projeto completo aqui.

Abraços e até a próxima.

Olá caro leitor que esta acompanhando este blog. Hoje vamos aprender como colocar nosso primeiro sprite na tela. Você está com dúvida do que é sprite ? então vamos a uma breve descrição do que seria.

Em computação gráfica, um sprite (do latim spiritus, significando “duende”, “fada”) é um objeto gráfico bi ou tridimensional que se move numa tela sem deixar traços de sua passagem (como se fosse um “espírito”).

Os sprites foram inventados originalmente como um método rápido de animação de várias imagens agrupadas numa tela, em jogos de computador bi-dimensionais, usando hardware especial. A medida que a performance dos computadores melhorou, esta otimização tornou-se desnecessária e o termo evoluiu para referir-se especificamente às imagens bi-dimensionais que eram integradas numa determinada cena, isto é, figuras geradas por hardware ou software eram todas referenciadas como sprites. A medida que gráficos tridimensionais tornaram-se mais comuns, o termo passou a descrever uma técnica elementar de simulação de imagens em 2.5D ou 3D que prescinde do uso de renderizações complexas.

Vamos começar ?

Crie um novo projeto como visto na aula anterior, ou abra um projeto já existente. E agora salve a imagem abaixo dentro da pasta Content do projeto que você acaba de criar.

helloworld.png

Agora conforme a imagem, clique com o botão direito do mouse na pasta Content, selecione Add -> Existing Item. Então selecione a imagem desejada, no nosso caso selecionaremos a imagem que copiamos.

Vamos agora usar esta bela imagem na nossa janela azul. Porém antes de usá-la vamos entender o que esta será feito. Primeiro precisamos declarar um objeto Texture2D para armazenar a imagem 2D, está classe Texture2D o XNA já nos dá. Declarado o objeto, precisamoss então carregar a imagem nesse objeto, através do método Load<Template>(AssetName) da classe.  E por fim, agora é só desenhar na janela. Simples você não acha ?

Então vamos para o primeiro passo, precisamos declarar nosso objeto do tipo Texture2D, que se chamara image. Veja como fica o código.

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

Nosso próximo passo, precisamos carregar a imagem para dentro deste objeto criado. Para carregar algo (imagens, modelos, músicas, etc..) isso é realizado dentro do método LoadContent. Veja o código.

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

E por fim, é só desenhar a imagem na janela. Isso deve ser feito dentro do método Draw da classe, veja como fica o passo final.

protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.CornflowerBlue);
    spriteBatch.Begin();
    spriteBatch.Draw(image, new Vector2(0, 0), Color.White);
    spriteBatch.End();
    base.Draw(gameTime);
}

Agora é só executar o programa e ver um resultado como este abaixo.

Código completo da aplicação:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace MeuPrimeiroJogo
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Texture2D image;

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }
        protected override void Initialize()
        {
            base.Initialize();
        }

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

        protected override void UnloadContent()
        {

        }

        protected override void Update(GameTime gameTime)
        {
            base.Update(gameTime);
        }

        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);
            spriteBatch.Begin();
            spriteBatch.Draw(image, Vector2.Zero, Color.White);
            spriteBatch.End();
            base.Draw(gameTime);
        }
    }
}

Agora que você já sabe como colocar uma imagem na tela, faça alguns testes modificando o valor de Vector2 e da Color para ver os resultados. Ou até mesmo colocando outras imagens.

NOTAS:

O método de desenho do objeto SpriteBatch usado, possui 7 sobrecargas, mas usamos somente uma delas.

• spriteBatch.Draw(Texture2D <textura>, Vector2 <vector2>, Color <cor>);

Referência:

André Luiz Battaiola, Rodrigo de G. Domingues, Bruno Feijó, Dilza Scwarcman, Esteban Walter G. Clua, Lauro Eduardo Kosovitz, Marcelo Dreux, Carlos André Pessoa, Geber Ramalho. Desenvolvimento de Jogos em Computadores e Celulares. UFSCar, PUC-Rio,UFPE. Em RITA, vol. VIII, n. 2, outubro de 2001.

]]> http://kleberandrade.wordpress.com/2009/11/03/xna-colocando-seu-primeiro-sprite-na-tela/feed/ 0 kleberandrade helloworld imagem2 imagemfinal http://kleberandrade.wordpress.com/2009/10/31/lord-of-the-rings-%e2%80%93-the-hunt-for-gollum-fan-film/ http://kleberandrade.wordpress.com/2009/10/31/lord-of-the-rings-%e2%80%93-the-hunt-for-gollum-fan-film/#comments Fri, 30 Oct 2009 23:20:27 +0000 Kleber Andrade http://kleberandrade.wordpress.com/?p=137 ]]>

Ola pessoal,  gostaria de colocar um vídeo muito interessante para os fãs de Senhor dos Anéis. O filme é “The Hunt for Gollum“. Com um orçamento baixíssimo, porém com ótima qualidade foi feito por fãs de Tolkien, retratando a caçada de Aragorn por Gollum a pedido de Gandalf. O filme tem duração de 40 minutos.

Muitos devem estar se perguntando, mas onde acontece essa história? Então, lembrando um pouco do primeiro filme do Senhor dos Anéis a Sociedade do anel. Lembram quando Gandalf deixou Frodo tomando conta do Anel logo depois de Bilbo ir embora, e depois volta para começar a aventura toda (no filme é muito rápido, mas na historia do livro dura 12 anos), é neste meio tempo que acontece o filme intitulado “The Hunt for Gollum”. No filme, durante todo esse tempo (12 anos) eles ficaram caçando Gollum para evitar que ele fosse pego por Sauron e contasse que o Anel estava no condado.

Quem dirige o filme é Chris Bouchard que tem em seu currículo outro fan-film divertidinho: Star Wars – Revelations, lançado em 2005.

Se você quiser saber mais sobre esse audacioso projeto, acesso o site oficial: TheHuntForGollum.com

Para assistir o filme com legenda:  http://www.dailymotion.com/br/video/x93zji_the-hunt-for-gollum-hd-version_shortfilms

Bom pessoal, estorem a pipoca, comprem um refrigerante e tenham um ótimo filme.

Abraços e até a próxima.

Olá turma, hoje vamos comentar sobre a comédia do criador de “Two and a Half Men”, “THE BIG BANG THEORY”, que mostra a história de dois melhores amigos inteligentíssimos que podem lhe dizer o que você quiser saber sobre física quântica — mas quando se trata de lidar com a vida diária na Terra, eles estão perdidos no universo.

Leonard (Johnny Galecki,”Roseanne”, “Hope & Faith”) e Sheldon (Jim Parsons, ”Judging Amy”) são físicos brilhantes que entendem como o universo funciona. Mas nada dessa inteligência ajuda os dois a interagir com as pessoas, principalmente as mulheres. Tudo isso começa a mudar quando uma jovem bela e liberal chamada Penny (Kaley Cuoco, ”Charmed”, “8 Simple Rules”) se muda para o apartamento ao lado.

Sheldon, o colega de quarto de Leonard, contenta-se a passar as noites jogando com seus amigos socialmente disfuncionais, os cientistas Wolowitz (Simon Helberg, ”Studio 60 on the Sunset Strip”, “Joey”), Koothrappali (Kunal Nayyar) e e Winkle (Sara Gilbert, ”Twins”, “ER”, “Roseanne”). Mas Leonard vê em Penny todo um novo universo de possibilidades… incluindo o amor

Fica de dica, para aqueles que querem dar boas risadas. Cada episódio tem aproximadamente 20 minutos e atualmente esta sendo exibida a terceira temporada nos Estados Unidos.

VÍDEO DA MÚSICA TEMA DE ABERTURA COMPLETA

FICHA TÉCNICA:

ELENCO
Johnny Galecki (Leonard), Jim Parsons (Sheldon), Kaley Cuoco (Penny), Simon Helber (Howard Wolowitz), Kunal Nayyar (Rajesh Koothrappali) e Sara Gilbert (Leslie Winkle).

CRIADORES
Chuck Lorre (“Two and a Half Men”, “Dharma & Greg”) e Bill Prady (“Gilmore Girls”, “Dharma & Greg”).

PRODUTORES/ESTÚDIO
Chuck Lorre, Bill Prady e Lee Aronsohn (“Two and a Half Men”, “Cybill”)/Chuck Lorre Productions Inc. e Warner Bros. Television.

ESTRÉIA
EUA: 24/09/2007
BRASIL: 06/11/2007

Pessoal, venho aqui agradecer a todos que participaram da minha palestra de Introdução ao Desenvolvimento de Jogos, realizada na II Semana de Informática da Faculdade Dom Bosco de Piracicaba e na II Semana Nacional de Ciência e Tecnologia do campus São Carlos do Instituto Federal de São Paulo (IFSP) ,  espero que todos tenham gostado da palestra apresentada.

A palestra teve como objetivo apresentar aos estudantes o mundo dos jogos eletrônicos, no qual foi abordado o conceito de jogo e uma breve revisão histórica, analisando a sua evolução e tendências futuras. Foi também apresentado dados sobre a indústria brasileira de jogos e toda a etapa de desenvolvimento de um jogo. No final da palestra foi dado diversas dicas.

Deixo aqui para download como prometido a palestra.

http://www.4shared.com/file/144449867/66af567b/Palestra_-_Introduo_ao_Desenvolvimento_de_Jogos.html

Abraços.

Olá pessoal, se você esta lendo este post ou é porque já ouviu falar de XNA ou nem sabe o que é, então vamos saber inicialmente o que é XNA.

XNA:

O XNA (sigla em inglês que significa XNA’s Not Acronymed) é um framework gratuito e robusto com interface amigável desenvolvido pela Microsoft para criar jogos tanto para PC quanto para o console XBox 360. XNA foi projetado pensando nas pessoas que querem fazer seus próprios jogos e acham complicado trabalhar com DirectX, OpenGL e/ou outras APIs. Além disso, é possível encontrar muita coisa pronta feita por outros desenvolvedores para facilitar ainda mais a programação. Mas não pense que é tão fácil usar XNA assim. Então para começar vamos ver como instalar o framework.

Requisitos mínimos:

• DirectX 9.0c ou superior
• Computador que suporte Pixel Shader 1.1 (recomendado 2.0 ou superior)
• Alguma experiência com a linguagem C#
• E uma boa idéia!

Para maiores informações dos requisitos, segue lista mais completa: clique aqui.

Instalação:

Se você cumprir os requisitos acima, agora é só instalar o Visual C# 2008 Express Edition, que não tem custo e você pode registrá-lo ao final da instalação.

• Visual C# 2008 Express Edition

Após abaixar o Visual C#, instale o mesmo em sua máquina e após a instalação vamos fazer download da versão mais atual do XNA por enquanto.

• XNA 3.1 (versão lançada em 03/07/2009)

Ao concluir o download do XNA 3.1 é hora de instalar. Após possuir o XNA instalado em seu computado, chega a  hora de ver se tudo está funcionando corretamente.

Teste:

Abra o Visual Studio 2008 Express Edition e abra o menu File -> New Project… (Figura 1)

Uma janela conforme a figura 2 deve aparecer.

Nesta janela, você deve escolher o formato do projeto e o nome para o mesmo, conforme figura 2.  Após isso, clique no botão OK e uma janela de projeto vai aparecer (figura 3).

Com o projeto aberto, você deve agora compilar o mesmo para ver se a instalação esta funcionando corretamente. Para fazer isso abra o menu Debug -> Start Debugging ou tecle F5.

Se não aparecer nenhum erro, então a tela do projeto (figura 4) irá aparecer, significando que a instalação do XNA 3.1 foi um sucesso e você pode usá-lo agora para fazer seus jogos.

Informações adicionais:

Segue uma lista dos formatos que o XNA suporta:

• Formatos 2D: DDS, BMP, JPG, PNG e TGA
• Formatos de Áudio: XAP (projeto de áudio gerado pelo XACT Tool), WAV, MP3 e WMA
• Formatos 3D: X (DirectX) e FBX (Formato da Autodesk, mas já é suportado por alguns softwares free e pela maioria dos softwares de modelagem comercial)
• Fontes: SpriteFont (Arquivo XML usado pelo XNA onde você pode descrever as características da fonte usada, como: tamanho etc.
• XML: Suporta arquivos. XML que podem ser usados para armazenar dados do jogo
• Shaders: Suporta arquivos .FX que são usados para descrever efeitos na renderização de modelos 3D ou 2D.

Espero que tenham aproveitado a leitura e que tenham gostado, pois logo viram mais artigos sobre o funcionamento do XNA e implementações de alguns joguinhos.

Abraços.

As Aventuras de Neuro Boy, é um jogo que funcionará com o dispositivo MindSet da empresa NeuroSky, no qual monitora a atividade cerebral sob a forma de um medidor de energia para controlar um personagem animado na tela. O mouse é utilizado para selecionar qualquer uma das potências disponíveis (incêndio, empurrar, puxar, levantar) para o jogador. Então, é só selecionar o ícone de fogo, clicar sobre um carro por exemplo, e se concentrar para o carro pegar fogo, e se quiser levantar uma bola para fora da água, é só selecionar o ícone da pena, clicar na bola, se concentrar até que a bola levante no ar.

Fonte: http://www.neurosky.com/mindset/neuroboy.html

Mais uma matéria interessante, dessa vez realizada pelo Jornal da Globo, que  foi ao Japão ver o que tem de mais moderno no mundo bilionário e globalizado dos videogames. O correspondente Roberto Kovalick testou jogos que ainda não foram lançados e até o famoso projeto Natal da Microsoft.

Para ver a matéria completa clique aqui.

Lendo vários post de blogs e procurando por reportagens de jogos, encontrei uma entrevista com Paulo Vínicius Wolski Radtke, professor da Puc Paraná, realizada pela Globo Ciência, na qual fala um pouco sobre desenvolvimento de jogos educativos. Para aqueles que tiverem interesse no assunto, vale a pena dar uma assistida (apesar do som estar um pouco ruim).