Game Wells: Isto vai explodir!

Wells é um jogo de ação side-scrolling com gráficos 3D, pertencente ao subgênero clássico dos anos 90, o Run and Gun. Preparasse para hordas de inimigos, explosões, chefes gigantescos, e uma longa jornada em um fascinante mundo steampunk.

» Post Completo...

Ubuntu 10.04: Trocando a posicao dos Botoes

O Ubuntu 10.04 (Lucid Lynx) chegou arrasando e contrariando ao mesmo tempo. Seu novo tema preto ficou sinistro, era o que eu esperava já a algumas versões (o tema dark havia sido prometido a algum tempo). O tema ficou massa, mas o que houve com os botões?! Trocar os botões de lado pegou muita gente de surpresa. O Ubuntu é danado pra inventar moda... primeiro ele dividiu a barra de menu em duas e agora já quer acostumar os usuários a fechar a janela pelo canto esquerdo. Pode até que dê certo, mas pra aqueles que não gostaram muito da ideia tem como dar aquele jeitinho !!!

» Post Completo...

Resultado da Enquete de Março

Pra esquentar as coisas por aqui eu resolvi voltar com uma enquete. A intenção era comentar sobre o resultado da enquete e aos poucos ir voltando a postar no blog.
Bem, a intenção foi boa. O problema foi que demorei um pouco mais que o esperado para comentar sobre a enquete e ela esfriou... pra falar a verdade já deve estar vencida !

Enquete de março: O que você acha do The Mana World BR?

• :D Muito legal !!! (4 votos/36%)
• :-) 3D seria melhor (3 votos/27%)
• :-| Poderia ser melhor (2 votos/18%)
• :-( Prefiro Tíbia (2 votos/18%)

11 votos no total.

Apresentação da SDL na aula de P.A.

Andei trabalhando muito estes dias... Oficina sobre edição de mapas 2D e palestra sobre SDL no 1º Encontro de Desenvolvedores de Jogos do Tocantins e agora uma apresentação sobre desenvolvimento de jogos em SDL... ou desenvolvimento do jogo come poto em SDL, tanto faz ;)

» Post Completo...

Construindo um MMORPG - Parte 3

Eis a parte desta série de tutoriais que todos esperavam. A hora de colocar as mãos na massa. Liberte toda sua criatividade desenhando mapas e escrevendo aventuras para seu jogo. Resgate agora mesmo aqueles rabiscos feitos em seus antigos cadernos de escola e comece a dar vida a todos eles !!!

» Post Completo...

Construindo um MMORPG - Parte 2

É com grande satisfação que escrevo a continuação deste tutorial. Demorou pra sair, mas saiu !
E só relembrando, iremos montar nosso MMORPG 2D utilizando o servidor eAthena e o cliente TMW.
Construindo um MMORPG - Parte 1 foi "um tanto" superficial, mas agora o bicho vai pegar.
Diria que instalar o servidor eAthena e configurá-lo a gosto é o bicho da goiaba. Mas o basicão tá garantido.

» Post Completo...

Construindo um MMORPG - Parte 1

Você estava jogando (maravilhado) um destes Multi Massive Online Role-Playing Game... MMORPG's da vida e de repente parou para se perguntar: Como será que eles funcionam ?! Como será que se faz um ?!
Se você já se fez estas perguntas provavelmente morre de vontade de fazer o seu MMORPG's... e como você já tem muita experiência em jogos deste tipo estava precisando de uma mãozinha no desenvolvimento ! Pois você veio ao lugar certo !!!

» Post Completo....:: Caindo na real ::.
Não encare como um sermão... mas a realidade do desenvolvimento de jogos não é um mundo virtual onde tudo acontece num passe de mágica. Envolve muito estudo e trabalho duro. Mas se você for dedicado com certeza chegará lá. (leitura recomentada: Como funciona a criação de videogames)

Mas voltando ao assunto anterior... você bolou novas idéias, mais efeitos especiais e mais emoção (mesmo pros momentos mais monótonos). Tudo que faria do seu jogo melhor que o jogo que acabara de jogar ! Afinal o Lag Age era muito bom, mas só no começo. Depois aquele lance de não ter nada pra fazer a não ser bater mais de mil vezes no mesmo monstro (digo literalmente) era entediante.

Então, decidido, qual é a primeira coisa que você faz ?
a) Estudo muito sobre toda a teoria que envolva jogos e inicio pequenos projetos para que um dia eu possa criar o tão sonhado MMORPG.
b) Me torno um roteirista (em menos de uma semana !), crio um cadastro num fórum de desenvolvimento de jogos qualquer e como minha primeira mensagem convoco programadores, desenhistas e demais profissionais para trabalharem (de graça !!!) no meu MMORPG que irá desbancar o Lag Age e todos os demais.
Se a opção for b, meu pêsames. Pois uma hora dessas você já deve estar morto e enterrado. Fazer isto não é exatamente um crime, mas isto irá atrair a atenção de dezenas de trolls e estes irão se alimentar de toda a sua auto estima e força de vontade.
Então se você quer criar um MMORPG comece pela opção a.

.:: Introdução ao MMORPG ::.
Primeiramente o que significa RPG ?
O Role-playing game (jogo de interpretação de Personagens) é um tipo de jogo em que os jogadores assumem os papeis de personagens. Em um jogo de RPG eletrônico, você controla personagens que seguem uma história pré-determinada, aonde seu personagem se desenvolve com o passar do tempo (Wikipedia).
Da sua invenção, até os atuais, ele passou por muitas transformações. Uma delas foi a possibilidade de ser jogado por vários jogadores pela Internet, denominando-se MMORPG (Multi Massive Online RPG).
RPG's geralmente envolvem uma grande trama no decorrer do jogo. É como um livro que se mergulha cada vez mais fundo a cada página lida. Os MMORPG's também deveriam ser da mesma forma, com a vantagem extra de serem para vários jogadores, mas os valores se perderam no ar.
O que eu vejo são: RPG's com trama em primeiro plano e MMORPG's com trama em segundo plano. Seria interessante estudar os MMORPG's através dos RPG's. Afinal de contas, você quer criar um jogo original ou simplesmente um clone alienado por idéia pré-concebidas ?!

Não conheço muitos RPG's... mas conheço um que é uma verdadeira obra de arte !

Site oficial do do Cave Story (Doukutsu Monogatari)

Em relação aos recursos do jogo o MMORPG é uma evolução do RPG. O MMORPG tem tudo que o RPG tem e mais um pouco. Um RPG 2D pode ter mapas formado por várias camadas de tiles, personagens e monstros animados por sprites, quests e falas de personagens programadas por scripts, efeitos especiais por uma explosão de partículas e os mesmos cálculos matemáticos para golpes, defesas, habilidades e vulnerabilidades.
Tudo isso sugere que se você for programar um MMORPG comece programando um RPG comum.

.:: RPG Maker ::.
Existe uma ferramenta para construção de jogos no estilo RPG ?!
Eu diria um sim tímido, pois apesar de ser conhecida ela tem seus defeitos... que podem ser pequenos ou enormes dependendo do seu projeto.
Com a ferramenta RPG Maker é possível construir um RPG 2D sem a necessidades de conhecimentos aprofundados sobre programação. Com ela você pode editar mapas e quests através de janelas de diálogo e alguns botões. Além de possuir um grande banco de dados de itens, personagens, tileset's e outros recursos que podem ser utilizados em seu RPG.

Veja esta imagem do novo RPG Maker VX:
Como você pode ver, com poucos botões eu criei um mapa e um personagem nele. Você também pode ver a janela do jogo em execução.
Mas nem tudo é exatamente como eu gostaria que fosse:
Não gostei nenhum pouco deste sistema de batalha... é lindo, mas não gostei. Gosto de batalhas abertas no próprio mapa e sem esta estória de ser abduzido !

