Acredito que assim deva ficar mais fácil de visualizar os textos e aproveitar melhor o conteúdo.

Até a próxima.

Foco é de extrema importância na vida (seja na execução de um trabalho difícil, nos estudos ou paciência para persistir) e principalmente para quem está estudando programação de jogos.

Um exemplo que aconteceu comigo: antigamente eu pesquisava diversos tutoriais sobre programação de jogos em geral (sobre diversas linguagens e tecnologias), dava uma lida por cima e guardava comigo.

Isto acabou me ajudando ??? Sim e não…

Sim pois acabei juntando uma boa biblioteca pra pesquisar e que me ajuda a resolver alguns problemas que eu possa ter no futuro.

Não pois sinceramente não “aprendi direito” deste jeito. O simples fato de ficar “apenas na pesquisa” não me deu o tempo necessário pra praticar. Resultado: não dá pra abraçar o mundo, é melhor focar em algo (quando estamos aprendendo) do que querer ver e fazer tudo o que tem de novo, interessante, etc.

Então baseado no que eu passei, segue abaixo algumas dicas para você ter foco e não se perder nessa longa caminhada:

1. faça um objetivo por vez (lembre-se que o conhecimento se constrói em cima de conhecimento, logo existem temas que você estuda que dependem do conhecimento e domínio prévio de outros temas, aprenda a detectar isto e corra atrás…);
2. faça uma lista do que você precisa estudar (vou dar um exemplo mais abaixo de uma lista que estou utilizando) e foque um assunto por vez, dedique alguns dias & semanas para cada assunto e você verá seus conhecimentos evoluindo;
3. Se quiser aprender a fazer jogos pra web, aprenda flash ou silverlight mas não os dois… Quer aprender a fazer jogos 3d com alguma API? Foque ou no OpenGL ou no Direct 3d (mas não nos dois (pegaram o espirito…). Quer aprender alguma linguagem? Escolha uma e foque sua energia nela;
4. Mais uma vez: conhecimento se constrói em cima de conhecimento. Para se ter conhecimento deve se ter uma base sólida que você consegue estudando e focando (no início). Depois fica mais fácil passar este conhecimento para outros ambientes;
5. Ouvir músicas que não distraem muito ajudam na hora de concentrar e focar no problema em mãos.
6. Façam exercicios: ajuda a manter o corpo e o cérebro saudáveis facilitando a resolução de problemas difícieis e a capacidade de concentração (para focar é claro).

Mais um exemplo: no item dois comentei a respeito de fazer uma listagem de coisas a fazer e a estudar, atualmente possuo um rascunho do que eu estou fazendo (pode não ser a lista mais completa, mas me ajuda a saber o que eu quero, o que preciso focar, o que ja sei, etc…).

• C++
• templates
• classes (incluindo construtores, de cópia e destrutores)
• namespaces
• ponteiros e referências
• sobrecarga de operadores
• herança
• polimorfismo
• STL
• friends
• game loop
• controle de fps
• sprites
• tiles
• background scrolling
• menu básico
• detecção de colisão
• boudingbox (plane exclusion)
• esfera
• triângulo
• intersecção entre dois segmentos de reta
• matemática
• seno & coseno
• tabelas lookup
• vetores
• matrizes
• matemática de ponto fixo
• geometria
• algebra linear
• fisica
• gravidade
• velocidade linear (um pouco mais complicado do que parece)
• friccao
• balistica
• leis de newton
• network
• ai
• pathfinding

Quando digo por exemplo para focar em uma tecnologia & ambiente é porque com o passar do tempo de estudo você já terá uma certa familiaridade com ele e não perderá mais tempo fazendo inicializações, enfrentando problemas diversos de adaptação. Com isso conforme for estudando novos assuntos, poderá facilmente aplicá-los na sua base ja existente (acelerando o aprendizado e permitindo que você foque no novo material).

É claro, a maioria das técnicas aprendidas (incluindo as mais avançadas que você só aprendeu por persistir e ter foco) podem ser aplicadas em outras ocasiões e ambientes (então o fato de você focar em um ambiente trouxe vantagens ao invés de desvantagens, pois permite uma adaptação mais rápida para novos ambientes e conceitos).

Conclusão

O que eu quis mostrar aqui é que a falta de foco pode atrapalhar bastante nos estudos. No geral é melhor ter um pássaro na mão do que dois voando.

Sintam-se a vontade para ler e deixar suas dicas também.

Falando um pouco sobre jogos e dispositivos portáteis, hoje em dia os processadores de dispositivos como celulares, mp3 players e afins podem ser comparados aos processadores dos computadores pessoais de até alguns anos atrás.

Quem não se lembra do famoso jogo Doom? Pois é, algumas pessoas conseguiram portar o código do Doom para o iPod.

O site oficial possui alguns vídeos do jogo em funcionamento e descreve todos os detalhes.

Para quem tem um iPod e quer se divertir um pouco vale a pena, mas, mais do que isso, exemplos como esse mostram as possiblidades existentes nos aparelhos comercializados em massa hoje em dia e mostram o que é possível fazer com um pouco de criatividade e muito esforço.

Agradeço a compreensão.

Ao término do tutorial teremos o seguinte menu:

O menu com todas as suas opções

Ao passar o mouse sobre o item do menu teremos um pequeno efeito:

Opção do menu com o mouse em cima

Recursos

O nosso menu terá os seguintes “recursos”:

• inserção de itens em qualquer lugar da tela;
• cada item poderá ter uma imagem diferente quando o mouse passar em cima;
• ação personalizada para cada item do menu.

Implementação

Agora que vimos a teoria vamos à implementação:

1. Para iniciar crie um projeto chamado Menu e utilize a base inicial deste tutorial;
2. Baixe este arquivo e extraia para a pasta do seu projeto (ou utilize suas próprias imagens);
3. No arquivo main.cpp, após a linha de inclusão da biblioteca allegro (#include <allegro.h>), insira as linhas abaixo:

#include <string>
#include <vector>
using namespace std;

Estas três linhas incluem as bibliotecas que utilizaremos (string e vector) e declara que utilizaremos o espaço de nomes std (maiores explicações depois).

Após a declaração da variável *bmp (BITMAP *bmp) vamos inserir o código das classes:

/*
=======
MenuItem

Representa o item de um menu
=======
*/
class MenuItem {
private:
    int x, y;                   // localizacao deste item de menu na tela

    // esta funcao verifica se o cursor do mouse esta em cima (dentro) deste item de menu
    // se estiver, retorna true, caso contrario retorna false
    bool mouseDentro() {
        int x1 = x;
        int y1 = y;
        int x2 = x1 + pic->w;
        int y2 = y1 + pic->h;

        if (mouse_x > x1 && mouse_x < x2 && mouse_y > y1 && mouse_y < y2)
            return true;
        else
            return false;
    }

public:
    BITMAP *pic;                // imagem do item do menu
    BITMAP *picMouseDentro;     // imagem do item do menu (quando o mouse estiver em cima)
    bool isMouseDentro;           // flag que indica se o mouse esta ou nao dentro do menu
    void (*funcao)(); // ponteiro para a funcao que sera executada quando o usuario clicar neste menu

    MenuItem(int posX, int posY, string imagem, string imagemDentro, void (*pFuncao)()) {
        isMouseDentro = false;

        // define a posicao
        x = posX;
        y = posY;

        // carrega as figuras do menu
        pic = load_bitmap(imagem.c_str(), NULL);
        picMouseDentro = load_bitmap(imagemDentro.c_str(), NULL);

        // se especificou uma funcao, passa ela
        if (pFuncao)
            funcao = pFuncao;
    }

    // acao que este item de menu ira realizar
    void realizaAcao() {
        if (funcao != NULL)
            (funcao)(); // chama a funcao
    }

    // atualiza este item de menu
    void atualiza() {
        // se o mouse passar em cima, executa a acao deste menu
        if (mouseDentro()) {
            isMouseDentro = true;

            // se clicar realiza a acao
            if (mouse_b & 1) realizaAcao();

        } else {
            isMouseDentro = false;
        }
    }

    // desenha este item de menu na tela
    void desenha(BITMAP *bmp) {
        if (isMouseDentro)
            draw_sprite(bmp, picMouseDentro, x, y);
        else
            draw_sprite(bmp, pic, x, y);
    }

    ~MenuItem() {
    }
};

/*
=======
Menu

Classe que gerencia os menus
=======
*/
class Menu {
private:
    vector<MenuItem> items; // representa os itens do menu

public:
    Menu() {}

    // verifica a logica para todos os itens do menu
    void atualiza() {
        int totalItems = items.size();
        for (int i = 0; i < totalItems; i++) {
            items[i].atualiza();
        }
    }

    // desenha os itens de menu
    void desenha(BITMAP *bmp) {
        int totalItems = items.size();
        for (int i = 0; i < totalItems; i++) {
            items[i].desenha(bmp);
        }
    }

    // adiciona um item ao menu
    void adicionaItem(MenuItem menuItem) {
        items.push_back(menuItem);
    }

    ~Menu() {
        int totalItems = items.size();
        for (int i = 0; i < totalItems; i++) {
            // desaloca a memoria alocada para este item
            destroy_bitmap(items[i].pic);
            destroy_bitmap(items[i].picMouseDentro);
        }
    }
};

// ===================
// funcoes dos menus
// ===================

void mnuNewGame() {
}
void mnuOptions() {
}
void mnuHighScores() {
}
void mnuExit() {
    fimJogo = true;
}

// ===================
// fim das funcoes dos menus
// ===================

Agora que temos as classes definidas e explicadas é hora da inicialização.

Após a chamada da função Inicializa na função main, insira o código abaixo:

    // inicializa o gerenciador do menu
    Menu *menu = new Menu();

    // agora adiciona os itens do menu
    // new game
    MenuItem itemNewGame(187, 51,  "mnuNewGame.bmp", "mnuNewGameM.bmp", mnuNewGame);
    menu->adicionaItem(itemNewGame);

    // options
    MenuItem itemOptions(187, 122, "mnuOptions.bmp", "mnuOptionsM.bmp", mnuOptions);
    menu->adicionaItem(itemOptions);

    // highscores
    MenuItem itemHighScores(187, 199, "mnuHighscores.bmp", "mnuHighscoresM.bmp", mnuHighScores);
    menu->adicionaItem(itemHighScores);

    // exit
    MenuItem itemExit(187, 274, "mnuExit.bmp", "mnuExitM.bmp", mnuExit);
    menu->adicionaItem(itemExit);

Já temos o menu inicializado, o que precisamos agora é fazer o gameloop atualizar a lógica do menu e desenhá-lo na tela.

Dentro do loop iniciado por:

        while (ticks && !fimJogo) {

e após a linha:

        if (key[KEY_ESC]) fimJogo = true;

insira o código:

        menu->atualiza();

e para desenhar o menu, antes da linha:

        textprintf(bmp, font, 0, 0, -1, "FPS: %i", fps);

insira o código:

        // limpa a tela com a cor branca
        clear_to_color(bmp, makecol(255, 255, 255));

Agora já temos a tela branca, só falta exibir o menu e o cursor do mouse, para isso após a linha:

        textprintf(bmp, font, 0, 0, -1, "FPS: %i", fps);

insira:

        // desenha o menu
        menu->desenha(bmp);

        // exibe o cursor do mouse na tela
        show_mouse(bmp);

e para finalizar, antes da chamada à função Finaliza, insira o código abaixo para destruir corretamente o menu e liberar a memória alocada por ele:

        delete menu;

Funcionamento

Basicamente o menu possui duas classes: Menu que cuida para gerenciar todos os itens do menu, e MenuItem que representa um item de menu.

A classe Menu possui os itens de menu em um vector, permitindo assim inserirmos dinamicante quantos itens forem necessários. Esta classe simples apenas possui métodos para adicionar um item de menu, atualizar a lógica dos mesmos e desenhá-los na tela.

A classe MenuItem é o núcleo do menu. Cada item do menu possui algumas propriedades chave tais como posição (int x, y), uma imagem para ser exibida normalmente e outra para ser exibida quando o mouse passa em cima, uma flag para indicar se o mouse está passando em cima e o mais importante: um ponteiro para uma função que será chamada assim que o menu for clicado.
Esta classe também implementa métodos para desenhar o item de menu e atualizar a sua imagem caso o mouse esteja em cima.

Algumas observações: eu deixei o código todo no mesmo arquivo (não aconselhável exceto para exemplos mais triviais) para ajudar as pessoas que tem dificuldades em compilar arquivos separados e evitar complicações com variáveis não definidas, variáveis externas, etc…

Se quiser o projeto pronto baixe este arquivo (arquivo de projeto para o Dev-C++).

Exercícios

Agora que você já viu uma implementação básica, tente os exercícios abaixo:

• faça o menu ser controlável por teclado;
• implemente animação nos itens do menu;
• toque um som ao passar o mouse em cima do menu ou ao clicar em um item;
• faça o item do menu “se animar” ao passar o mouse em cima;
• as possiblidades são grandes, experimente…

Na segunda parte veremos em detalhes como controlar os “estados” do jogo para poder trocar mais facilmente as telas (podendo inclusive implementar um menu em cada uma ou iniciar o jogo).

Espero que tenham gostado.

PS: estou pensando em distribuir os códigos fontes com arquivo de projeto do Microsoft Visual C++ Express Edition 2008 ao invés de utilizar o Dev-C++, se alguém tiver alguma observação agora é a hora.

O blog estará em manutenção pelos próximos dias.

Agradeço a compreensão.

Aproveitando que agora posso realizar atualizações mais frequentes no blog, pensei em dar uma mudança no foco e uma diversificada: antes o meu foco original era apenas a linguagem C e a biblioteca Allegro (ainda continuo com este foco) mas pretendo passar a utilizar apenas a linguagem C++ nos exemplos (acho que compensa um pouco mais de complexidade na flexibilidade que terei ao utilizar classes para exemplificar alguns conceitos). Também pretendo postar alguns tutoriais simples sobre programação em celulares (tenho me dedicado bastante nesta plataforma e estou gostando bastante).

Falando em mudança de foco, a minha idéia inicial era publicar artigos sobre “conceitos” em separado e depois dar um pequeno exemplo prático, mas pelo que eu vi, é muito mais fácil já dar um exemplo prático (e explicá-lo) já aplicando o conceito. Exemplo: ao invés de explicar detecção de colisão, gameloop etc, seria melhor mostrar um exemplo já aplicando isto em um jogo e depois ir dissecando um por um.

Seguindo esta linha creio que o pessoal irá aprender mais e se divertir mais no processo.

Também andei acompanhando a movimentação do tráfego do blog, partes mais acessadas e percebi que o tutorial de trigonometria anda bastante acessado (muito obrigado pessoal). Isto me fez perceber que ele precisa de uma revisão (e uma boa reescrita) mas acima de tudo: mais exemplos práticos.

Bom, na verdade foi mais um desabafo para vocês saberem que eu estou vivo e como pretendo fazer as coisas daqui pra frente.

Obrigado pessoal e até a próxima.

Sugestões? Críticas? Sou todo ouvidos.

Mês que vem (Agosto/2008) o blog passará por algumas mudanças e talvez fique fora do ar alguns dias.

Em especial terá um novo layout e um novo foco nos artigos.

Fiquem ligados.

• Estude códigos fonte: esta dica é essencial, códigos fonte escondem verdadeiros tesouros, técnicas sendo utilizadas, estruturação de projeto, documentação, construções da linguagem, etc. Essas são algumas das coisas que você encontrará lendo um código fonte, mas o importante é que você verá a coisa na prática, verá o que é possível fazer (muitas coisas você nem terá idéia de que era possível). Gaste um pouco do seu tempo e estude códigos fonte. Futuramente farei um guia para auxiliar o estudo de códigos fonte;
• Com o tempo de utilização e programação, você irá desenvolvendo sua própria biblioteca utilitária de funções (super importante) para melhorar a produtividade pessoal, pode ser um projeto teste ou apenas um arquivo que não compila mas é importante ir guardando esses pequenos pedaços úteis de código pois no futuro serão muito úteis (provavelmente se você tem o costume de ler códigos fonte já possui vários desses “nacos”);
• No C e C++ o domínio de ponteiros é fundamental (mais do que parece, principalmente pelo C ser meio que uma linguagem de baixo nivel muito utilizado em programação de microcontroladores e dispositivos embarcados), para o inicante começar a entender e dominar ponteiros, o interessante é ele trabalhar com strings no C (vetores de caracteres) e principalmente: ESTRUTURAS DE DADOS (o pulo do gato para entender ponteiros);
• C é uma linguagem pequena e concisa, C++ é uma linguagem mais complicada e possui um poder de expressão maior, mas ambas dão conta do recado no que se refere à programação de jogos eletrônicos. Estude as duas se possível (ou parta direto para o C++, não é necessário aprender C para aprender o C++ embora eu recomende), saiba os prós e contras de cada uma;
• Estude estruturas de dados, veja o conceito, desenhe no papel o seu funcionamento, estruturas de dados são fundamentais para a organização de dados e o entendimento de diversos conceitos na ciência da computação, além disso, a implementação de listas linkadas em linguagem C e manipulação de vetores de chars serve como uma excelente prática de ponteiros;
• Entenda como funciona o hardware de um IBM PC, se você pegar um livro de assembly e der uma “passada por cima” poderá ter um pouco dessa visão;
• Estude sobre teoria geral de sistemas operacionais: saiba os conceitos envolvido no mundo dos sistemas operacionais em geral: threads, processos, escalonamento, saiba como seu sistema operacional organiza e permite o acesso à memória e dispositivos;
• Não existe só C e C++ para programação de jogos, se você sabe os conceitos pode aplicá-los em outros ambientes e linguagens (celulares com J2ME), Flash para a Web, não se prenda a um ambiente, principalmente se você pretende programar consoles.

As dicas abaixo foram selecionadas e traduzidas de um artigo do site Gamasutra (http://www.gamasutra.com/features/20010117/abrash_01.htm). Eu separei as que achei mais relevante:

• Os três segredos para o sucesso são:

1) Trabalho duro,
2) Trabalho duro, e
3) Trabalho duro.

• Aprenda fazendo. Pensar é bom, mas a única maneira de você realmente aprender algo é fazendo você mesmo e finalizando, o que é mais difícil do que parece porque entregar software não é um ato natural (obrigado ao David Stafford por esta frase). Aceite a realidade: nenhum software será perfeito, e a perfeição é um alvo móvel de qualquer maneira. Faça as concessões necessárias e finalize o projeto;
• Siga a sombra dos gigantes. Existem poucas idéias novas no mundo; leia o que os outros fizeram ao invés de ficar tentando inventar tudo você mesmo;
• A maior parte do sucesso da programação se baseia na engenharia e integração e finalização e ser flexível, ao invés de pura invenção. Claro, é divertido reinventar as coisas, mas existe uma quantidade enorme de coisas que você precisa saber, então é difícil fazer tudo você mesmo. Além do mais, existe um monte de coisas legais para descobrir depois que você aprender o que já foi resolvido;
• Aprenda o máximo de matemática que você conseguir. Então aprenda um pouco mais. A indústria está movendo dos generalistas, programadores fazem-tudo para programadores com grandes conhecimentos em áreas como física. Programar em si é fácil; é o expertise em áreas intensivas de conhecimento que irão diferenciar os programadores no futuro;
• Seja paciente. Demora um ano para ficar competente em algo novo, três anos para se tornar um especialista;
• Abrace as mudanças, ou assista elas chegarem e as deixe para trás. Aceite que os objetivos, técnicas, e regras irão mudar constantemente;
• Faça um glossário dos termos que você desconhece, procure na Internet, livros, viu uma sigla e não sabe o que é Google ou Wikipedia nela :), aprenda a estudar.
• Utilize toda informação a sua disposição.

