Artigo WebMobile 18 - Escrevendo uma aplicação de jogo de cartas

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

Artigo publicado pela revista WebMobile edição 18.

Esse artigo faz parte da revista WebMobile edição 18. Clique aqui para ler todos os artigos desta edição

imagem_pdf.jpg

.NET Mobile

Pocket Jack

Escrevendo uma aplicação de jogo de cartas

 

Muitos jogos são baseados em baralho de cartas. Portanto faz sentido implementar um conjunto de classes que fornecem um conjunto de métodos para gerenciamento de cartas. Você pode usar estes métodos para implementar vários jogos. Este artigo descreve um mecanismo para distribuir cartas aleatoriamente, exibindo-as na tela, mostrando a “mão” de cada jogador, e gerenciando jogos baseados em cartas. Fornece a implementação no contexto de um jogo de Blackjack funcional, chamado Pocket Jack, para SmartPhone. Para começar, você necessitará do Visual Studio .NET 2003 e do SmartPhone 2003 SDK. Consulte o quadro de links no final do artigo para obter a URL de download do SmartPhone SDK.

Desenhando as cartas na tela

O primeiro problema a resolver é a exibição das cartas de um jogador. As cartas que são usadas no jogo devem ser exibidas na tela do SmartPhone. Para isso, você precisa de 53 imagens: uma para cada carta, mais uma imagem que mostre a parte de trás das cartas. Um conjunto de imagens foi criado em arquivos individuais, como mostrado na Figura 1.

 

Figura 1. Imagens das cartas

Cada um desses arquivos é uma imagem GIF da carta em questão. Arquivos numerados de 1 a 52 contêm cada uma das cartas do baralho. O arquivo de número zero é a parte de trás da carta. Estas imagens podem ser adicionadas ao projeto da aplicação e usadas para mostrar as cartas. Cada imagem das cartas possui cerca de 1KB de tamanho, porque contém só quatro cores, então as imagens não usarão muita memória.

Criando o projeto e adicionando imagem de cartas

Para começar, você precisa primeiro criar um novo Smart Device Application no Visual Studio .NET 2003 (Figura 2), para isso você deve seguir os quatro passos descritos a seguir:

1.   No Visual Studio 2003, clique File>New>Project.  Isso irá exibir a caixa de diálogo de New Project;

2.   Na caixa de diálogo de New Project, selecione o tipo de projeto Visual C# Projects;

3.   Escolha Smart Device Application;

4.   Atribua o nome de PocketJack para o novo projeto como mostrado na Figura 2.

 

Figura 2. Caixa de diálogo do New Project 

    Para completar a criação do projeto de Smart Device Application no Wizard apresentado, selecione a plataforma SmartPhone e o tipo de projeto Windows Application como na Figura 3.

 

Figura 3. O Smart Device Application Wizard

Com o projeto criado, você agora está pronto para incluir as imagens das cartas. O melhor lugar para armazenar as imagens é na própria aplicação – isso torna o deploy mais fácil. É melhor criar um diretório de recursos dentro do projeto que irá armazenar as imagens na pasta principal, porque isso evita o grande número de arquivos e pastas que podem atrapalhar na manutenção do projeto. Para criar a pasta de recursos clique com o botão direito no projeto Add>New Folder, como mostrado na Figura 4.

 

 

 

Figura 4. Adicionando uma nova pasta ao projeto

Nomeie a pasta para “cardImages”. Se você olhar o projeto, verá que o Visual Studio criou uma pasta chamada cardImages ligada ao projeto, como mostra a Figura 5.

 

Figura 5. A pasta cardImages

Agora que você tem sua pasta no projeto, você precisa colocar as imagens nela. A melhor forma de fazer isso é selecionando todas as imagens no diretório de origem e arrastá-las até a pasta cardImages. Os arquivos aparecem dentro da pasta da Solution, e também são copiados ao diretório do projeto. Entretanto, até o momento, elas não estão embutidas no projeto quando este for distribuído. Para isso acontecer, é preciso marcar os arquivos de imagens como embedded resource, selecionando todas as imagens no diretório. Então, modifique as propriedades Build Action para marcar os arquivos como recursos embutidos (embedded resource), como mostrado na Figura 6.

 

Figura 6. Recurso de imagens embutidas