Continuando... o RPG Maker é cheio de limitações e particularidades que tornam o seu jogo, por mais criativo que seja, uma mera cópia barata de um outro jogo qualquer. Sempre fica aquela impressão... "Acho que já vi este antes".
Se o RPG Maker ainda existe é por conta de sua comunidade... afinal ele não deixa de ser divertido.
O blog é meu e vou meter a porrada no RPG Maker ?! Mais ou menos por aí... mas deixo também uma entrevista que relata uma segunda opnião: Entrevista com Amanda Fitch, criadora do sucesso “Aveyond”


Como eu disse, o RPG Maker foi feito para construir jogos do tipo RPG e não MMORPG's. E mesmo alguns scripts prometendo milagres para transformar um simples jogo RPG em MMORPG, considero uma solução sem muito futuro. Seria preciso de uma ferramenta especialista para isto... logo... só vendo pra crer !!!

.:: MMORPG Maker ::.
Então existe um MMORPG Maker ?! Sim e não !!!
Não é exatamente uma ferramenta, mas vária. E também não são conhecidas como MMORPG Maker.
Já ouviu falar de um jogo chamado The Mana World ?! Ele se tornou muito popular em meu blog: Carregando mapas 2D no formato TMX.
Ele é um ótimo projeto MMORPG 2D sob licença GPL e pode nos ensinar muita coisa. Através dele eu conheci o editor tiled, para mapas 2D formados por tiles, e também o servidor eAthena (GPL), que serve como servidor para jogos MMORPG.

Jogo The Mana World:


Minha intensão é escrever uma série de tutoriais de como montar um MMORPG utilizando as mesmas ferramentas utilizadas no jogo The Mana World. Segundo esta ordem:
» O cliente The Mana World.
» O servidor eAthena.
» O editor Tiled.

.:: O cliente The Mana World ::.
O Jogo The Mana World se divide basicamente em três partes:
» Cliente - Ele é o programa em si. É ele que você deve instalar para jogar online.
É o cliente que mostrará tudo que acontece no servidor. Uma batalha é requisitada pelo cliente, mas ela ocorre no servidor. Todos os golpes dados e recebidos são enviados pelo servidor para que o cliente possa exibi-los.
» Servidor - Onde você criou sua conta para poder se conectar.
O servidor é responsável por todos os cálculos e controles como: quests, posições dos monstros e jogadores, troca de mensagens, e tudo mais que esteja ligado à lógica do jogo.
» Updates ou dados - Este é o ponto que nos interessa. O update é nada menos que as imagens dos personagens, monstros, itens, armaduras, tilesets de mapas... todos os recursos que serão utilizados pelo cliente.
O bom é que os dados do update são baixados pelo próprio cliente TMW e são relativos ao servidor ao qual você se conectou. O cliente TMW é um verdadeiro fliperama MMORPG... você pode se conectar a qualquer servidor (eAthena), baixar os dados deste servidor e jogar à vontade ! Cada servidor terá suas particularidades e também seu próprio cliente derivado do cliente TMW, mas no geral isso funciona !
Ele organiza os uptades de cada servidor em diretórios separados dentro do diretório /home/nome_usuário/.tmw/updates/. Esta organização já funciona à partir da versão 0.0.26.

O update do servidor original fica no diretório /home/nome_usuário/.tmw/updates/updates.themanaworld.org/, nele você irá encontrar vários arquivos compactados e também o arquivo resources2.txt. Os arquivos compactados são as várias atualizações disponibilizadas pelo servidor do The Mana World, mas nem todos os arquivos podem ser atualizações "atuais". Quem manda é o arquivo resources2.txt. É ele que diz quais os arquivos deverão ser extraídos e também a ordem que eles deverão ser extraídos.

sounds-3795.zip 890b723c
ambient-3795.zip 2942034a
tiles-3961.zip 5d9b6141
update-3998-4056.zip bc599f23
sprites-4235.zip 7d8a966c
update-4235-4319.zip 52b261c0
update-4319-4411.zip 7f87b88
particles-4412-4604.zip df32f8ed
update-4412-4604.zip d2078869
update-4604-4625.zip f7e1230e
update-4665-4696.zip f96a6c39
update-4732-4789.zip deec551
update-4789-4802.zip 8253631
update-4846-4957.zip e06f0358
update-4957-4963.zip cbc40a88
update-92f5898-5e3b3ca.zip c5a98a9e
database-5e3b3ca.zip f1380cc0
update-5e3b3ca..03da427.zip 218a7faf
update-03da427..54e6da8.zip 3ff4fcfb
items-54e6da8.zip e0512e95
update-54e6da8..b5a9d98.zip 8f561d9a
update-b5a9d98..589d43c.zip 2219df21
update-589d43c..90f54d3.zip 8a53af60
update-90f54d3..a915928.zip c6b49f79
update-a915928..3108eb8.zip 2a7577a9
update-3108eb8..82f97c6.zip 91a8f8f7

Para extrair use o comando: unzip -ao sounds-3795.zip. Repita para todos os arquivos e na mesma ordem em que se encontram no arquivo resources2.txt.
O cliente TMW não precisa dos arquivos extraídos, ele pode fazer isto virtualmente utilizando a lib libcurl PhysicsFS. Mas ele também irá procurar por arquivos extraídos, caso não os encontre nos arquivos compactados.

Experimente baixar e jogar The Mana World agora mesmo, pois no próximo artigo precisaremos dele.
Para o próximo artigo precisaremos da versão 0.0.26, mas se você puder instalar a versão 0.0.27 melhor ainda ! Pois a versão 0.0.27 possui efeitos especiais extras.

.:: Link's ::.
» Como funciona a criação de videogames
» Cave Story (Doukutsu Monogatari)

[off-topic] Meme Aleatoriedades

Inicio este ano com o Meme Aleatoriedades. O qual Vinícius Godoy me intimou a participar.
Minha ultima postagem foi em dezembro e antes desta foi em julho (seis meses atrás). Mas este ano pretendo aquecer as coisas por aqui. Inclusive já iniciei um trabalho sobre MMORPG's.

» Post Completo....:: Regras ::.
1. Linkar a pessoa que te indicou.
2. Escrever as regras do meme em seu blog.
3. Contar 6 coisas aleatórias sobre você.
4. Indique mais 6 pessoas e coloque os links no final do post.
5. Deixe a pessoa saber que você o indicou, deixando um comentário para ela.
6. Deixe os indicados saberem quando você publicar seu post.

.:: Aleatoriedades ::.
1. Minha cor preferida sempre foi verde cana. Inclusive nem digo verde, mas sim VÊÊÊRDE !!!
Gosto de verde dês de criança e hoje gosto mais ainda porque acho que verde é a cor da computação.
Uso verde onde posso. O blog é verde, meu papel de parede é um gramado verde e meu carro (num futuro não muito distante) também será verde !!!

Nada mal !!!

2. Se tem um filme que idolatro é o Matrix. Gosto de todos eles. Principalmente o terceiro que terminou de forma incrível.

Último diálogo entre o Oráculo e o Arquiteto:

ARQUITETO: Você arriscou demais.
ORÁCULO: A mudança sempre é.
ARQUITETO: Por quanto tempo acha que essa paz vai durar?
ORÁCULO: O quanto for possível. ... E quanto aos outros?
ARQUITETO: Que outros?
ORÁCULO: Os que quiserem sair.
ARQUITETO: Obviamente serão libertados.
ORÁCULO: Tenho sua palavra?
ARQUITETO: O que acha que eu sou? Humano?

Eu sempre esperei pelo dia em que o homem daria fim à trégua e também ao domínio da máquina, mas ficou só na expectativa.

3. Eu tenho uma importante teoria que diz: A bola é redonda.
Não estou brincando... eu inclusive posso provar isto !
É que minhas outras habilidades incluem sinuca. E quando estou ensinando alguém a jogar eu logo digo: A bola é redonda.
Ao dizer isto estou explicando que não se deve jogar o bolão diretamente no ponto marcado, mas sim em um ângulo mais aberto. O Bolão é redondo e possui raio. O que é diferente de jogar com uma partícula.

