quarta-feira, 19 de outubro de 2011

060 - AmareloGameEngine[1]: Esqueleto do código

Amarelo Game Engine é uma engine de desenvolvimento de jogos para XNA do grupo Interactive Digital Enterteniment [Indigente] da Universidade Federal da Bahia e pode ser baixada direto do repositório SVN do projeto [ procura no google ae... ] mediante um programa apropriado [ para usuários do Windows, recomenda - se TortoiseSVN ]. A engine é desenvolvida em C#

Todo esse tutorial será feito usando Microsoft Visual Studio 2010 Express. Lembre - se de ter instalado este programa mais o XNA.

Neste primeiro post, vamos aprender a criar um projeto no Visual Studio (a coisa mais simples do mundo) e a escrever o esqueleto do código.

1. Criando um novo projeto no Visual Studio
  • FILE // NEW PROJECT
  • VISUAL C# // WINDOWS GAME 4.0


  • No campo NAME, dê o nome do seu jogo [ "testetutorial" por exemplo ]
  • Clique em OK
  • Após tudo isso, a próxima tela deve ser similar a essa...



2. Montando o esqueleto do código
  • Baixe a engine no svn do projeto - use um programa próprio para isso [ TortoiseSVN por exemplo]
  • Na aba SOLUTION EXPLORER //SOLUTION (nome do projeto), clique com o botão direito na pasta REFENCES // ADD REFERENCE


  • Uma janela como essa se abrirá


  • Navegue até "(pasta do checkout) // AmareloGameEngine // bin // x86 // debug", selecione a dll "AmareloGameEngine.dll" e clique em OK


  • O nome AmareloGameEngine aparecerá na pasta REFERENCES



  •  Para importar outros recursos - como a engine de física ou outra engine qualquer - basta repetir os passos acima