Possui alguma dica interessante? Não deixe de enviar. Contribua para espalhar o aprendizado sobre desenvolvimento de jogos no Brasil.

Referências

Gamasutra

Recentemente para fins de teste me aventurei a fazer um jogo para celular e acabou saindo o VMPong.

VMPong rodando em todo o seu esplendor…

Para esta tarefa eu queria verificar:

• qual a dificuldade real de se fazer um jogo para celular;
• quais ferramentas, plataformas e ambientes disponíveis;
• quais são as possibilidades.

Como eu queria algo “livre” e estava curto em dinheiro, a minha melhor opção era sem dúvida o Java. Após algum tempo verificando a página de tecnologias de mobilidade da Sun, resolvi dar um chance e botar a mão na massa.

O primeiro passo foi conseguir ter acesso às ferramentas necessárias, neste quesito eu apelei para o NetBeans. Um ambiente completo e integrado para desenvolvimento Java (incluindo claro, módulos para desenvolvimento mobile).

No processo todo, aprendi algumas lições:

• ferramentas para desenvolvimento Java são muito boas, em especial o NetBeans dá conta do recado com o seu ambiente integrado;
• sempre teste no aparelho, emuladores são muito diferentes e no meu caso (no meu celular V3), o celular é muito mais lerdo do que o emulador;
• celulares são MUITO diferentes de serem programados. Cada variável declarada, cada memória alocada deve ser pensada com atenção pois os recursos são muito escassos (MUITO escassos);
• a parte mais difícil do processo todo foi conseguir passar o jogo para o celular (realmente complicado, vale um artigo inteiro por si só);
• se você curte otimizar o código ao máximo vai se divertir bastante.
• as possibilidades são grandes.
• ver um jogo que você fez rodar em seu celular é muito bacana (todo mundo devia experimentar isso um dia :))…

No geral, utilizando conceitos básicos de game loop e colisão, consegui fazer um pong simples e rápido para o celular (o problema inicial foi se acostumar com o “feeling” de espaço e tempo da plataforma.

As possiblidades para jogos para celulares são grandes, em especial conforme eles aumentam de capacidade, as coisas ficam muito mais interessantes, mas por enquanto, o público alvo para este tipo de plataforma são os jogadores casuais (e com razão). Com o advento e adesão do OpenGL ES os celulares mais novos já suportam aceleração 3D (acessível através da API OpenGL (em uma versão reduzida)).

É possível fazer coisas muito mais bacanas (eu mostrei apenas a ponta do iceberg).

Como não poderia deixar de ser, o jogo pode ser baixado aqui (incluindo o código fonte completo com o projeto no NetBeans) . PS: o código fonte está em inglês, incluindo os comentários.

Bom estudo.

Espero ter ajudado. Qualquer sugestão não deixem de comunicar.

Links

Pensei em postar alguns links que encontrei, mas por enquanto existe um link muito bom em http://www.codebeach.com/index.asp?tabID=2&categoryID=25&subcategoryID=11 onde você pode encontrar diversos links para outros sites com muitos materiais sobre programação de games em J2ME.