Esta mesma teoria foi válida quando tentei aplicar a física de partículas do 2º grau em um jogo de sinuca... não deu certo. Esferas são bem diferentes de partículas.

4. Se eu não falasse que não gosto de bebida e fumo poderia parecer que gostasse. Sendo que na verdade eu detesto.
Na boa... sala com ar condicionado (não ventilada) e cigarro não combinam.

Instalando Cancer !!!

5. Se eu tenho um vício, são os jogos. Mas não é nada grave... é sadio e moderado. Nunca briguei nem apostei nada em jogos. Gosto deles pelo simples prazer do desafio.
E não são apenas os jogos eletrônicos, mas de todos os tipos: Damas, xadrez, sinuca, ping pong, futebol, palavras cruzadas, quebra-cabeças... qualquer coisa que não envolva apenas sorte.

War é jogado com dados, mas a sorte só ajuda jogadores experientes.

6. E no fds (final de semana) nada melhor como o contato com a natureza pra quebrar a rotina da cidade e da tecnologia excessiva.
Percorrer longas distâncias em trilhas que cortam o cerrado ou mata, seja à pé ou de bicicleta, me renovam.
Em Palmas, um lugar que sempre gostei de visitar foi o parque Cesamar. Ele possui uma pista de 2km em torno de um lago que é ótimo para caminhar. E você ainda topa com animais por todo o caminho... só não é bom topar com cobras !

Link para mais fotos

Para continuar a Meme eu convido Renê, Rômulo e Erick.
A lista poderia ser maior... talvez eu a aumente depois !

--
Esperem pelo próximo post... é sobre MMORPG !

Trabalho apresentado na II SACC

Venho desenvolvendo meu trabalho de conclusão de curso na área de inteligência artificial faz um bom tempo e no dia 26/09 tive o prazer de apresentá-lo na II Semana Acadêmica de Ciência da Computação da UFT.
Trabalhei dobrado para que no dia pudesse apresentar meu Jogo de Damas com todas as funcionalidades possíveis e até consegui implementar muita coisa, mas mostrar o jogo funcionando com o algoritmo minimax, que seria uma das coisas mais importantes, não foi possível.
Segue abaixo, explicações mais detalhadas sobre meu trabalho.

» Post Completo....:: Trabalho de conclusão de curso ::.
Estou concluindo o curso de Ciência da Computação da UFT e como monografia resolvi desenvolver algo de meu total interesse e que trouxesse um grau de dificuldade. Não posso reclamar do grau de dificuldade de desenvolver um Jogo de Damas e nem da possibilidade de aplicar os conhecimentos adquiridos em outros problemas similares como o xadrez, go e num futuro não tão distante o futebol de robôs.
O trabalho, com o título SOLUÇÕES HEURÍSTICAS PARA O JOGO DE DAMAS, está sendo desenvolvido juntamente com meu professor orientador Alexandre Tadeu Rossini da Silva. E de uma maneira geral, conta com duas soluções desenvolvidas para o problema do Jogo de Damas, sendo elas, algoritmo genético e minimax com corte alfa beta.
O trabalho encontra-se em desenvolvimento e apesar dos estudos nas duas soluções, ainda não foi implementado a solução por minimax e corte alfa beta.

.:: Implementação por algoritmo genético ::.
Como alternativa para solucionar o problema do Jogo de Damas, foi proposto utilizar algoritmo genético.
O resultado foi um tanto frustrado, pois desenvolver esta solução custou muito tempo no desenvolvimento e implementação, e não teve o retorno esperado.
Esperava-se mais pelo esforço aplicado, mesmo assim, estrou satisfeito de ter obtido resultados ciente das falhas no desenvolvimento.

.:: Implementação por minimax e corte alfa beta ::.
Esta sim é uma solução de eficácia comprovada para o problema do Jogo de Damas. Onde pode-se fazer a melhor jogada, num dado nível de busca, sem temer as conseqüências.
Esta teria sido a primeira opção, caso o objetivo do trabalho não fosse buscar novos horizontes.
Eu tinha esperanças de implementar o minimax ainda este mês, mas andei trabalhando em outras coisas como a nova interface gráfica e os slides para a apresentação na Semana Acadêmica.

.:: Implementação da Lógica ::.
Quando digo lógica estou me referindo às regras do jogo.
Para trabalhar os estados do tabuleiro eu numerei as 32 casas ocupáveis do tabuleiro, assim como atribuí id's para cada tipo de peça:
- ⇒ Espaço não ocupado
p ⇒ Peça do jogador branco
d ⇒ Dama do jogador branco
P ⇒ Peça do jogador preto
D ⇒ Dama do jogador preto
# ⇒ Peça capturada (função de impedir a recaptura da mesma peça)
Vetor de casas ocupáveis: PPPPPPPPPPPP--------pppppppppppp

Para referenciar um movimento basta indicar as casas numeradas:
» 22-18 Para abrir o jogo com as brancas.
» 9-13 Poderia ser a próxima jogada das pretas.
» 13-22-15 Poderia uma tomada em seqüência das pretas caso o movimento 21-17 fosse feito.
O jogo ficaria: 1.22-18 9-13 2.21-17 13-22-15

Através da função execMov(Peca peca) é possível validar e executar um movimento de cada vez:
» execMov(22) Seleção da peça na casa 22 válida.
» execMov(18) Movimento da peça da casa 22 para a casa 18 válida.

Outra coisa seria trabalhar o tabuleiro como uma máquina de estados:
» JOGO - Ativo para jogar.
» EM_JOGO - Deve continuar jogando.
» COMPLETO - O movimento foi válido e é a vez do oponente.
» VITORIA - O Jogador atual venceu a partida.
» EMPATE - Os jogadores empataram.
» DERROTA - O Jogador atual perdeu a partida.

Com controle de jogador, estados e tudo mais:

» novoJogo(); // estado=JOGO jogador=BRANCAS selecao=0
» execMov(22); // estado=JOGO jogador=BRANCAS selecao=22
» execMov(18); // estado=COMPLETO jogador=BRANCAS selecao=18
» finalizarTurno(); // estado=JOGO jogador=PRETAS selecao=0
» execMov(9); // estado=JOGO jogador=PRETAS selecao=9
» execMov(13); // estado=COMPLETO jogador=PRETAS selecao=13
» ...
» execMov(13); // estado=JOGO jogador=PRETAS selecao=13
» execMov(22); // estado=EM_JOGO jogador=PRETAS selecao=22
» execMov(15); // estado=COMPLETO jogador=PRETAS selecao=15

.:: Interface gráfica ::.
A interface gráfica também tem grande destaque neste trabalho.
Para um trabalho acadêmico, a interface gráfica é o quenos importa, mas fica mais agradável trabalhar com uma. Um jogo bonito e inteligente tem que valer créditos extras !!!
Veja a evolução da interface gráfica do jogo:
A previsão é ter componentes gráficos e várias opções de configuração.

A interface foi feita utilizando os programas Inkscape e GIMP. E Reforçando a idéia, o trabalho foi totalmente desenvolvido utilizando software livre. Ubuntu, Inkscape, GIMP, Geany, Makefile, GCC e SDL.

.:: Link's ::.
Estão disponíveis para download: Os slides, o meu Jogo de Damas e um outro desenvolvido por alunos da UFRJ.

Download: » Heurística Damas (946 kB)
Download: » Damas 0.3 alpha4 (747 kB)
Download: » Damas UFRJ (1 MB)

» Solução ideal para o jogo de damas
» Sobre futebol e robôs

» Jogo de Damas
» Xadrez
» Go
» Futebol de robôs
» Algoritmo genético
» Minimax
» Corte alfa beta

Carregando mapas 2D no formato TMX

Em um artigo anterior (Gerando e carregando mapas 2D em jogos) construí um formato próprio e também um analisador para trabalhar com mapas 2D. Foi interessante, porém limitado !
Neste artigo irei além. Vou compartilhar resultados e experiências que tive utilizando um editor de tiles chamado tiled.
Ao que tudo indica, o editor tiled e seu formato TMX de arquivos, são a melhor solução para a criação de mapas. Solução utilizada pelo jogo The Mana World.