Ao criar o projeto, o Visual Studio já gera o esqueleto do código do seu jogo. Mas para usar os recursos da AmareloGameEngine, você precisará importar duas coisas para o projeto: a engine em si e o namespace Amarelo
Agora porque importar o namespace? Sem isso, todas as funções da engine que você usar devem ser seguidas do nome Amarelo [ Amarelo.FadeInOut(), Amarelo.graphicsEngine.addSprite() ]. Com o namespace, apenas o nome da função já basta.
  • No arquivo "Game1.cs", logo nas linhas iniciais do código, existe uma lista de imports do XNA:
 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;  
  • Adicione a essa lista o namespace e a engine, respectivamente:
 using Amarelo;  
 using Amarelo.GameEngine; 



  •  Troque a linha...


  •  public class Game1 : Microsoft.Xna.Framework.Game  
    

    • ...por
      public class _nome do projeto_ : Amarelo.AmareloGame  
    

    • e o nome do construtor...
     public Game1()  
    

    • por...
     public _nome do projeto_(GameConfig cg) : base(cg)
    

    • enfim apague a linha
     GraphicsDeviceManager graphics;  
    
    • Na aba SOLUTION EXPLORER // ( nome do projeto ) , clique duas vezes no arquivo "program.cs"
    • Dentro da função main adicione a linha
      Amarelo.GameConfig cg = new Amarelo.GameConfig()  
    

    • e troque a linha
      using (Game1 game = new Game1())  
    

    • ...por
      using ( _nome do projeto_ game = new _nome do projeto_(cg))   
    

    • Salve o projeto (Ctrl+S)  e teste (F5)
    • Ao tentar executar, vc deve se deparar com uma mensagem de erro similar a essa:


    • O erro reporta a não implementação dos métodos abstratos da engine. Na linha
    public class : Amarelo.AmareloGame

    • Clique com o botão direito em Amarelo.AmareloGame e selecione a opção IMPLEMENT ABSTRACT CLASS


    • Essas novas linhas aparecerão no final do código


    • Trata - se dos métodos Initialize(), LoadContent(), UnloadContent e Update(GameTime game). Elas já existem quando você cria um novo projeto no XNA. AmareloGameEngine apenas reimplementa tais métodos. Portanto as linhas de código abaixo, situadas logo após o construtor da classe são dispensáveis. Apague - as do código


         /// 
         /// 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.  
         ///   
         protected override void Initialize()  
         {  
           // TODO: Add your initialization logic here  
           base.Initialize();  
         }  
         /// 
         /// LoadContent will be called once per game and is the place to load  
         /// all of your content.  
         ///   
         protected override void LoadContent()  
         {  
           // Create a new SpriteBatch, which can be used to draw textures.  
           spriteBatch = new SpriteBatch(GraphicsDevice);  
           // TODO: use this.Content to load your game content here  
         }  
         /// 
         /// UnloadContent will be called once per game and is the place to unload  
         /// all content.  
         /// 
         protected override void UnloadContent()  
         {  
           // TODO: Unload any non ContentManager content here  
         }  
         ///  
         /// Allows the game to run logic such as updating the world,  
         /// checking for collisions, gathering input, and playing audio.  
         /// 
         /// 
    
    
    
    
    
    Provides a snapshot of timing values.</param>  
         protected override void Update(GameTime gameTime)  
         {  
           // Allows the game to exit  
           if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)  
             this.Exit();  
           // TODO: Add your update logic here  
           base.Update(gameTime);  
         }  
    
    •  Comente as exceções dos métodos abstratos implementados. Eles só servem para lembrar de que é você que vai implementar o código desses métodos. Essa implementação varia com o jogo.
    • Agora nós temos apenas o construtor do projeto, o método Draw(GameTime gameTime) default do projeto e os métodos abstratos da AmareloGameEngine, encerrando assim a construção do esqueleto do código
    1:  /* --- ESQUELETO Game1.cs --- */  
    2:  using System;  
    3:  using System.Collections.Generic;  
    4:  using System.Linq;  
    5:  using Microsoft.Xna.Framework;  
    6:  using Microsoft.Xna.Framework.Audio;  
    7:  using Microsoft.Xna.Framework.Content;  
    8:  using Microsoft.Xna.Framework.GamerServices;  
    9:  using Microsoft.Xna.Framework.Graphics;  
    10:  using Microsoft.Xna.Framework.Input;  
    11:  using Microsoft.Xna.Framework.Media;  
    12:  using Amarelo;  
    13:  using Amarelo.GameEngine;  
    14:  namespace <nome do projeto>  
    15:  {  
    16:    /// 
    17:    /// This is the main type for your game  
    18:    /// 
    19:    public class _nome do projeto_ : Amarelo.AmareloGame  
    20:    {  
    21:       GraphicsDeviceManager graphics;  
    22:      SpriteBatch spriteBatch;  
    23:      public <nome do projeto>(GameConfig cg) : base(cg)  
    24:      {  
    25:        Content.RootDirectory = "Content";  
    26:      }  
    27:      /// 
    28:      /// This is called when the game should draw itself.  
    29:      /// 
    30:      /// Provides a snapshot of timing values.
    31:      protected override void Draw(GameTime gameTime)  
    32:      {  
    33:        GraphicsDevice.Clear(Color.CornflowerBlue);  
    34:        // TODO: Add your drawing code here  
    35:        base.Draw(gameTime);  
    36:      }  
    37:      protected override void initialize()  
    38:      {  
    39:        //throw new NotImplementedException();  
    40:      }  
    41:      protected override void loadContent()  
    42:      {  
    43:        //throw new NotImplementedException();  
    44:      }  
    45:      protected override void unloadContent()  
    46:      {  
    47:        //throw new NotImplementedException();  
    48:      }  
    49:      protected override void update(GameTime time)  
    50:      {  
    51:        //throw new NotImplementedException();  
    52:      }  
    53:    }  
    54:  }  
    55:  /* --- ESQUELETO program.cs --- */  
    56:  using System;  
    57:  namespace __nome do projeto__
    58:  {  
    59:  #if WINDOWS || XBOX  
    60:    static class Program  
    61:    {  
    62:      /// 
    63:      /// The main entry point for the application.  
    64:      /// 
    65:      static void Main(string[] args)  
    66:      {  
    67:        Amarelo.GameConfig cg = new Amarelo.GameConfig();  
    68:        using (_nome do projeto_ game = new _nome do projeto_(cg))  
    69:        {  
    70:          game.Run();  
    71:        }  
    72:      }  
    73:    }  
    74:  #endif  
    75:  }  
    
    • Salve e teste
    • Após todos esses procedimentos, finalmente teremos uma tela azul ( não se trata da BlueScreenOfDeath ) como essa. Clique no X vermelho no canto da janela para fechar.


    Nenhum comentário:

    Postar um comentário