Iniciando no Xamarin CocosSharp – Parte 02

Fala Jovem!

Dando sequência em nossa serie, hoje vamos conversar sobre Entidades dentro do CocosSharp. Vou tomar por base que você já leu a parte 1 da nossa serie. Ok?

O padrão de entidade é uma forma poderosa de organizar o código do jogo. Ela melhora a legibilidade, torna o código mais fácil de manter e aproveita a funcionalidade pai / filho incorporada.

Vamos criar um novo projeto CocosSharp. No meu caso vou fazer gerar apenas build para Android.  >;-)

Introdução

As entidades de jogo são classes que definem objetos que necessitam de renderização, colisão, física ou lógica de inteligência artificial. Felizmente, as entidades presentes na base de código de um jogo muitas vezes correspondem a objetos conceituais. Quando isso é verdade, identificar as entidades necessárias em um jogo pode ser feito mais fácil.

Por exemplo,  se seguirmos a temática Shoot ‘em up podemos mapear as seguintes entidades:

  • Jogador
  • Jogador Inimigo
  • Munição (Balas) do jogador
  • Munição do jogador inimigo
  • Armas
  • Meio ambiente

Essas entidades seriam as classes do nosso jogo.

Tipos de Entidades Gerais vs. Específicas

A grande dúvida dos desenvolvedores de games é quando deve generalizar uma entidade ou especializar a mesma. Se olharmos as entidades que mapeamos acima, poderíamos generalizar elas em apenas duas classes:

  • Jogador
  • Jogador Inimigo

Ou poderíamos ainda ter apenas uma classe, a Jogador. Enfim , para saber como dosar essa generalização ou especificação, leve em consideração os seguintes pontos:

  • Tamanho do jogo – jogos menores podem se dar ao luxo de criar classes específicas, enquanto jogos maiores podem ser difícil gerenciar um grande número de classes.
  • Desenvolvimento orientado a dados – jogos que dependem de dados (imagens, modelos 3D e arquivos de dados como JSON ou XML) podem se beneficiar de ter tipos de entidades generalizada. Isso é especialmente importante para jogos que esperam adicionar novos conteúdos durante o desenvolvimento ou após o lançamento do jogo.
  • Game engine patterns – Algumas engine incentivam fortemente o uso de sistemas de componentes enquanto outros permitem que os desenvolvedores decidam como organizar entidades. CocosSharp não requer o uso de um sistema de componentes, de modo que os desenvolvedores são livres para implementar qualquer tipo de entidade.

De teoria é isso por hoje, vamos voltar agora ao nosso projeto e ver esses conceitos na pratica =)

Primeiro baixe o arquivo content do nosso exemplo ou baixe o fonte completo no GitHub

No projeto Portable crie duas pastas, Entities e Factories.

No projeto Droid adicione as duas imagens que baixou no content. Detalhe, se estiver fazendo build para IOS , não esqueça de colocar as imagens lá também =)

Edite o arquivo GamePage.cs do projeto Portable. Lá vamos definir nossa resolução como sendo 480×320.

Vamos criar uma classe Ship.cs dentro da pasta Entities.

Vamos adicionar um CCsprinte para que nossa nave possa aparecer na tela. A classe Ship.cs deve ficar assim:

Precisamos agora incluir essa classe no GameLayer.cs, hoje ele está assim:

Primeiro insira o “using NaveSpace.Entities;” para  que nossa classe Ship possa ser usada.

Vamos limpar algumas informações que o template CocosSharp acaba inserindo. O label e using desnecessários. Nosso GameLayer.cs deve ficar assim:

Se você fizer um build já vera a nave na tela.

Agora, vamos dar vida a nave. Voltando a classe Ship.cs  vamos criar um método HandleInput para capturarmos os movimentos do touch e assim a nossa nave possa se posicionar na tela.

Ainda na classe Shipcs vamos incluir um touchListener. (Estamos usando a mesma logica do PalitosBall)

Agora vamos adicionar munição nessa nave =)

Adicione ao projeto portable a classe Bullet.cs dentro da pasta Etities. Nessa classe já vamos adicionar um sprite.

Como iremos usar várias balas, vamos criar uma Lista em nosso GameLayer.cs

A logica acontece na classe Bullet.cs , mas armazenamos “as balas” na GameLayer.cs . Agora precisamos carregar a munição da nave, para isso vamos preencher essa lista.

Vamos adicionar uma classe chamada BulletFactory em nossa pasta Factory. Você poderia não estar usando essas pastas, mas já vamos nos acostumando com essa nomenclatura e organização para que no futuro nosso código não vire um bagunça. Ok?

A classe Ship é quem irá  criar as instancias de Bullet e irá usar a Factory para isso.  A Ship irá controlar a posição , velocidade ou frequência que as balas são disparadas. Vamos adicionar um método FireBullet na Ship.cs e um Schedule no construtor de Ship para dar vida as balas.

Agora vamos até a GameLayer.cs e vamos adicionar um evento que vair colocar as balas em nossa lista. Para isso vamos criar o método HandleBulletCreated .

Na classe Bullet vamos adicionar duas propriedades para controlar a velocidade da bala, VelocityX e VelocityY.  Além do metodo ApplyVelocity que irá dar velocidade as balas. Além de um Schedule para dar vida. A calsse Bulle irá ficar assim:

Se você fizer um deploy verá a nave disparando as balas. E poderá controlar os movimentos das balas.

Hoje nós começamos a entender os conceitos de Entidades e Factories no desenvolvimento com CocosSharp.  Ao longo da série iremos voltar em pontos mais avançados desses conceitos.

O NaveSpace ainda será finalizado, hoje foi apenas a primeira parte. Ainda teremos que implementar as colisões das balas e colocar alguns inimigos para que possamo destruir =)

Caso tenha alguma dúvida, sugestão, ou melhoria nesse material não deixa de comentar.

O código fonte desse projeto está disponível em https://github.com/mhbsti/NaveSpace

Um forte abraço.

Marcos Hitanael Barchiki Dos Santos

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *