O portal de desenvolvimento de jogos PontoV criado pelos sócios Vinicius Godoy de Mendonça e Bruno Crivelari Sanches completou um ano de atividade. O PontoV é um portal brasileiro, sem fins lucrativos, sobre desenvolvimento de jogos que tem como objetivo ser um ponto de encontro de profissionais e amadores desta indústria fascinante, trazendo tutoriais e artigos de qualidade sobre a indústria e técnicas utilizadas.

Para fazer parte dessa equipe eu (Kléber de Oliveira Andrade) acabei me tornando sócio deste incrível portal e por isso o conteúdo relacionado a games do meu blog serão reescritos no portal PontoV para não só unir todos os conhecimentos numa único lugar, mas também porque esperamos que logo se torne referência sobre nosso hobby favorito “Desenvolvimento de Jogos” e para isso que isso aconteça, contamos com vocês. Não se assustem, vou continuar escrevendo tutoriais, artigos entre outras atividades, porém você as verão no PontoV de hoje em diante.

Muito obrigado a todos pelos acessos, e esta página no futuro simplesmente contará com meus projetos em andamento.

Ainda não entrei de férias, como sempre fico fazendo meus trabalhos até o último minuto do ano. Mas o fim do ano vem chegando e muito já estão de férias descansando e não querem nem saber de programar ou fazer outra atividade relacionada ao computador.

Vou fazer um rápido review deste ano  (2010), já que foi um ano bem divertido e interessante. Neste ano o blog começou a ter muitos acessos, comentários, sugestões entre outras movimentos no que fez o número de acesso chegar ao 108mil. Também foi um ano no qual ministrei diversas palestras, cursos de jogos e fiz também algumas viagens por conta disso, duas delas a Campo Grande – MS no qual conheci muitas pessoas legais desde alunos a professores que troquei experiências e mantenho contato até hoje. Este ano também consegui finalmente ir a SBGames apresentar o trabalho do grupo de participo dentro da USP. No laboratório de Robótica Móvel (LabRoM) foi um ano muito produtivo no qual desencadeou diversos trabalhos e artigos e estamos trabalhando o máximo que podemos e logo acabarei o mestrado também. Alias, passei no doutorado, só falta acabar o mestrado para começar mais uma etapa da vida acadêmica.

Novidades para o próximo ano: provavelmente irei comprar um domínio para poder organizar melhor o blog e até mesmo convidar mais pessoas interessadas a escrever e montar um forum de discussão. Alguns artigos estão para serem escritos uma vez que estamos acabando de falar sobre os jogos 2D. Então irei escrever um artigo agora sobre câmeras, montagem de mapas para jogos de plataforma, física e colisão, tudo isso para montarmos um jogo de plataforma básico. Logo após, irei começar a falar sobre Inteligência Artificial, mas tudo isso no decorrer do ano.

Agradeço então aqui a todos os meus amigos que colaboraram diretamente e indiretamente com este blog  que mantenho para tentar ensinar de maneira mais fácil possível como desenvolver jogos. Agradeço também a todo minha família, a minha namorada que amo tanto e  a todos os leitores deste blog. Pra fechar este tópico, desejo a todos um Feliz Natal e um Próspero Ano Novo e que 2011 seja ótimo para todos. Fiquem aqui mais um ano com o vídeo do Chiron Beta Prime (acho que é um dos melhores, quem souber outro me mande para mudar no próximo ano).

1. Uma variável de controle (ou contador de loop).
2. Um valor inicial para controlar a variável.
3. O incrementador e o decrementador, através da qual a variável de controle é modificada a cada passagem pelo loop.
4. A condição para continuação do loop que determina se o looping deve continuar.

Para ver esses aspectos de repetição controlada por contador, considere a aplicação que usa um loop para mostrar números de 1 até 10. Veja no exemplo abaixo:

Using System;

Public class RepeticaoWhile
{
      Public static void Main ( string[] args )
      {
            int contador = 1;           // Declaração e inicialização da variável de
                                                // controle
	 while ( contador <= 10 )  // Condição de continuação do loop
	 {
	       Console.Write (“ {0} “, contador );
 	       contador++;    // Incrementa a variável de controle
	 }

           Console.WriteLine();     //Escreve uma nova linha em branco
       }
 }

A variável de controle (contador) foi declara como sendo Int, pois nós usaremos apenas valores de 1 até 10. Para uma estrutura de repetição é desnecessário declarar a variável como sendo Double ou Float, pois o contador só funciona com números inteiros, o que não descartaria a hipótese de você utilizá-la com os operadores em uma divisão ou resto, nesse caso basta colocar em parênteses (float) ou (double) para que o seu resultado não saia como sendo um número inteiro, e sim um número decimal. Porém jamais armazene esse valor decimal na variável contador, pois se o loop continuar isso resultará em um erro no seu programa.

Note que o contador é inicializado com o valor 1, logo após é declarada a estrutura de repetição while, que verifica se o valor do contador é menor ou igual a 10. Se ele for menor ou igual a 10, ele é escrito na tela pelo comando Console.Write, e logo em seguida ele implementa mais 1 ao valor do contador. A expressão contador++ nada mais é do que uma forma reduzida e prática de (contador = contador + 1), que primeiramente pode ser simplicada por (contador += 1), mas isso fica a cargo das preferências do programador.

Logo após chegar ao final da estrutura de repetição, ele retorna ao início do while e começa tudo novamente, isso é chamado de loop, quando um número fica retornando inúmeras vezes ao começo da estrutura de repetição.

O que está classe realmente faz então, esta classe armazena um dicionário de nomes para chamar cada animação que poderá ser adicionada a ele. O método Update navega entre os quadros da animação atual conforme um intervalo de tempo determinado por cada animação. E o método Draw desenha o objeto.

A classe que gerencia as animações (AnimatedSprite) pode ser vista abaixo.

public class AnimatedSprite
{
    #region [ Fields ]

    /// <summary>
    /// Sprite sheet da imagem animada
    /// </summary>
    protected Texture2D texture;

    /// <summary>
    /// Posição do objeto animado no mundo
    /// </summary>
    public Vector2 Position { get; set; }

    /// <summary>
    /// Dicionário contendo as animações do personagem
    /// </summary>
    public Dictionary<string, Animation> Animations
    {
        get { return this.animations; }
    }
    private Dictionary<string, Animation> animations = new Dictionary<string, Animation>();

    /// <summary>
    /// Indice do frame da animação em execução
    /// </summary>
    public int FrameIndex
    {
        get { return this.frameIndex; }
    }
    private int frameIndex = 0;

    /// <summary>
    /// Nome da animação
    /// </summary>
    private string animationKey;
    public string AnimationKey
    {
        get { return this.animationKey; }
    }

    /// <summary>
    /// Cor de desenho da imagem
    /// </summary>
    protected Color color = Color.White;

    /// <summary>
    /// Rotação da imagem
    /// </summary>
    protected float rotation = 0.0f;

    /// <summary>
    /// Origem do desenho
    /// </summary>
    protected Vector2 origin;

    /// <summary>
    /// Escala da imagem
    /// </summary>
    protected float scale = 1.0f;

    /// <summary>
    /// Efeitos de imagem
    /// </summary>
    public SpriteEffects Flip
    {
        get { return this.flip; }
        set { this.flip = value; }
    }
    protected SpriteEffects flip = SpriteEffects.None;

    /// <summary>
    /// Layer de desenho
    /// </summary>
    protected float layerDepth = 0.0f;

    /// <summary>
    /// Tempo decorrido do frame atual da animação
    /// </summary>
    private float timeElapsed = 0.0f;

    /// <summary>
    /// Lista com os quadros do sprite sheet
    /// </summary>
    public List<Rectangle> Frames
    {
        get { return this.frames; }
    }
    private List<Rectangle> frames = new List<Rectangle>();

