Digo isso porque eu sinceramente estou cansado de trabalhar no jogo, quero tentar outros projetos e este aqui durou muito mais do que eu planejava inicialmente (de 3 a 6 meses previstos, agora já tem quase um ano e meio, mais até se eu contar com o desenvolvimento do editor de mapas original) Há um ano e meio atrás, eu ainda era um calouro em Ciencias da Computação, e apesar de ter passado boa parte da minha adolescencia lendo tutoriais sobre programação para jogos, eu ainda era muito ruim e só tinha segurança para programar em C (sim, o Clorofila 2 é feito em C), hoje, eu já dominei o paradigma OO, e voltar a trabalhar no velho procedural é meio desestimulante. Tanto que ao ter que modificar grande parte do editor de níveis, eu acabei colocando código C++, o que me levou a decidir desmembrar o editor do jogo.

Para animar um pouco aqui vai logversion da versão atual ( o que já tá pronto!)

1. Eliminação da Win32 Api do código do editor de niveis, substituída pela Guichan, que se adapta bem melhor à SDL;
2. Melhoramento da interface do Editor de Níveis;
3. Melhoramento das Dicas. Agora estão todas guardadas dentro de cada fase (antes elas estavam todas dentro do executável);
4. Ajuste no sistema de efeitos para corrigir bug da invisibilidade;
5. Ajuste no sistema de efeitos para permitir fade in/out total (e não apenas do cenário, como antigamente);
6. O editor de níveis agora está compilado em um progama à parte, não está mais no mesmo executável que o jogo;
7. O efeito de fade out agora é aplicado quando se passa de fase e está completo (antes apenas o cenário escurecia);
8. Adicionada uma nova fase, que era (e ainda é) a fase de Demonstração, e  agora tambem é a fase 8;
9. Criado um novo tipo de evento, o Func_Apertar, que permite responder ao evento de apertar uma tecla. Antes só podíamos verificar se uma tecla estava apertada, agora, sempre que uma tecla apertar, podemos ser avisados;
10. Usando o evento apertar, o menus foram remodelados para responder desta forma, e portanto a navegação pelos mesmos está sensivelmente melhor;
11. Ainda usando o apertar, agora é possível sair da fase de demonstração apertando qualquer tecla;
12. Revisado alguns efeitos e transições entre efeitos do jogo. Os bugs de imagem teoricamente sumiram e o jogo está mais bonito visualmente;
13. Corrigido o bug da transição de fase (que encerrava o jogo). A posição de certos objetos não era inicializada e ficava carregando lixo de memória, o que levava à acessos indevidos à memória. Como o valor era praticamente aleatório, na maioria das vezes ele apontava para uma posição “errada”, mas sem causar dano, porém outras vezes ele apontava para algum espaço de endereçamento protegido, cujo acesso era prontamente negado e o programa simplesmente encerrava. (Tô colocando bem explicadinho para ver se eu aprendo a nunca mais esquecer de incializar uma variável. Francamente eu estou me sentindo idiota por ter cometido um erro tão besta).

E além disso estão planejadas as seguintes alterações:

1. Criar a 10ª fase. Há alguns objetos novos nela, que já estão sendo implementados, mas apesar de já estar na mente, falta tirar um tempo para desenhá-la;
2. Modo Fase Customizada, este modo abre coleções de fases extras que podem ser editadas, assim o jogador teria acesso ao editor de mapas e poderia cria fazes novas para jogar e distribuí-las em pacotes;
3. Cena Apresentação e Cena Vitória, sonhos antigos, mas apesar de ter adiado muito esta parte, eu não acho que será difícil implantar esta parte.

E essas são as novidades do jogo. Após o break, temos screenshots e um vídeo (mal gravado, pois eu não encontro em lugar algum o antigo que eu usava, aliás, se alguém souber de um bom programa de captura de vídeo e que capture som também, avise-me)

Imagem do Editor de Níveis assim que ele é aberto

Abrindo um nível

Após abrir uma fase

Editando...

Colocando uma escada

Editando os atributos de um objeto