A aplicação agora tem 52 imagens de cartas e uma imagem de fundo embutidas nela. Se continuar com o projeto verá que o arquivo executável tem em média 83KB de tamanho. A maior parte deste tamanho é das imagens.

Carregando a imagem das cartas

A melhor maneira de gerenciar as cartas é através de um array de cartas. As imagens então poderão ser desenhadas no jogo quando requisitadas. A Listagem 1 nos mostra como armazenar as nossas cartas em um array de imagens.

Listagem 1. Armazenando as cartas em um array de imagens

//Definindo o tamanho do array das imagens para podermos armazenar as 52 cartas do nosso baralho

            System.Drawing.Image[] cardImages = new System.Drawing.Bitmap[53];

            //obtemos o Assembly atual para podermos ter acesso ao manifesto de arquivos de recurso

            System.Reflection.Assembly execAssem = System.Reflection.Assembly.GetExecutingAssembly();

            for (int i = 0; i < 53; i++)

            {

                //para cada posição do nosso array criamos um novo bitmap informando o nome completo de cada arquivo

                //lembre-se que foi dado como nome de cada imagem um número e elas estão armazenadas na pasta cardImages do nosso projeto

                cardImages[i] = new System.Drawing.Bitmap(execAssem.GetManifestResourceStream( @"PocketJack.cardImages." + i + @".gif"));

            }

 

Esse código cria um array para guardar referências aos bitmaps e então carrega cada bitmap de seus respectivos recursos dentro do assembly. Perceba que o código cria o nome do recurso usando o número da imagem a ser carregada. Quando criamos recursos embutidos, o Visual Studio automaticamente adiciona o nome do projeto ao começo do nome dos recursos. Além de incluir o nome padrão do projeto, o nome dos recursos também incluem o nome da subpasta, porque os arquivos usados para criá-los estão contidos em uma subpasta do projeto. Como resultado, o código para carregar os recursos deve incluir o nome do projeto padrão e o nome da subpasta como parte do seu nome, para então ser localizado corretamente.

Desenhando a imagem das cartas

O próximo passo a se considerar é o processo de desenhar as cartas. As imagens das cartas têm cantos arredondados. Quando mostradas no plano de fundo do jogo, esses cantos devem ser exibidos de forma transparente, para as cartas parecerem reais. É um pequeno detalhe, mas significante se desejamos que os usuários realmente gostem do jogo. Se olhar atentamente as imagens das cartas, verá que os cantos foram desenhados em verde escuro, como mostra a Figura 7.

 

Figura 7. Detalhe do canto da carta  8 de espadas

Quando as cartas são mostradas, você deve escolher esta cor (o verde) como transparente, para o plano de fundo mostrar a borda de cada carta. Você precisa usar o código da Listagem 2 para criar uma instância de ImageAttributes que indica qual a cor é a transparente.

Listagem 2. Definindo a cor verde como transparente

//criamos uma instância com os atributos das imagens

            System.Drawing.Imaging.ImageAttributes transparentAttributes = new System.Drawing.Imaging.ImageAttributes();

            //ajustamos a cor verde (Green) para ser identificada como transparente            transparentAttributes.SetColorKey(Color.Green, Color.Green);

 

O método SetColorKey informa a faixa de cores a ser considerada como transparente. Para o .NET Compact Framework essas cores devem ter o mesmo valor; isto é, só uma cor pode ser transparente quando mostrada no SmartPhone. Para mostrarmos todas as cartas na nossa aplicação, podemos usar o código da Listagem 3. O programa de exemplo mostra todas as cartas a cada vez que o método Paint é chamado (Figura 8).

Listagem 3. Desenhando as cartas na aplicação de uma forma randômica

            // Cria um objeto para obter o posicionamento randômico das cartas

System.Random rand = new System.Random();

            foreach (System.Drawing.Image card in cardImages)

            {

// Cria um retângulo que conterá a imagem a ser desenhada            

System.Drawing.Rectangle drawRect = new System.Drawing.Rectangle()

// atribui uma coordenada randômica ao eixo X do retângulo

                drawRect.X = rand.Next(this.Width);

// atribui uma coordenada randômica ao eixo Y do retângulo

                drawRect.Y = rand.Next(this.Height);

// atribui o valor correto de largura da imagem

                drawRect.Width = card.Width;

"

A exibição deste artigo foi interrompida :(
Este post está disponível para assinantes MVP

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?