    /// <summary>
    /// Largura do quadro
    /// </summary>
    private int frameWidth = 0;

    /// <summary>
    /// Altura do quadro
    /// </summary>
    private int frameHeight = 0;

    /// <summary>
    /// Tamanho do frame
    /// </summary>
    public Vector2 Size
    {
        get { return new Vector2(frameWidth, frameHeight); }
    }

    #endregion

    #region [ Constructor ]

    /// <summary>
    /// Construtor do objeto animado
    /// </summary>
    /// <param name="texture">Imagem (Sprite Sheet)</param>
    /// <param name="columns">Quantidade de colunas</param>
    /// <param name="rows">Quantidade de linhas</param>
    public AnimatedSprite(Texture2D texture, int columns, int rows)
    {
        this.texture = texture;
        this.Position = new Vector2();
        this.frameWidth = texture.Width / columns;
        this.frameHeight = texture.Height / rows;

        // Cria todos os quadros da imagem
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < columns; j++)
                frames.Add(new Rectangle(j * frameWidth,
                    i * frameHeight, frameWidth, frameHeight));

        this.origin = new Vector2(frameWidth / 2, frameHeight / 2);
    }

    #endregion

    #region [ Update ]

    /// <summary>
    /// Atualiza a animação do objeto
    /// </summary>
    /// <param name="gameTime">Tempo de jogo</param>
    public void Update(GameTime gameTime)
    {
        timeElapsed += (float)gameTime.ElapsedGameTime.TotalSeconds;

        if (timeElapsed > animations[AnimationKey].Interval)
        {
            if (animations[AnimationKey].IsLooping)
            {
                frameIndex = (frameIndex + 1) % animations[AnimationKey].FramesCount;
            }
            else
            {
                frameIndex = (int)MathHelper.Min(frameIndex + 1, animations[AnimationKey].FramesCount - 1);
            }
            timeElapsed = 0.0f;
        }
    }

    #endregion

    #region [ Draw ]

    /// <summary>
    /// Desnha o objeto animado
    /// </summary>
    /// <param name="spriteBatch"></param>
    public void Draw(SpriteBatch spriteBatch)
    {
        spriteBatch.Draw(texture,
            Position,
            Animations[AnimationKey].Frames[frameIndex],
            color,
            rotation,
            origin,
            scale,
            flip,
            layerDepth);
    }

    #endregion

    #region [ Add Animations ]

    /// <summary>
    /// Adiciona novas animações
    /// </summary>
    /// <param name="name">Nome chave da animação</param>
    /// <param name="newAnimation">Animação definida</param>
    public void AddAnimation(string name, Animation newAnimation)
    {
        animations.Add(name, newAnimation);
    }

    #endregion

    #region [ Play Animation ]

    /// <summary>
    /// Inicia ou continua uma animação.
    /// </summary>
    public void PlayAnimation(string name)
    {
        // Se a animação for a mesma em execução, não reinicia a animação
        if (name == AnimationKey)
            return;

        // Inicia uma nova animação
        this.animationKey = name;
        this.frameIndex = 0;
        this.timeElapsed = 0.0f;
    }

    #endregion
}

A classe Game1.cs deve ficar da seguinte forma para testar nosso exemplo.

public class Game1 : Game
{
    GraphicsDeviceManager graphics;
    SpriteBatch spriteBatch;

    /// <summary>
    /// Entrada atual do teclado
    /// </summary>
    ///
    KeyboardState keyState = Keyboard.GetState();
    /// <summary>
    /// Entrada antiga do teclado
    /// </summary>
    KeyboardState oldKeyState = Keyboard.GetState();

    /// <summary>
    /// Personagem animado
    /// </summary>
    AnimatedSprite player;

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

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