E o vídeo:

E por enquanto é só tudo isso…

Antes de começar, eu vou assumir neste tutorial que você tenha um ambiente pronto de programação usando o Code::Blocks, com SDL, SDL_Image, e opcionalmete, SDL_TTF. Se você não sabe como montar um ambiente desse, eu recomendo que você leia este tutorial, o site em si é muito bom, e é uma boa ideia deixá-lo nos favoritos.

As antigas versões da Guichan, distribuíam nas versões pré-compiladas uma dll para o core, e uma para cada front-end (um para SDL, uma para Alegro, etc). Porém como vamos usar a Guichan somente com SDL, neste tutorial serão compilado ambos em uma única biblioteca.

Baixando

Primeiramente você precisar ir neste link e baixar a versão mais recente da Guichan. Após baixar e descompactar a pasta (no caso, eu coloquei dentro da pasta devJogos\projetos\, sendo que o code::blocks está instalado em devJogos\Codeblocks\, a SDL, SDL_Image e SDL_TTF estão todas em subdiretórios dentro de devJogos\).

Criando o Projeto

Então agora você precisa abrir o Codeblocks e criar uma projeto do tipo Static Application.

Criando um novo projeto

Uma parte importante é que você tem que nomear o projeto com o mesmo nome da pasta da guichan (por ex: guichan-0.8.1) e verificar se no Resulting filename o projeto está sendo criando na pasta certa.

Observe o nome a pasta do projeto

Não há necessidade de mais do que uma build target, então pode desmarcar a “debug” sem medo.

Configurando o Comopiler e o Linker

Agora é a hora de configurar as bibliotecas que serão incluídas. Se fossemos compilar apenas o Core, nem preciaríamos fazer essa parte, então, basta-nos adicionar as bibliotecas SDL, SDL_Image e caso queira, a SDL_TTF. Portanto vá agora em Project->Build Options e clique em guichan-0.8.1 para alterar as configurações de todo o projeto (e não somente de uma build targe, pois iremos criar outro futuramente para testar) certifique-se que o path de cada biblioteca esteja incluído tanto no Compiler como Linker:

Configuração do Compiler

Configuração do Linker

E depois é só mandar o linker carregar as bibliotecas clicando na aba Linker settings e adicionando as libs mingw32, SDLmain, SDL, SDL_Image e SDL_TTF, nesta mesma ordem e deve ficar assim:

Configurações do Linker

Adicionando os Arquivos

Agora vem a parte mais “fácil”, adicionar os arquivos, basicamente o que você deve fazer é clicar OK para fechar a janela de Build Options, clicar no menu Project->Add files e incluir todos os arquivos .hpp que houverem nas sub-pastas include, include\guichan, include\guichan\widgets, include\guichan\sdl e include\guichan\contrib\sdl, esta ultima só entra se estiver usando a SDL_TTF. Eu recomendo que você use, pois usando a SDL_TTF podemos usar fontes prontas, enquanto se não usarmos, teremos que nos contentar com as fontes de bitmap, que são muito mais limitadas e normalmente mais feias, além da maioria não suportar os acentos da lingua portuguesa (aliás, com esse acordo, eu me sinto até livre para errar um pouco mais )

Depois que adicionarmos os headers, vamos adicionar os sources, que também é fácil, basta adicionar todos os arquivos .cpp que tanham nas subpastas src, src\widgets, src\sdl e src\contrib\sdl.

Compilando

Primeiramente aperte Ctrl+F9 e espere, porque vai dar erro. Os passos que eu mostrei até agora são genéricos para qualquer biblioteca, que são, criar projeto, configurar e eliminar dependencias, adicionar arquivos e compilar. Porém esta biblioteca requer alguns ajustes.

O primeiro é bem simples, porque o compilador não consegue encontrar os headers. Para resolver este, Vá em Project->Build options e na aba Search directories e adicione “include” e “include\guichan\contrib\sdl” na aba Compiler:

Configuração do Compiler