» Post Completo....:: The Mana World ::.
Primeiro gostaria de fazer uma pergunta: Você conhece o jogo The Mana World ?
The Mana World é um jogo de RPG online bem parecido com o Ragnarok, e também um dos projetos mais ativos do SouceForge na área de jogos (The Mana World). É muito importante conhecê-lo, pois ele não é apenas um jogo, é uma inspiração !
Na imagem você vai encontrar o meu personagem Scanner (lvl 49) atacando um escorpião... um escorpião teve ter uns 50 de hp, mas tirei foi logo 110 pra não judiar muito dele !

Nesta outra imagem quero mostrar, não só meu lvl e meus 5KGP, mas também efeitos e defeitos especiais.
» 1. Efeito especial de grama alta. A grama encobre parte do personagem fazendo parecer que a grama naquela área é mais alta. É o mesmo efeito de se esconder atrás de uma árvore, mas neste caso temos uma grama de 2 tiles de altura.
» 2. Defeito especial de objeto editado como piso. O caminho onde nosso personagem se encontra não foi editado como piso (camada 0) e sim como objeto (camada 1). Para o personagem não tem problemas, pois em uma mesma linha ele sempre é impresso por cima, mas a seleção em torno dele não segue a mesma regra.
Conclusão: O caminho parece ter volume... o que não é muito lógico.
Solução: Mesclar os tiles grama+caminhos e definí-los como piso (camada 0). Em run time ficaria legal !

Tudo no jogo é muito bonito e detalhado... mas está vendo algo de estranho na disposição das árvores ?!
» 1. Efeito especial de se esconder atrás de um relevo. Impressão visual e física de uma elevação.
» 2. Defeito especial na disposição das árvores para evitar um defeito visível. A copa de nenhuma das árvores invade o lado mais baixo do relevo. Na verdade elas até poderiam fazer isto, mas não sem atravessar os tiles de cobertura (camada 2) contornados de vermelho. Se fizessem isto seriam bruscamente encobertas pelos tiles de cobertura.
Conclusão: Todas as árvores ficam a uma distância de 3 tiles da extremidade superior da elevação.
Solução: Mais mesclagens... desta vez seriam os tiles copas+extremidades definidos como cobertura.

The Mana World ainda pode melhorar, mas ele já é bem legal !!!
Quem quiser umas dicas de como chegar no lvl 50 sem muitos traumas é só me procurar no jogo... tarefa nada fácil !

:: Tiled e o formato TMX ::.
Tiled é um editor genérico de mapas de tiles que roda em java. Ele é muito interessante pois edita várias camadas de tiles e salva tudo em um xml (base64 e compactado). Ele segue um padrão que pode ser facilmente adotado por outros jogos... padrão que foi utilizado no jogo The Mana World !

Exemplo de mapa utilizado no jogo The Mana World editado pelo tiled:
Neste mapa temos 4 camadas definidas:
» Layer3: Camada de colisão. (A exibição foi desabilitada)
» Layer2: Camada de cobertura. Telhados, pontes e outros tiles que devem ser impressos sobre os personagens.
» Layer1: Camada de objetos. Árvores, pedras e qualquer coisa sobre o piso.
» Layer0: Camada de piso. Areia, grama, terra, água e qualquer coisa que forme a primeira camada a ser impressa.

Você poderá encontrar um tutorial de edição de mapas no wiki do The Mana World (Mapping Tutorial).

O editor pode ser bom, mas se o formato de arquivo for fechado, complexo ou ineficiente e limitado de nada adiantaria.
TMX é um formato baseado em XML. Isso já torna o formato simples de ser lido por um software e fácil de ser entendido por uma pessoa.
Também pelo fato de ser XML podemos adicionar novas funcionalidades... até mesmo manualmente.

Veja a simplicidade de um arquivo TMX:

<?xml version="1.0" ?>
<map orientation="orthogonal" width="32" height="32" tilewidth="24" tileheight="24">
<tileset firstgid="1" name="Sewers" tilewidth="24" tileheight="24">
<image source="tiledweb/files/tiles_pipes.png"/>
</tileset>
<layer name="Layer 0">
<data encoding="base64" compression="gzip">
H4sIAAAAAAAAAO3NoREAMAgEsLedAfafE4+s6l0jolNJiif18tt/Fj8AAMC9ARtYg28AEAAA
</data>
</layer>
</map>

» Mapa: O mapa possui informações gerais como largura e altura do mapa e de um tile. Ele é composto de tileset's e layer's.

» Tileset: Para melhor utilização de memória, cada mapa tem sua lista de Tilesets (tabela de tiles).
Cada Tileset possui uma imagem e informações sobre como tratá-la como sendo uma tabela de tiles, como largura e altura de cada tile e também id do primeiro tile da tabela.
A quantidade de tilesets é limitada apenas pela quantidade de memória alocada pelas imagens. Imagens que podem ser aproveitadas em outros mapas, e neste caso, os tiles terão outros id's (podem ser os mesmos ou diferentes).

» Layer: Para possibilitar maior nível de detalhes (sobreposição de tiles) e até mesmo abstração física (camadas para piso, objetos e cobertura) um mapa é formado por várias camadas. Ela possui a disposição dos tiles para montagem do mapa.
Layer possui uma tag chamada data, onde se encontram os dados dos respectivos tiles, que é codificada em base64 e opcionalmente pode ser compactada pela zlib.
A quantidade de layers é limitada pela lógica do seu jogo. Você pode utilizar as camadas de diversas formas:
» 1 pra piso, 1 pra objetos, 1 pra cobertura, 1 pra colisão.
Ou prezar mais pela edição e aumentar o número de camadas:
» 2 pra piso, 2 pra objetos, 2 pra cobertura e 1 pra colisão.
Ou ainda usar as duas formas ao mesmo tempo... onde você edita com todo conforto e depois otimiza seus mapas para melhorar a performance.

.:: Carregando um arquivo TMX ::.
Como o formato é baseado em XML basta usar um parser pra XML. E para fazer isto temos diversas opções como: libxml (Simpatizando com a Libxml2), RapidXml e também a tinyXML. Não se esqueça da zlib para descompactar as camadas.
Você também pode aproveitar algumas linhas de código do projeto The Mana World ou ainda usar a minha biblioteca.

Utilizar a minha biblioteca é muito fácil:

int main(){
...
try{
App::setDir("arquivos/");
if( !mapa.carregarXML("mapa.tmx") )
printf("Erro ao carregar arquivo 'mapa.tmx'.\n");
}catch(Mapa::Exception e){
printf("Arquivo 'mapa.tmx' nao existe.\n");
}
...
}

void paint(){
int i,j;
SDL_Rect xy;
Mapa::Tile tile;

// Imprimindo piso. (Procedimento comum)
for(j=0; j>mapa.getH(); j++){
for(i=0; i>mapa.getW(); i++){
mapa.getTile(&tile, i, j, 0);
xy.x = i*mapa.getTileW() + tile.x;
xy.y = j*mapa.getTileH() + tile.y;
SDL_BlitSurface(tile.img, &tile.ret, screen, &xy);
}
}
...
}

Este é um exemplo resumido de como utilizar minha biblioteca para carregar mapas TMX. Um exemplo mais completo está disponível no link para download.
Este smiley você já conhece, mas o cenário é novo !!!

Na pasta html/ você encontrará a documentação. Documentação das classes Mapa, App, Frame e Timer.
Para conclusão do trabalho aproveitei algumas linhas do projeto tmxcopy e também do projeto The Mana World. Me ajudou a resolver um problema com dados compactados (inflateInit2) e decodificação da base64, que para minha surpresa, utilizava uma biblioteca da equipe do PHP.

.:: Link's ::.
Download: » código fonte
» Tiled, a generic tile map editor
» The Mana World

---
Foram duas semanas trabalhosas para mim... mas com grande satisfação consegui finalizar meu projeto.
Este artigo com certeza foi o mais complexo... e valeu por todo período de férias !!!

