Criando uma simples classe Sprite com XNA no Windows Phone 7

Article
02/24/2012

Criaremos uma simples classe para encapsular um Sprite e então adicionar algumas características para permitir que nossa classe seja útil. Faremos o processo do modo mais simples possível para que acompanhe todas etapas sem sofrimento.

O objetivo destes posts é dividir conhecimento e então torna-lo apto a desenvolver as tarefas que estamos abordando. Se não conseguirmos atingir tal objetivo, então teremos falhado no propósito desta série de artigos dedicados ao desenvolvimento de games para Windows Phone 7.

Mão na massa.

Comece um novo projeto (XNA Game Studio 4.0 / Windows Phone Game 4.0) e dê o nome de Sprite Demo. A versão que estamos utilizando do Windows Phone SDK é a 7.1

Em Game1.cs no projeto Sprite Demo (e não no projeto Sprite DemoContent (Content) pois este, como já aprendemos, tem o propósito de manter nossos assets ) iremos adicionar uma nova classe Sprite no topo do arquivo, acima da classe Game1.

Detalhe, classes não precisam ser armazenadas em um único arquivo, por mais que seja uma prática comum que visa principalmente fácil manutenção e organização do seu projeto.

Mas é aceitável definir uma nova classe dentro de um arquivo existente, principalmente quando as classes em questão são relativamente similares, com propósitos parecidos.

Visando boas práticas, definir arquivos específicos para cada classe é interessante. (sugiro ir por este caminho Wink )

Mão no código

 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.Input.Touch;
using Microsoft.Xna.Framework.Media;

namespace Sprite_Demo
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    /// 


    public class Sprite
    {
        public Texture2D image;
        public Vector2 position;
        public Color color;
    }


    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Viewport viewport;
        Sprite cave;

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

            // Frame rate is 30 fps by default for Windows Phone.
            TargetElapsedTime = TimeSpan.FromTicks(333333);

            // Extend battery life under lock.
            InactiveSleepTime = TimeSpan.FromSeconds(1);
        }

        

        /// <summary>
        /// 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.
        /// </summary>
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        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
            //As the template is nice, is it not? It teaches us until where I can or must put our code.

            //get screen dimensions 
            viewport = GraphicsDevice.Viewport;

            //creating a Sprite
            cave = new Sprite();
            cave.image = Content.Load<Texture2D>("cave");

            //center the cave sprite on screen

            float x = (viewport.Width - cave.image.Width) / 2;
            float y = (viewport.Height - cave.image.Width) / 2;

            cave.position = new Vector2(x, y);

            //set color

            cave.color = Color.White;
            
        }

        /// <summary>
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// </summary>
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">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);
        }

        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            // TODO: Add your drawing code here

            spriteBatch.Begin();

            //draw the cave
            spriteBatch.Draw(cave.image, cave.position, cave.color);
            spriteBatch.End();

            base.Draw(gameTime);
        }
    }
}

Simples? Aproveitando.. No Visual Studio 2010 Ultimate é possível gerar alguns gráficos bem interessantes, e um deles é justamente de dependencias, veja só

Se você também tem a versão Ultimate, faça o teste! Selecionando By Class e com nosso exercício você terá um grafico parecido com este

Legal não é mesmo? Cool

Pense o quanto isto pode te ajudar, principalmente quando estamos falando em dar manuteção e continuidade em projetos de terceiros.. (o que normalmente pode não ser uma tarefa facil) mas com esta ferramenta de arquitetura sua vida pode ficar mais simples.

Detalhe, muita gente tem o Visual Studio mas não sabe desta feature e muitas outras, e acabam utilizando como um editor de código somente, o que está longe do potencial da ferramenta.

Não tem o Ultimate? Nâo tem problema algum, como ja falamos lá no começo (com enfase no post Ferramentas - Visão Geral do Windows Phone ) você não precisa gastar 1 centavo para adquirir as ferramentas para desenvolver para Windows Phone 7 , e em um processo de aprendizagem, não precisará de recursos mais avançados disponíveis em outras versões.

Porem dividir o que existe pode ser útil.. vai que em um futuro breve você comece a trabalhar em uma grande companhia que utiliza plataforma Micrsoft e possui os produtos top de linha? Você irá tirar proveito de todos eles.

Olha você também -> Cool

Nos próximos posts, falaremos de transformações, movimentos, velocidade.. e todas estas coisas bacanas que somente o desenvolver de um game pode lhe fornecer. Bem mais interessante que fazer formulários web ou sistemas desktop para controle de estoque não é mesmo?

Games games games! O mercado está aquecido como nunca esteve, e muitas oportunidades vivem aqui.
Gosta de games? Aprenda a desenvolver e invista na sua carreira. Acredite, além de um bom mercado, existe a grande chance de se divertir bastante com seu próprio trabalho.

Boa sorte!

Posts anteriores

Visão geral do MVA - entendendo o roteiro de Windows Phone

O Windows Mobile e o Windows Phone

Visão geral do Windows Phone 7.5 (codinome Mango)

Visão geral do conceito Metro

Visão geral do SDK do Windows Phone

Visão geral das ferramentas de desenvolvimento para Windows Phone

Visão geral do Emulador

Testando sua app no device

Criando Protótipos

O que é o Windows Phone Marketplace parte 1 - Publicando sua app no Marketplace