Se você não estiver usando a SDL_TTF, deve compilar sem problemas depois disto. Mas com SDL_TTF, precisamos de dois novos ajuste, abra o arquivo  “sdltruetypefont.hpp” que está em include\guichan\contrib\sdl. Vá a linha 50 e mude a parte de <SDL/SDL_TTF.h> para <SDL_TTF.h> e comente a linha 59.

Como o arquivo deve ficar

Agora pode apertar Ctrl+F9 que vai compilar sem erros, talvez haja alguns warnings, mas pode ver que o arquivo libguichan-0.8.1.a foi criado (deve está na pasta do projeto ou dentro de bin\lib ou bin\Release).

Testando

Para testar a guichan, são fornecidos três exemplos de uso. Para compilar qualquer um deles precisamos de apenas alguns passos básicos, que são os mesmos para os três, portanto não detalharei como como compilar cada um deles, apenas mostrarei quais são os passos necessários.

1) Criar um novo build target, com o nome do teste (helloworld, action ou widgets). Para fazer isso, clique no menu Project->Properties, clique na aba “Build targets“, clique em add e escreva o nome do teste. Depois assegure-se que o Type seja GUI application e que nenhum arquivo esteja marcado na lista de Build target files.

O nome do executável foi deixado padrão, mas pode ser mudado sem problema

2) Adicionar a libGuichan ao projeto. Abra novamente as Build Options (project->Build Options) e clique na build target do teste, clique na aba Link Settings e clique em add. Se o arquivo libguichan-0.8.1.a estiver na pasta do projeto, basta escrever “libguichan-0.8.1.a” e clicar ok, senão clique em “…” e procure o arquivo e então clique ok.

Deve ficar + ou - assim.

3) Adicione os arquivos do teste. Para cada um deve-se adicionar os arquivos “sdl.hpp”, “<nome do teste>.hpp” e “sdl<nome do teste>.hpp”. Todos estã na pasta “Examples“, e é bom tomar cuidado para não adicionar o arquivo de outra biblioteca como algro ou hge.

4) Copie os arquivos de imagem da pasta examples para a pasta do projeto, e certifique-se que todas as dll’s estão lá também (SDL, TTF, image, zlib, etc)

5)Compile e execute, se você seguiu todos estes passos, o programa deve rodar sem problemas.

Depois é só repetir os passos para cada teste e visualizar o exemplos. Fazer pequenas modificações no código dos exemplos, mas não se preocupem que eu planejo lançar a parte 2 na próxima semana, onde vou explicar os comandos básicos e dar um exemplo. Até lá! E qualquer duvida, não tenha medo de usar os coments, blz?

Enfim, não está aquela lindeza toda mas tá bonitinho, então vai ficar assim por um bom tempo.

E só,

T+

Nesta versão, temos, como novidades:

• Modifcação em algumas fases;
• Modo Tutorial Implementado. Agora o nível Iniciante inclui dicas e ensina como jogar;
• Agora o tiro (com [ESPAÇO]) pode ser dado mais acima segurando [SETA CIMA] ou mais abaixo segurando [SETA BAIXO];
• A interação entre Gelatron e Destrutor foi refeita;
• Os níveis de dificuldade agora se chamam: “Iniciante”, “Experiente” e “Difícil”, em vem do sem-sal: “Fácil”, “Médio” e “Difícil”;
• Os Flamens foram melhorados. Agora eles podem subir/descer escadas e se teleportarem quando tocam em um teleportador;
• 8ª Fase modificada. Mais interssante agora;
• Pause graficamente melhorado;
• Fase de Demonstração. Se esperar alguns segundos no menu inicial (sem pressionar nenhuma tecla) o jogo inicia uma fase de demonstração. Nela, Clorofila move-se automaticamente;
• Menus Redesenhados. Mudanças nas cores uma pequena melhora de peformance e, principalmente, organização do código;
• Alguns gráficos redesenhados.

Screenshots após o break…

Novo Menu Principal

Nova tela de Recordes

Fase 4

Fase 7

Por enquanto é só…

T+