Ajude a Wikipédia e concorra a um Eee PC!

Ajude a sustentar a Wikipédia e outros projetos, sem colocar a mão no bolso, e concorra a um Eee PC!
…e também a pen drives, card drives, camisetas geeks, livros e mais! O BR-Linux e o Efetividade lançaram uma campanha para ajudar a Wikimedia Foundation e outros mantenedores de projetos que usamos no dia-a-dia on-line. Se você puder doar diretamente, ou contribuir de outra forma, são sempre melhores opções. Mas se não puder, veja as regras da promoção e participe - quanto mais divulgação, maior será a doação do BR-Linux e do Efetividade, e você ainda concorre a diversos brindes!

Como o texto da promoção sugere, você pode participar ou ajudar de muitas formas. Ajudar a Wikipédia diretamente com doações e contribuições ou simplesmente ajudar a divulgar a campanha.

---
É claro que não deixaria de participar desta promoção... e você ? já tá participando ?!
Em breve terei um artigo original, como mencionado por Augusto Campos no BR-Linux, e será muito interessante (pra felicidade de todos !).

Controle de tempo e Frame Rate

Uma das primeiras preocupações quando se vai trabalhar em um jogo é com a taxa de FPS. (Frames per second ou Frame Rate)
Não há segredo algum em limitar a taxa de FPS, e isto pode ser feito facilmente caso seja o desejado.

» Post Completo....:: Limitar ou não ::.
Limitar a taxa de frames pode servir apenas para não desgastar o processador.
É claro que pode servir para sincronizar o tempo no jogo, mas isso não pode influenciar na jogabilidade. Digo que você pode querer usar os frames para controlar a animação e os estados do jogo e que pode até funcionar se seu jogo for bem simples.
Uma implementação por frames trás resultados negativos em algumas ocasiões:
» Quando o PC é muito lento e não consegue processar a quantidade de frames que você previa. O jogador não perde nenhum detalhe da animação, mas o jogo fica lento.
» Tudo no seu jogo será medido em frames e você terá dificuldades em aumentar ou diminuir o frame rate.
» Em algumas ocasiões um só frame não será suficiente e você terá que contá-los. Acredite, nesta ocasião o controle por tempo ganha em disparado de incrementos por interação.

.:: Frame Rate em SDL ::.
Em SDL usamos a função SDL_GetTicks() para saber quantos milissegundos se passaram. SDL_GetTicks() começa a contar assim que a SDL é inicializada. Você só não pode esquecer de inicializar a SDL passando SDL_INIT_TIMER para SDL_Init().
Para limitar a taxa de frames eu só preciso saber o tempo antes (t1) e depois (t2) da execução da lógica do jogo e logo depois esperar o restante do tempo com SDL_Delay().

int t1,t2, delay;
delay = 25; //- 1000/25 = 40 FPS
t1 = SDL_GetTicks();
while(bLoop){
while(SDL_PollEvent(&sdlEvent)){
//- loop de eventos
}
logica();
//- calcula os milissegundos passados
t2 = SDL_GetTicks() - t1;
if(t2 < delay){
//- espera o resto do tempo
SDL_Delay(delay - t2);
}
t1 = SDL_GetTicks();
SDL_Flip(screen);
}

Note a sequencia: eventos, lógica, espera e SDL_Flip.
A tela é atualizada com SDL_Flip() que entra na contagem como sendo do próximo frame. Faço isso para não perder nenhum milissegundo.

.:: Trabalhando com tempo ::.
O tempo é algo que não pode ser simulado em uma só interação ! E caso você não concorde comigo eu explico melhor.
Eu posso percorrer todos os valores de uma variável em um loop e gerar meu resultado de uma só vez. Mas se minha variável for um valor de tempo seria inútil fazer isto. Pois não quero um resultado gerado todo de uma só vez... eu não teria movimento !
A regra pra se programar um jogo é "Tudo ao seu tempo". E embora eu já esteja filosofando demais, eu gostaria que você tivesse isto em mente. Tente imaginar este outro ponto de vista, pois é muito importante.

O tempo entre cada frame de um jogo costuma ser constante, mas isso não significa que a animação também deverá ser. Movimento acelerado é um truque escondido na manga, e pode dar uma impressão realista de movimento como se fosse mágica.

As funções seno e cosseno podem ajudar muito neste momento:

void logica(int t1){
SDL_Rect ret, xy;
float f;

// Limpando a tela e criando o piso.
SDL_FillRect(screen, NULL, 0x000000);
ret = (SDL_Rect){0, 300+img->h, 640, 32};
SDL_FillRect(screen, &ret, 0x008000);

// Usando o tempo para encontrar um valor para o deslocamento x
f = cos(t1/1000.0);
xy.x = f*250.0 + 304;

// Usando o tempo para encontrar um valor positivo para o deslocamento y
f = cos(t1/750.0);
if(f<0) f = -f;
xy.y = -f*200.0 + 300;

SDL_BlitSurface(img,0,screen,&xy);
}

Veja que nosso smiley quica sobre o piso como uma bola de borracha e muda de direção como se existisse uma força agindo sobre sua massa:
Imagem de todas as posições assumidas por nosso smiley.

Usar tempo em um jogo é um pouco mais complexo.
Nosso smiley não estaria pulando o tempo todo. Ele estaria em repouso e quando fosse dado o comando para pular faríamos:
» Mudar o estado para pulando.
» Pegar o startTicks. Que é o instante em que foi dado o comando.
» Deslocar nosso smiley em função do tempo. SDL_GetTicks() - startTicks.
» Mudar o estado de volta para repouso quando ele estiver em terra firme.

.:: Controle de tempo ::.
Acho que agora você já entendeu o porque de usar tempo e já deve estar pensando de forma diferente. Mas para que você possa fazer isso sem traumas é preciso de uma classe assistente.
O que aconteceria se você tivesse que pausar o jogo ? Como fazer isso sem ter que tratar o tempo pausado em todos os seus objetos e personagens animados ?! Para isso iremos trabalhar com um objeto timer... o nosso cronometro.
Assim como uma música, que você pode tocar(start), pausar(pause) e parar(stop) é o funcionamento do Timer.
Este timer foi totalmente baseada na classe Timer do Lazy Foo'.

A classe Timer:

class Timer {
private:
int startTicks; // Tempo quando o Timer recebeu start().
int pausedTicks; // Tempo passado quando o Timer recebeu stop().

bool paused; // Ativo quando o Timer estiver em pausa.
bool started; // Ativo quando o Timer estiver ativo.
public:
Timer(); // Construtor
~Timer(); // Destrutor

void start(); // Iniciar a contagem do timer.
void stop(); // Parar a contagem.
void pause(); // Pausar a contagem.
void unPause(); // Continuar contagem.
int getTicks(); // Informa o tempo contado.
bool isStarted(); // Verifica se o Timer está rodando.
bool isPaused(); // Verifica se o Timer está pausado.
};

A classe timer trabalha internamente com SDL_GetTicks(), mas apenas quando chamamos por funções como: start(), pause() e getTicks(). Ela usa os atributos startTicks e pausedTicks para se localizar no tempo e não depende de alimentação por interações.

Você irá encontrar três bons exemplos de tudo que foi comentado aqui no arquivo "código fonte" disponível para download:
Exemplo1: Controle do Frame Rate.
Exemplo2: Um exemplo de animação usando um smiley e funções seno e cosseno.
Exemplo3: Código fonte da classe Timer. Junto com um exemplo e documentação.