    protected override void LoadContent()
    {
        // Create a new SpriteBatch, which can be used to draw textures.
        spriteBatch = new SpriteBatch(GraphicsDevice);

        // Cria o personagem
        player = new AnimatedSprite(Content.Load<Texture2D>("claudius"), 6, 4);
        // Posiciona o personagem na tela
        player.Position = new Vector2(100, 100);

        // Baixo
        // Cria as animações para baixo
        Animation stopedDownAnimation = new Animation(player.Frames, 0, 2);
        player.AddAnimation("StopedDown", stopedDownAnimation);
        // Cria as animações para baixo andando
        Animation walkingDownAnimation = new Animation(player.Frames, 2, 4);
        walkingDownAnimation.IsLooping = true;
        player.AddAnimation("WalkingDown", walkingDownAnimation);

        // Esquerda
        // Cria as animações para esquerda
        Animation stopeLeftAnimation = new Animation(player.Frames, 6, 2);
        player.AddAnimation("StopedLeft", stopeLeftAnimation);
        // Cria as animações para esquerda andando
        Animation walkingLeftAnimation = new Animation(player.Frames, 8, 4);
        walkingLeftAnimation.IsLooping = true;
        player.AddAnimation("WalkingLeft", walkingLeftAnimation);

        // Cima
        // Cria as animações para cima parado
        Animation stopedUpAnimation = new Animation(player.Frames, 12, 2);
        player.AddAnimation("StopedUp", stopedUpAnimation);
        // Cria as animações para cima andando
        Animation walkingUpAnimation = new Animation(player.Frames, 14, 4);
        walkingUpAnimation.IsLooping = true;
        player.AddAnimation("WalkingUp", walkingUpAnimation);

        // Direita
        // Cria as animações para direita parado
        Animation stopedRightAnimation = new Animation(player.Frames, 18, 2);
        player.AddAnimation("StopedRight", stopedRightAnimation);
        // Cria as animações para direita andando
        Animation walkingRightAnimation = new Animation(player.Frames, 20, 4);
        walkingRightAnimation.IsLooping = true;
        player.AddAnimation("WalkingRight", walkingRightAnimation);

        // Inicializa a animação do personagem parado a direita
        player.PlayAnimation("StopedRight");
    }

    protected override void Update(GameTime gameTime)
    {
        oldKeyState = keyState;
        keyState = Keyboard.GetState();

        if (keyState.IsKeyDown(Keys.Right))
        {
            player.PlayAnimation("WalkingRight");
            player.Position += new Vector2(60.0f, 0.0f) * (float)gameTime.ElapsedGameTime.TotalSeconds;
        }
        else if (keyState.IsKeyUp(Keys.Right) && oldKeyState.IsKeyDown(Keys.Right))
        {
            player.PlayAnimation("StopedRight");
        }
        else if (keyState.IsKeyDown(Keys.Left))
        {
            player.PlayAnimation("WalkingLeft");
            player.Position += new Vector2(-60.0f, 0.0f) * (float)gameTime.ElapsedGameTime.TotalSeconds;
        }
        else if (keyState.IsKeyUp(Keys.Left) && oldKeyState.IsKeyDown(Keys.Left))
        {
            player.PlayAnimation("StopedLeft");
        }
        else if (keyState.IsKeyDown(Keys.Up))
        {
            player.PlayAnimation("WalkingUp");
            player.Position += new Vector2(0.0f, -60.0f) * (float)gameTime.ElapsedGameTime.TotalSeconds;
        }
        else if (keyState.IsKeyUp(Keys.Up) && oldKeyState.IsKeyDown(Keys.Up))
        {
            player.PlayAnimation("StopedUp");
        }
        else if (keyState.IsKeyDown(Keys.Down))
        {
            player.PlayAnimation("WalkingDown");
            player.Position += new Vector2(0.0f, 60.0f) * (float)gameTime.ElapsedGameTime.TotalSeconds;
        }
        else if (keyState.IsKeyUp(Keys.Down) && oldKeyState.IsKeyDown(Keys.Down))
        {
            player.PlayAnimation("StopedDown");
        }
        // Atualiza o personagem
        player.Update(gameTime);

        base.Update(gameTime);
    }