Eu sempre me interessei por como os jogos eram feitos, lembro-me de jogar pokemon e perceber que os cenários eram montados a partir de “pecinhas”, como quebra cabeças. A partir daí criei o hábito de observar todos os jogos  que via pela frente e tentar identificar se estes tinham ou não o “sistema de peças”.

Quando ganhei meu 1º computador, bem no início de 2003, antes mesmo de aprender a mexer direito eu já estava tentando aprender a fazer jogos. Conheci o Game Maker e o RPG Maker, nessa época que eu consegui fazer o Clorofila, no GM com gráficos feito no paint e sons do rtp do RM. Depois disso, peguei a terrível mania de tentar sempre melhorar até me encher do projeto e desistir. Então, aprendi muita coisa, mas não fiz nada que preste até em 2007.

Eu nem me lembro quando foi que comecei a mexer com sdl, mas pelo meu registro na unidev (onde comecei) foi lá pelos idos de 2004. Porém, cometi o grave erro de aprender a mexer com gráficos e imagens antes de aprender a programar. Assim apesar de inúmero protótipos, o primeiro jogo que programei foi um jogo da forca em modo texto (o popular MS-DOS). Porém foi justamente a partir daí que eu comecei a evoluir de fato, pois pouco depois eu adaptei-lo para SDL e finalmente pude contemplar, com um certo orgulho meu primeiro game de fato.

Aí então eu criei esse blog e consegui me manter na linha (produzindo) o ano inteiro. Infelizmente, esse ano a coisa desandou. Eu praticamente não mexi no Clorofila 2 de janeiro à Julho, e depois eu prossegui em ritmo muito lento,  por conta de um estágio que arrumei. Mas agora, nesse periodo de férias, eu acelerei de novo a produção e acredito no máximo no final de janeiro, eu estabilizarei o Clorofila 2. E por essa folga, eu comecei a pensar em mudanças neste blog, e como minhas férias do curso vão até o inicio de março, é provável que eu siga adiante com elas.

Novas Diretrizes (ou objetivos ou metas ou rumos ou …)

1. Publicar o código fonte dos games estáveis. Isto é, daqueles que estão “terminados” (entre aspas, pois um software nunca é terminado, no máximo é abandonado quando os desenvolvedores cansam dele), ou seja, quando eu atingir uma determinada meta e achar que o código não ser mudado em breve, eu certamente o postarei aqui (como fiz com ploft e vou fazer em breve com o Jogo da Forca e até final de janeiro, espero, com o Clorofila 2);
2. Escrever tutoriais e artigos (ainda vou descobrir a diferença ).  Apesar de não ser um expert de programação pra jogos, eu tenho lá o meu valor e posso ensinar alguma coisa. Pra começar, como eu venho estudando a Guichan, eu planejo fazer uma série de tutoriais sobre o uso desta.
3. Divulgar melhor este blog. Do jeito que está nem adiantaria falar dele, mas se eu colocar os itens 1 e 2 em prática, pode valer a pena que outras pessoas alem de mim saibam da existencia deste blog.

E só, senão vai ficar parecendo promessa de ano novo, daquelas que nunca cumprimos, saca?

T+

Screenshot:

clique para ampliar

Download:

O link para downloads é este. Como já está estável, o código fonte está incluído.

T+

Um simples cronometro. Pra marcar o tempo… Simples mesmo.

Download aqui

Mas vamos por partes, primeiro a versão Beta 1.7, que está nesse endereço. Já está lá há alguns dias mas só hoje eu tive tempo de postar aqui, desculpem me por isso.

O “logversion.txt” contém todas mudanças desta versão (e de todas). Mas aqui vai umas screen shots mostrando o novíssimo scrolling.

E aqui vai um vídeo mostrando o Game Over (não tinha até pouco tempo) e também mostrando o ainda em testes efeito de Fade In/Out.

E quanto à versão 2.0, bem, eu falo disso depois…

Download

Os 5 primeiros que baixarem e testarem entrarão nos créditos como Beta-Testers. Mas tem que testar e dizer o que os erros que achou, o que pode melhorar, etc…  Blz?

Notícias em breve.