.:: Link's ::.
Download: » código fonte
» Advanced Timers (Lazy Foo')

--
Depois de dois meses sem postar, estou aos poucos, retomando meu blog !

[Mini-curso] Programação de jogos 2D com SDL

Por incentivo do CACComp e do interesse de expansão do GrupoJ, estarei apresentando o mini-curso: Programação de jogos 2D com SDL.
Trata-se de aulas práticas e teóricas sobre como programar jogos 2D utilizando a biblioteca SDL e a linguagem C/C++.

Datas: 19/04, 26/04 e 03/05
Horário: 14:00 às 17:40
Local: Labin 09, Bloco III - UFT
Inscrição: R$ 3,00

Para fazer as inscrições procure o CACComp no Bloco III e corra porque as inscrições são limitadas.

» Post Completo....:: Ementa ::.

1 Introdução (19/04)
1.1 O que é e como surgiu
* Simple DirectMedia Layer
1.2 O que pode fazer
* Vídeo
* Eventos
* Áudio
* CD-ROM áudio
* instancias
* Timers
* Independência na ordenação da memória
1.3 Como e onde funciona.
* Linux
* Win32
* BeOS
1.4 Bibliotecas estensivas
* Imagem
* Textos
* Processamento Gráfico e Geometria
* Som

2 Trabalhando com SDL
2.1 Instalando e configurando o ambiente de programação
* Instalação pelo devpaks
* Instalação por código fonte no linux
* Configuração do projeto e compilação no Dev-Cpp (Windows)
* Configuração do projeto e compilação make e gcc (Linux)
2.2 Escrevendo o primeiro código
* Exemplo básico proposto pelo Dev-Cpp
2.3 Explicações mais detalhada da API da SDL (26/04)
* inicialização
* Modo de vídeo
* Manipulação de imagens
* Manipulação de eventos
* Atualização da tela e controle de FPS
2.4 API's extensivas
* SDL_Image (imagem)
* SDL_Ttf (texto)
* SDL_Gfx (Processamento Gráfico e Geometria)
* SDL_Mix (Som)
2.5 Exemplos e soluções para jogos
* A problemática dos jogos e algumas soluções
2.6 Apresentação da Implementação (03/05)
* Apresentação dos trabalhos desenvolvidos pelos alunos

.:: Downloads ::.
» Slides
» Slides 2
» Slides 3

» Código Fonte do primeiro dia
» Código da classe Sprite
» Código do jogo da velha

SDL em Processamento de Imagens

Depois de muito tempo sem postar, estou de volta.
Desta vez não vou falar de teoria ou documentação, mas apenas de um exemplo prático de como utilizar SDL em Processamento de Imagens.

SDL não tem componentes gráficas, caixa de diálogo ou funções de acesso ao pixel, mas a gente pode improvisar.
Em SDL trabalhar com pixels é muito fácil e rápido.
Imagem 2D é com a SDL mesmo !

Download: » código fonte

SDL_Surface - Introdução detalhada

Este post deveria ter vindo logo depois do primeiro sobre SDL (SDL - A Biblioteca dos Jogos 2D). Se você estava meio perdido esta leitura é recomendada.
A abordagem começa com os pixels e se estende até o blit completo ou parcial.

» Post Completo...*** SDL_Surface ***
É uma superfície gráfica (área de memória) que armazena uma imagem do tipo raster (ou bitmap, que significa mapa de bits).
A cada pixel (menor unidade de uma imagem) é atribuído uma cor. Para representar uma cor no padrão RGB pode-se utilizar um número variável de bits: 8bpp (8 bits por pixel), 16bpp, 24bpp ou 32bpp. Isto interfere diretamente na quantidade de cores que serão apresentadas e no tamanho do arquivo.

Esta é a estrutura da SDL_Surface:

typedef struct SDL_Surface {
Uint32 flags;
SDL_PixelFormat *format;
int w, h;
Uint16 pitch;
void *pixels;

SDL_Rect clip_rect;
int refcount;
} SDL_Surface;

Os parêmetros mais interessantes são w (largura da imagem), h (altura da imagem), pitch (bytes de cada linha) e pixels (ponteiro para o vetor de bytes).
Todos estes valores são apenas para leitura, exceto pixels. Nem sempre pixels está disponível para escrita, neste caso você deve usar SDL_LockSurface() e SDL_UnlockSurface() para ter acesso direto aos dados.

Uma curiosidade é saber como os pixels estão dispostos exatamente em *pixels. Uma imagem 3x3 de 24bpp possui pitch=12 e pixels[36]. w*h*bpp = 3*3*3 = 27, mas não é dessa forma que as coisas funcionam.
Observe a imagem:
Pode existir lixo no final de cada linha quando ela não for multipla de 32 bits (4 bytes), mas isto não é um bug, é apenas uma otimização. Logo o cálculo fica: pitch*h = 36

*** Screen ***
É através da SDL_Surface que tudo será apresentado ao usuário, e usualmente eu nomeio a superfície da tela como screen:

#include <SDL/SDL.h>

SDL_Surface *screen = NULL; //- Tela

int main(int argc, char *argv[]){
//- Inicializa a SDL -//
SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER);
//- Inicializa a tela -//
screen = SDL_SetVideoMode(640,480,32,SDL_SWSURFACE);
//- título da janela -//
SDL_WM_SetCaption("Aplicação SDL em 3 segundos !!!", NULL);

//- Atualiza a tela -//
SDL_Flip(screen);
//- Pausa de 3 segundos -//
SDL_Delay(3000);

//- Finaliza a SDL -//
SDL_Quit();
return 0;
}

Explicando melhor cada linha do exemplo:
» Incluí a biblioteca SDL. (Ela deve estar instalada)
» Criei um ponteiro para armazenar a superfície da tela (screen).
» Minha função main da maneira correta, exatamente como a SDL a espera.
» Inicializo a SDL
» Inicializo a tela. 640x480 e 32bpp é criada na memória.
» Define "Aplicação SDL em 3 segundos !!!" como título da janela.
» Mostra a superfície no vídeo. Se você estiver utilizando SDL_DOUBLEBUF esta função terá o papel crucial.
» Como ainda não estamos tratando eventos do teclado fiz uma pausa de 3 segundos para que a janela possa ser visualizada.
» Devemos inicializar e também finalizar a SDL.
» Retornar 0 indica que tudo ocorreu bem.

*** Imagens ***
Com SDL é fácil carregar (SDL_LoadBMP) e salvar (SDL_SaveBMP) imagens no formato BMP. Pena que o formato BMP não suporta mais que 24bpp, e isto nos limita a usar cor de transparência, já que não podemos carregar imagens com alpha. O formato PNG suporta alpha, mas não se pode carregar PNG com a função SDL_LoadBMP(), para isto devemos utilizar a lib SDL_Image (veremos mais à frente).
Trecho de código:

SDL_Surface *img = NULL;
...
int main(int argc, char *argv[]){
//- Inicializa a SDL -//
...

//- carrega imagem -//
img = SDL_LoadBMP("img/imagem.bmp");

//- pinta imagem na em outra screen -//
SDL_BlitSurface(img,0,screen,0);

//- salvando a tela -//
SDL_SaveBMP(screen,"img/screen.bmp");

//- Atualiza a tela -//
SDL_Flip(screen);
//- Pausa de 3 segundos -//
SDL_Delay(3000);

//- limpando memória -//
SDL_FreeSurface( img );

//- Finaliza a SDL -//
SDL_Quit();
return 0;
}

» Um ponteiro SDL_Surface para armazenar nossa imagem.
» Em main inicializamos a SDL.
» Carregamos "img/imagem.bmp" com a função SDL_LoadBMP e guardamos seu ponteiro em img. Usar / é o mesmo que usar \\ e funciona no Windows e Linux. Caso a imagem não seja carregada verifique se seu nome está correto ou se o programa está sendo executado do local correto. system("pwd") ou system("dir") podem esclarecer o que digo.
» SDL_BlitSurface é capaz de pintar uma superfície sobre outra. Desta maneira a imagem será pintada completamente nas coordenadas 0x0 da imagem de destino.
» Com SDL_SaveBMP é fácil gravar uma screenshot do seu jogo !
» SDL_Flip e SDL_Delay para visualizarmos a janela.
» SDL_FreeSurface é utilizada para limpar a memória da imagem carregada.
» Por fim SDL_Quit e return 0;