    protected override void Draw(GameTime gameTime)
    {
        GraphicsDevice.Clear(Color.CornflowerBlue);
        spriteBatch.Begin();
        // Desenha o personagem
        player.Draw(spriteBatch);
        spriteBatch.End();

        base.Draw(gameTime);
    }
}

Para ver como ficou o resultado veja o vídeo abaixo.

Se quiser fazer download do código-fonte do tutorial clique aqui.

Abraços galera, os próximos tutoriais serão sobre Camera 2D para começarmos a montar um jogo de plataforma.

Primeiro passo para se criar uma animação é preciso ter um sprite sheet de um objeto (nosso caso um personagem de rpg) como vimos na primeira parte deste tutorial a imagem do Mario e Luigi. Nosso personagem animado que será animado neste tutorial é o Claudius.

A esquerda sprite sheet do personagem Claudius e a direita o sprite sheet com a marcação dos quadros (frames)

Perceba que o sprite sheet possui as imagens espaçadas igualmente tanto na vertical quanto na horizontal formando quadros de mesmo tamanho, facilitando assim o processo de animação. Este sprite sheet tem 192 x 256 pixels, então cada quadro tem 32 x 64 pixels. Se dividirmos esta imagem nos seus respectivos quadros teremos a imagem a direita marcada.

Vamos criar então uma classe que possa representar cada animação deste personagem. Daremos o nome para esta classe de Animation, veja como ela ficaria abaixo.

public class Animation
{
    #region [ Fields ]

    ///
    /// Lista contendo a sequência de quadros da animação
    ///
    public List Frames
    {
        get { return this.frames; }
    }
    private List frames = new List();

    ///
    /// Intervalo de tempo de passagem dos frames da animação
    ///
    public float Interval
    {
        get { return this.interval; }
        set { this.interval = value; }
    }
    private float interval = 0.25f;

    ///
    /// Define se existe repetição na animação
    ///
    public bool IsLooping
    {
        get { return this.isLooping; }
        set { this.isLooping = value; }
    }
    private bool isLooping = false;

    ///
    /// Quantidade de frames da aniamação
    ///
    public int FramesCount
    {
        get { return this.framesCount; }
    }
    private int framesCount = 0;

    #endregion

    #region [ Constructor ]

    ///
    /// Construtor de uma animação
    ///
    /// Nome da animação que será utilizada como chave
    /// Tamanho do quadro
    /// Quadro inicial
    /// Quantidade de quadros
    public Animation(List frames, int startFrame, int framesCount)
    {
        this.framesCount = framesCount;
        // Armazena os quadros referêntes a esta animação
        for (int i = startFrame; i < startFrame + framesCount; i++)
            Frames.Add(frames[i]);
    }

    #endregion
}

No próximo tutorial veremos então como gerenciar as animações que serão criadas utilizando esta classe que definimos hoje. Abraços, até a próxima.

Abraços,

O que são Sprites ?

Antes que alguém pense em uma piadinha, sprite não é a marca de refrigerante e sim um elemento básico visual dos jogos bidimensionais que pode ser representado por um conjunto de imagens estáticas. Uma animação de um jogo em duas dimensões, por exemplo, é representada por uma seqüência de sprites sendo exibidos em sucessão. Sua principal função atualmente é economizar recursos ao tornar desnecessária a representação de objetos utilizando objetos complexos em três dimensões. Um exemplo de aprite para animação do personagem Mario e Luigi, pode ser visto na figura 1.

Figura 1. Sprite Sheet do Mario e Luigi

As imagens 1 a 3 definem o movimento de caminhada do Luigi, enquanto a imagem 4 a 5 o de pulo. Perceba que ao trocar a imagem você pode posicionar o objeto em outra posição dando realmente a impressão que ele esta caminhando.  Um detalhe importante é que só existe imagens para um lado, pois para ele andar para o outro lado você deve simplesmente fazer um giro horizontal na imagem.