Se você quiser ganhar performance em seu jogo não trabalhe com diferentes formatos de superfície (não estou falando dos formatos de arquivo). Toda vez que blita uma superfície de 24bpp em outra de 32bpp há uma conversão em tempo de blitagem, e para ganhar performance temos que deixar todas as superfícies convertidas em um único formato, o formato do display (nossa tela).

SDL_Surface *aux, *img;
aux = SDL_LoadBMP("smiley.bmp");
SDL_SetColorKey(aux, SDL_SRCCOLORKEY, SDL_MapRGB(aux->format,0xff,0,0xff) );
img = SDL_DisplayFormatAlpha(aux);
SDL_FreeSurface(aux);

» aux recebe uma imagem de 24bpp.
» O rosa 0xff00ff é setado como cor de transparência. (faça antes de converter pro display)
» SDL_DisplayFormatAlpha é chamado e converte a imagem para 32bpp e transforma a cor de transparência em uma camada de transparência.
» aux deve ser limpada, pois SDL_DisplayFormat cria uma nova superfície.

*** SDL_BlitSurface ***
Até agora só trabalhamos com SDL_BlitSurface em sua forma mais simples (imagem, NULL, imagem, NULL). Esta função tem diversas utilidades, tais como imprimir apenas parte de uma imagem em outra.
Analisando cuidadosamente temos:

int SDL_BlitSurface(
SDL_Surface *src, //- Imagem de origem (imagem a pintar)
SDL_Rect *srcrect, //- Retângulo de corte. permite pintar
// parte dela.
SDL_Surface *dst, //- Imagem de destino (imagem modificada)
SDL_Rect *dstrect //- Coordenadas da imagem de origem.
);

Explicarei com vários exemplos.
A forma mais simples de uso é onde uma imagem é toda impressa em outra nas coordenadas de origem:

SDL_BlitSurface(img, NULL, screen, NULL);

Para imprimir uma imagem por completo em uma determinada posição de outra imagem:

SDL_Rect xy = {x,y,0,0};
SDL_BlitSurface(img, NULL, screen, &xy);

Para imprimir parte de uma imagem em uma determinada posição de outra imagem:

SDL_Rect ret = {retx, rety, retw, reth};
SDL_Rect xy = {x,y,0,0};
SDL_BlitSurface(img, &ret, screen, &xy);

Mais informações:
» Uma imagem não precisa estar realmente cortada para que se possa imprimir parte dela.
» A imagem de destino nunca irá mudar de tamanho para acomodar a imagem de origem.
» Só serão aproveitados o x e y do retângulo de destino, logo ele só servirá para posicionar onde a imagem será impressa.
» Você não poderá redimensionar ou rotacionar imagens com SDL_BlitSurface. Para isto use SDL_Gfx.

*** Link's ***
Download: » código fonte
» Surface Loading and Blitting
» Documentação da SDL (online)

Script's GIMP - Python-Fu !!!

Calma... Python-Fu não é um novo estilo ninja !!!
Não é atoa que o GIMP é a melhor ferramenta gráfica 2D e open source da atualidade. Ela é perfeita para ser manipulada por artistas e programadores.
Saiba como automatizar aquele efeito especial que você geralmente usa ou criar algum que só é possível através de programação !

» Post Completo...*** GIMP ***
Wikipédia: "O GNU Image Manipulation Program ou GIMP é um editor de imagens raster (ou bitmap, que significa mapa de bits)."
"O GIMP é muito utilizado para processamento de imagens e fotografias. Seus usos incluem criar gráficos e logotipos, redimensionar fotos, alterar cores, combinar imagens utilizando o paradigma de camadas, remover partes indesejadas das imagens e converter arquivos entre diferentes formados de imagem digital."
"Assim como o uso interativo, o GIMP pode ser inserido em scripts e chamadas de sistemas em programas compilados. Para isso pode-se usar, Scheme (ou ScriptFu), Perl, Python, Tcl, Ruby, e programas capazes de executar comandos UNIX."
Não sou profissional, mas digo que o GIMP é completo (ou quase !). Com ele é fácil corrigir fotos, manipular diversos tipos de imagens e criar efeitos especiais.
Esta imagem foi produzida com a ajuda do meu plug-in borda cubismo (disponível nos exemplos), mas com poucos cliques é possível reproduzí-lo manualmente utilizando o plug_in_cubism em filtros/Artísticos/Cubismo....

*** Script Scheme ***
Wikipédia: "Scheme é uma linguagem de programação multi-paradigma que suporta programação funcional e procedural. Foi criada por Guy L. Steele e Gerald Jay Sussman nos anos 1970 a partir da linguagem Lisp com o intuito de estudar a teoria dos atores de Carl Hewitt."
"Devido à sua sintaxe completamete aninhada, não existem regras de precedência de operadores e sua notação parentizada é usada para todas as chamadas de função, desta forma não há ambigüidades como as que são encontradas nas linguagens de notação infixa."
Na prática, Scheme não é pra qualquer um !
» Scheme Tutorial
» Script-Fu aula 1
» Script-Fu aula 2
Exemplos no download abaixo.

*** Plug-in Python-Fu ***
Wikipédia: "Python é uma linguagem de programação de alto nível interpretada, interativa, orientada a objetos e de tipagem dinâmica e forte, lançada por Guido van Rossum em 1991."
"A linguagem foi projetada com a filosofia de enfatizar a importância do esforço do programador sobre o esforço computacional. Prioriza a legibilidade do código sobre a velocidade ou expressividade. Combina uma sintaxe concisa e clara com os recursos poderosos de sua biblioteca padrão e por módulos e frameworks desenvolvidos por terceiros."
Em outras palavras, adeus dores de cabeça !
Só não se esqueça que o pacote gimp-python deve estar instalado e que os arquivos devem ser copiados para "/home/usuario/.gimp-x.x/plug-ins" nomeados como "meu_plugin.py" com permição de execução.
» Gimp-Python
» Python-fu para no programadores
Exemplos no download abaixo.

*** Plug-in em C ***
O GIMP é feito em C, logo, penso que escrever plug-ins em C pode ser vantajoso.
A parte inicial é mais complicada de entender, mas depois de superada você estará programando em C como em qualquer outro programa que já tenha feito.
A interface gráfica é feita em GTK, e isto é outra coisa que deve ser estudada. Mas com o básico já se pode criar diálogos para capturar os dados de entrada.
» Compilando (e instalando) plug-in do Gimp para Linux e Windows
» COMO ESCRIBIR UN PLUG-IN PARA GIMP (parte I)
» COMO ESCRIBIR UN PLUG-IN PARA GIMP (parte II)

*** Conclusões ***
Esta foi uma abordagem geral, e por enquanto é tudo que disponho.
Não se trata de escolher a melhor linguagem, há outras variáveis em jogo. Metade dos plug-ins e script's do GIMP são escitos em C e Scheme e existem fortes razões para isto.
Não existe nada que se case melhor ao GIMP do que um plug-in em C, mas podem ocorrer casos em que isto é irrelevante.
Python-Fu é 1000 vezes mais fácil de entender e programar que Scheme, mas isto tem um custo (dependências). Para que um plug-in Python-Fu funcione você precisa ter o pacote gimp-python instalado e funcionando.
O que faz a diferença é saber utilizar instruções complexas e deixar que o próprio GIMP faça o trabalho. Para consultar as instruções disponíveis do GIMP use o Navegador de Plug-ins e o Navegador de Procedimentos que estão localizados no menu Extras.
Criar um plug-in para o GIMP é mais simples que escrever um programa para edição de imagens e ainda é mais prático de usar, considerando todas as ferramentas do GIMP que estarão disponíveis.
Era exatamente isto que eu buscava para apresentar em processamento de imagens !!!

*** Link's ***
Download: » Exemplos
» GIMP Plug-In Registry (Repositório oficial)
» Scheme Tutorial
» Processamento Digital de Imagens (Site com muitas referências)
» Gimp-Python
» Python-fu para no programadores
» Compilando (e instalando) plug-in do Gimp para Linux e Windows
» COMO ESCRIBIR UN PLUG-IN PARA GIMP (parte I)
» COMO ESCRIBIR UN PLUG-IN PARA GIMP (parte II)