Logo iremos começar a ver códigos, mas por hoje é só.

Sendo este o primeiro SBGames que participo de muitos outros que viram, o primeiro dia do evento foi marcado com uma grande euforia, muitas atividades em paralela, negócios a serem tratados, intercâmbio, novos contatos e na minha opinião a melhor de todas as palestra (keynotes) do evento. Dom Marinelli é professor de teatro e artes e produtor executivo do centro de entretenimento e tecnologia do Carnegie Mellon, nos EUA. disse que os jogos ainda não são reconhecidos como formas de expressão artística por grande parte da sociedade, mas que isso pode mudar no futuro.

Desse modo, Marinelli defende que os estudantes de desenvolvimento de games, em qualquer área que seja, devem viver experiências reais. “Eu tento ensinar artes para estes alunos, para que eles sejam atores. Quero que eles sintam emoções reais como perigo, tristeza e felicidade. Somente assim eles criarão bons jogos”, conta. “Eu não procuro por um desenvolvedor de jogos, eu procuro por um artista”.

Marinelli também disse que os estudantes poderão criar games em diversas áreas, principalmente na educação, no entretenimento adulto e, no que ele acredita ser o próximo passo dos jogos eletrônicos, em títulos voltados para idosos. “Eu estou ficando velho e quero que vocês façam jogos para eu me divertir”. Ele comentou também que espera que os videogames sejam reconhecidos no futuro como arte – algo como o cinema é visto atualmente, por exemplo. “Quero que os videogames tenham o mesmo impacto de ‘Hamlet’”.

Durante o primeiro dia também assisti alguns papers, fiz alguns contatos e depois saímos para comer e beber um pouco com os novos amigos de Recibe, Brasilia, Rio de Janeiro e outros lugares.

Já no segundo dia, tive que acordar cedo pois a apresentação do paper do meu grupo eram as 9:00 da manhã, paper apresentado, novos contatos e novas atividades além do Plenário e cerimônia de premiação. Durante a cerimônia de premiação foi anunciado que o prêmio Abragames ao melhor profissional do ano, chamado de “Contribuição à Indústria Brasileira de Jogos”, mudará de nome, a partir de 2011, ele será chamado Prêmio Marcelo Carvalho, em homenagem ao primeiro presidente da Abragames, que faleceu este ano.

No último dia do evento conforme previsto aconteceu a palestra mais relevante com Jonathan Blow, criador de Braid,

Crédito da foto: Mario Oliveira

considerado um dos melhores títulos independentes dos anos anteriores quando saiu para Xbox 360 (2008), PC e PS3 (2009). Contemplado por um público de mais de 500 pessoas na plateia, o programador e designer que reside nos EUA abordou temas relacionados a como os desenvolvedores devem se relacionar com o público, e afirmou que nem sempre dar ao jogador o que ele quer é o correto a se fazer. ”O que é recompensador? Os game designers podem dar aos jogadores o que eles querem, mas às vezes isso não é saudável para as pessoas. Jogos como Farmville são do mal. Como designer, eu quero dizer que levo a magnitude destas consequências a sério“, afirmou Blow.

O profissional também fez uma analogia com relação à preocupação que os produtores devem ter com relação a magnitude de seus trabalhos, comparando como uma pessoa que pode sair para tomar uma cerveja com os amigos depois do trabalho, mas o efeito será nocivo à saúde se ela se embebedar todos os dias. Da mesma forma, se um game ruim fosse usado por uma única pessoa o efeito não seria impactante, mas na realidade o que acontece é que centenas de pessoas gastam milhares de horas de suas vidas com coisas que as tornam mais burras. ”Nós temos responsabilidade proporcional ao número de pessoas que afetamos. E este número é cada vez maior. Por isso eu não gosto de manipular jogadores. Quero ser o mais ético que puder. Tento criar a maior liberdade possível na mente do jogador.“

Por fim, Blow disse que o objetivo dos profissionais dessa área não deve ser preocupar-se em criar o jogo mais divertido, mas respeitar os jogadores ainda que se tenha pretensão de ganhar dinheiro com o game. Para atingir esse objetivo ele aconselha muita pesquisa e usar formas honestas de conversar com os jogadores, como se faz nas novelas.

Junto com a SBGames acontece o Festival de Jogos Independentes, oportunidade para pessoas e empresas mostrarem suas criações. Dentre os 34 títulos participantes, destacaram-se “Krimson”, game 3D no qual o jogador controla um dragão; “Painting Rage”, um puzzle que brinca com cores, e “Star Triad”, um típico game de nave para celular. Foram os jogos ganhadores deste festival.

Para aqueles que buscaram negócios, podia candidatar-se a vagas de empregos disponíveis em algumas produtoras como a Hoplon, que tem cerca de 110 funcionários, cujo jogo principal, o MMO “Taikodom”, custou US$ 15 milhões. No estande da empresa, os estudantes podiam deixar seus currículos e até mesmo conversar com funcionários do departamento de RH. Também tivemos a chance de visitar a empresa e conversar com os programadores, artistas, músico e outros membros da equipe.

Entre as atividades de lazer a Hoplon realizou um grande campeonato de Taikodom: Livind Universe no qual durante os 3 dias do evento aconteceram combates com patidades de 40 minutos cada em 50 máquinas. Os 3 vencedors foram premiados com placas de vídeo da última geração.

Empresas e instituições francesas de games também marcaram presença no evento, que teve iniciativa de integrar o 1° Encontro Franco-Brasileiro sobre Videogames. Foi discutido o desenvolvimento de parcerias comerciais e co-produções, além de colaborações entre universidades e laboratórios de pesquisa e pólos de competência.

Infelizmente eventos desse tipo ocorrem uma unica vez por ano, mas se eu sou você não ficaria fora da próxima edição que será em Salvador, que tal conhecer o que a baiana tem ? Fico por aqui galera, espero que tenham gostado, até a próxima e alias abraços a todos os amigos que fiz neste evento e até Salvador.

Breakout ou Arkanoid é um jogo simples, que começou em máquinas arcade e que se tornou popular por causa da sua facilidade de jogo e gráficos simples. A empresa que comercializou este jogo foi a Taito. O jogo é formado por uma bola, uma raquete e blocos coloridos. Uma bola começava a andar pelo ecrã. Com a “raquete” tentava-se bater na bola, movimentando-se para os lados. A bola batia nos blocos e você ganhava pontos.

• Código de um mini-breakout desenvolvido nos mini-cursos que ministrei (clique aqui)
• Código de um breakout completo desenvolvido usando diversas técnicas (clique aqui)

Existem alguns bugs em ambas versões que não fique corrigindo, e também o código do jogo completo foi um teste que fiz sobre o uso de Components em XNA, então pode ser que a maioria ache meio confuso o código, até eu mesmo achei.

Abraços, espero que gostem.

Veja o vídeo do clássico jogo Space Invaders

Veja o nosso remake desenvolvido

Como funciona o jogo, o que o usuário pode fazer ? veja o diagrama de caso de uso abaixo

Diagrama de Caso de Uso do Jogo

O sistema de Telas é o mesmo do nosso tutorial, veja a maquina de estado do jogo abaixo.

Maquina de Estados Finitos do jogo

E o nosso diagrama de classes ficaria dessa forma.

Diagrama de Classes do Jogo

Vale lembrar que esse jogo foi criado em um curso de 20 horas sem restrição de conhecimento inicial, então seu código esta criado de maneira a ser cumprida nessas horas de curso. Ou seja, você pode pensar em diversas melhorias para esse código com certeza. Outro detalhe, a tela de créditos foi eliminada do código para reduzir o tempo de programação do curso, porém a mesma se encontra em todos os diagramas.

Pegue o código aqui do jogo clicando aqui.

Abraços galera, até a próxima.