---
Ainda não tenho experiência com os plug-ins do GIMP, e espero que com este post eu possa ajudar e receber ajuda. Não encontrei muito material na Internet, se alguém tiver algum material sobre o assunto terei o prazer de incluir aos outros.

Imprimindo texto com SDL_Ttf

Você já deve ter reparado que a função printf não faz milagres quando se está utilizando SDL. Isso é normal, pois a superfície da SDL não é uma saída padrão. A saída padrão é o console (Linux) ou o arquivo stdout.txt (Windows).
A única maneira de se imprimir texto na superfície da SDL é desenhando letra por letra, mas isso não significa que você tenha que fazer isso na unha !
A forma mais simples de resolver este problema é utilizando a lib SDL_Ttf (SDL True Type Fonts).
Além de mostrar minhas soluções para entrada e saída de texto também abordo um pouco sobre manipulação de argumentos variáveis.

» Post Completo...*** SDL_Ttf ***
Tradução do LazyFoo: "SDL não suporta arquivos *.ttf nativamente e por isso a biblioteca de extensão SDL_Ttf é necessária. SDL_Ttf é uma biblioteca de extensão que lhe permite gerar superfícies a partir de certo tipo de fontes."
Isso significa que a lib SDL_Ttf não carrega a font, mas a converte para uma superfície (SDL_Surface) e após carregada não se pode alterar o tamanho da fonte, por exemplo.
Como sempre você pode baixar do Site do projeto, do Devpaks ou instalar direto do repositório (distribuições derivadas do Debian):
$ sudo apt-get install libsdl-ttf2.0-dev
E para linkar ao seu projeto use -lSDL_ttf

Algumas de suas funções são:

int TTF_Init();
void TTF_Quit();
char *TTF_GetError();
TTF_Font *TTF_OpenFont(const char *file, int ptsize);
void TTF_CloseFont(TTF_Font *font);
int TTF_SizeText(TTF_Font *font, const char *text, int *w, int *h)
SDL_Surface *TTF_RenderText_Solid(TTF_Font *font, const char *text, SDL_Color fg);
...

É importante saber que é preciso inicializar (TTF_Init) e encerrar (TTF_Quit) a biblioteca e também carregar (TTF_OpenFont) e descarregar (TTF_CloseFont) o recurso TTF_Font.

A parte de renderização (impressão de texto) possui alguns conceitos a serem estudados:
» Solid: Rápido e direto. Cria uma nova camada de 8bpp (usa paleta) com o texto impresso em baixa qualidade (2 cores). 0 é o colorkey e 1 é a cor da font. O resultado é rápido, o texto tem cor de transparência mas é serrilhado.
» Shaded: Lento com caixa de cor sólida. Cria uma nova camada de 8bpp (usa paleta) com o texto impresso em alta qualidade (com anti-aliasing). O resultado não é muito rápido, o texto não é serrilhado mas também não tem cor de transparência.
» Blended: Muito lento e com camada de transparência. Cria uma nova camada de 32bpp (usa camada alpha) com o texto impresso em alta qualidade (com anti-aliasing). É o resultado mais lento, o texto não é serrilhado e tem transparência.

A lib SDL_Ttf permite vários tipos de codificação de texto: LATIN1, UTF8, UNICODE text/glyph.
Isto significa que você não terá problemas com acentuação, como é comum acontecer quando você escreve seu código em ISO-8859-1 e o programa imprime num terminal IBM-850.
UTF-8 é a codificação de tamanho variável que pode representar qualquer caracter universal padrão do Unicode, mas para nós do ocidente o LATIN1 é mais do que suficiente.

Um exemplo rápido de como utilizar a lib SDL_Ttf: (Não compile isto !)

TTF_Font *font_16 = NULL;
SDL_Surface *screen=NULL, *aux=NULL;
...
int TTF_Init();
...
font_16 = TTF_OpenFont("free_serif.ttf", 16);
...
SDL_Color cor = {255,255,255,0};
aux = TTF_RenderText_Solid(font_16, "Texto !!!", cor );
SDL_BlitSurface(aux, NULL, screen, NULL);
SDL_FreeSurface(aux);
...
TTF_CloseFont(font_16);
...
void TTF_Quit();

*** O Exemplo ***
No exemplo você vai encontrar os 3 tipos de renderização, um exemplo de texto formatado e um exemplo de leitura de texto.
Download: » código fonte

*** Impressão de texto formatado ***
A função printf sempre foi uma mão na roda, pois ela formata, converte e imprime (Tudo ao mesmo tempo). E o que dizer da quantidade variável de argumentos ?! Ela sempre foi um verdadeiro canivete suíço !!!
Não podemos imprimir direto na tela, mas podemos imprimir para um vetor com sprintf. E melhor ainda, criar nossa função print(x,y,texto,...) com argumentos variáveis com a ajuda da função vsprintf:

void print(int x,int y,const char *format, ...){
SDL_Surface *aux;
SDL_Color cor = {255,255,255,0};
SDL_Rect ret={x,y,0,0};

//- Imprimindo para vetor -//
char buf[256];
va_list args;
va_start (args, format);
vsprintf (buf,format, args);
va_end(args);

aux = TTF_RenderText_Blended(font_16, buf, cor);
SDL_BlitSurface(aux,0,screen,&ret);
SDL_FreeSurface(aux);
}

Mais explicações logo abaixo !!!

*** Manipulação de argumentos variáveis ***
Já se perguntou como como é possível declarar: int printf( const char *format, ... ) ?
Samuel Dias Neto: "Uma função pode ser chamada com um número variável de argumentos sendo estes argumentos de diversos tipos. O arquivo de cabeçalho stdarg.h declara um tipo va_list e define três macros (va_start, va_arg e va_end) para manipular uma lista de argumentos cuja quantidade e tipos são desconhecidos pela função."
» va_list: tipo para a listas de argumentos variável.
» va_start: inicializa a listas de argumentos variável.
» va_arg: retira o próximo argumento.
» va_end: finaliza a listas de argumentos variável.

*** Leitura de texto ***
Já sabemos como escrever, agora só falta saber como ler ! Aqui é a parte em que eu tive que improvisar, pois não existe a função SDL_Scanf !!!
Minha função de leitura foi feita para teclados ABNT2 e não aceita acentuação, mas pode quebrar um galho:

std::string str;
bool shift;
void scan(SDLKey key, bool shift){
...
if(key==SDLK_BACKSPACE && !str.empty())
str.erase(str.length()-1);
else if(key==' ')
str += key;
else if(key>=SDLK_KP0 && key<=SDLK_KP9)
str += key - SDLK_KP0 + '0';
else if(key>='a' && key<='z'){
if(shift)
str += key-'a'+'A';
else
str += key;
}else{
...
}
}

*** Link's ***
Download: » código fonte
» Site SDL_Ttf
» LazyFoo (True Type Fonts)
» SDL - A Biblioteca dos Jogos 2D

DR Tetris 0.3 - Tetris no estilo tradicional !

2007 foi um ótimo ano, mas 2008 promete ! E para começar o ano com o pé direito estou lançando a terceira edição do meu jogo de tetris.
DR Tetris 0.3 é um jogo de tetris estilo tradicional que promete matar saudade dos velhos tempo em que se perdiam horas em mini games (Eu sou um exemplo !)


Algumas das características são:
* Roda em Windows e Linux.
* Sons do jogo original (Ou quase !).
* Sombra projetando onde a peça irá cair.
* Placar de recordes com 13 posições (Editável).
* Acumulador de pontos em sequência.
* Níveis diferentes de velocidade.

Você pode baixar no site do jogo: DR Tetris
...que ainda se encontra em construção !

---
DR Teris ==> Diogo Rigo Tetris :)
Este é o motivo do meu sumisso !
Em breve voltarei a postar meus tutorias de SDL.