Deploy Games

RPG Maker XP Converter - Janelas e mais Janelas

2014-07-17T16:24:00.000-03:00

Salve Pessoas!

Por aqui o trabalho continua. Mas de todas as implementações que eu sabia que seriam necessárias, não imaginei que as janelas de jogo fossem dar tanto trabalho. UFA!

Mas aí alguém pode dizer: Ah, mas são só umas janelinhas, super simples. Bem, o principal é que as janelas tem que funcionar numa tela de toque, ou seja TODAS ELAS precisaram de ajustes. Acabei achando algumas formas de deixar isso bem bacana, e venho aqui mostrar hoje. Algumas ainda estão em andamento, mas acho que não vai demorar muito para que eu chegue na etapa mais esperada desse conversor: O sistema de batalha.

Janela de Menu (100%):

Janela de Itens (100%):

Janela de Habilidades (90%):

Janela de Equipamento (100%):

Janela de Status: (100%):

Janela de Loja (50%):

Veja que precisei mudar algumas coisas principalmente nas janelas de Habilidades, equipamento e Status, acrescentando o seletor de herói na parte de baixo.

Por enquanto é isso, vamo que vamo!

E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !

RPG Maker XP Converter - O trabalho continua! - Parte 2

2014-07-06T20:32:00.001-03:00

Salve amigos!

Eu de novo por aqui. Eu sei que tem gente por aí torcendo pra que eu desista de fazer esta ferramenta. Mas vou dizer com todas as palavras: Isto vai ser feito! É complicado sim, estou tendo dificuldade com muitas coisas, há muito o que portar ainda, mas como é um objetivo da equipe Deploy fazer um P#t@ jogo de RPG para Android, então é minha obrigação terminar essa ferramenta.

Boas notícias sobre os scripts: Já tenho uma forma de portar os scripts dos comandos "Chamar Script" para serem executados na engine. É claro que no começo haverão certas restrições, mas com certeza conseguirei deixar muita coisa configurável via script através do comando!

No mais, as coisas vão caminhando aos poucos, muita, mas muita coisa mesmo já funciona. Não vai demorar muito pra termos uma demo disponível por aí.

Segue um pouquinho a mais do que já está funcionando:

Engine em execução, Configuração de valores variáveis nas mensagens (cores, nome de herói, valor de variável, dinheiro):

Engine em execução, Configuração de Clima (Chuva, tempestade e Neve):

Engine em execução, Tom de Tela, Flash e Efeito de Tremor:

Por enquanto é o que posso mostrar.

E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !

RPG Maker XP Converter - O trabalho continua!

2014-06-23T22:30:00.000-03:00

Salve amigos!

Venho aqui falar sobre o projeto de forma genérica, por um motivo bem simples: Todo o trabalho envonvendo a construção da ferramenta não poderá ser descrito de forma técnica como eu estava planejando. Há muito trabalho. Só para se ter noção, os comandos de eventos são 96, ou seja, 96 implementações que precisam ser feitas, os comandos de mover evento são mais de 40, e tem toda a engine de batalha ainda.

Outro detalhe são os curiosos. Minha caixa de email está lotada de curiosos que, agora que viram que é possível fazer uma ferramenta desse porte, não param de perguntar como estou fazendo isto ou aquilo. Não é que eu queria esconder nada, mas tem muita coisa que eu só vou saber como fazer NA HORA DE FAZER, não tenho nada planejado para saber exatamente como as coisas irão funcionar.

Então, para não ficar parecendo que o projeto parou, eu vou postando screens e videos do andamento e, do jeito que as coisas estão, acho que rapidinho vou conseguir disponibilizar um beta pra vocês.

Seguem algumas Screens do Andamento:

Conversor, tela principal (WIP):

Conversor, tela de customizações (WIP):

Engine em execução, tela de Título:

Engine em execução, tela de Mapa:

Engine em execução, tela de Menu Padrão:

Engine em execução, Comando "Teleporte" já funcional (troca de mapa):

Engine em execução, Comando "Mostrar Mensagem" já funcional:

Engine em execução, Comando "Armazenar Número" já funcional:

Por enquanto é isso. Vejam que já andei um tanto bom, mas tem muita coisa ainda pela frente!

E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !

RPG Maker XP Converter - Conversão de Mapas para o Tiled - 1º Etapa

2014-06-16T09:23:00.001-03:00

Salve Amigos!

Estou empolgado em manter ativo este blog, e com este novo objetivo em andamento, acho que não terei problemas pra isso :D

No post anterior falei sobre a extração e conversão de dados do RPG Maker XP para um formato legível por outra ferramenta. Antes de qualquer outra coisa, seria preciso ter certeza que os Mapas de jogo do RMXP poderiam ser renderizados no LibGDX, já que há todo um aparato por trás (Tileset, SpritesetMap, Eventos) que fazem o mapa funcionar e, é óbvio, não se tem um jogo de RMXP sem mapas!

Para mim, a opção mais óbvia era usar o Tiled. É uma ferramenta Free, extremamente bem cotada no mercado indie de jogos e o principal: É completamente compatível com o LibGDX! Como eu já havia feito um código de extração de mapas para XML (posso mudar isso para JSON a qualquer momento :P) usei este padrão para fazer a etapa de conversão de mapas. Veja um pouco do que é gerado pelo RGSS como saída para os mapas:

MapInfos
Tilesets

Algumas coisas são bem parecidas, e facilitou muito, como por exemplo:

RXMP e Tiled usam 0 para uma região vazia;
RMXP e Tiled colocam os tiles como sequencia numérica, ou seja, não usam posição X/Y do tile e sim um ID que o identifica;
O RMXP guarda os IDs de 1 a 383 para os Autotiles, independente de haver um configurado ou não. No Tiled, usando o parametro firstgid é possível definir a partir de qual ID o tileset irá começar;

Até aqui tudo normal, consegui transformar o XML de saída do RMXP no XML de entrada do Tiled APENAS PARA O TILESET.

Certo, mas e os Autotiles?

Bom, sinseramente eu não imaginei que seria tão complicado. como é explicado neste post do CodeProject o mapeamento por usando autotiling é bem complexo, e eu teria que desdobrar pra descobrir como fazer isso usando o Tiled. Daí pesquisando um pouco, descobri que o próprio RMXP desdobra os AutoTiles em uma imagem já mapeada e numerada, como a do exemplo abaixo:

Pensando nisso, foi questão de tempo até fazer uma ferramenta que transforma um arquivo de autotile comum e um arquivo com o mapeamento acima. Qual o ganho disso? Este arquivo entra como tileset no arquivo do Tiled, mapeado com o firstgid baseado na sua posição (veja que usei como exemplo uma imagem que começa no ID 48) e então, VOILA! Um mapa completo, incluindo Autotiles!

A primeira etapa esta completa, com isso seria possível construir um modelo usando o LibGDX que carregasse este mapa!

MAS...

O principal problema, que ainda não pensei a melhor forma de fazer é com o AutoTiles animados. O RMXP usa um algoritmo muito complexo que muda apenas os tiles daquela posição se o AutoTile for animado, e isso é bem complexo de fazer usando o Tiled + LibGDX. Como o foco é fazer funcionar bem básico e ir melhorando com o tempo, já tenho uma idéia de como fazer, espero que funcione.
Ainda falta muita coisa, pra falar aqui, mas já posso dar a dica:

Como a proposta é que funcione para Celulares, o movimento do Herói será usando Click-To-Move, ou movimento com o Mouse como muitos conhecem. Já tenho Know-how nisso (Chama-se A* PathFinding) e pelos meus testes vai funcionar bala;
O Mapeamento de colisão vai ser básico por enquanto, ou seja, nada daquela mapeamento complexo que é feito no RMXP, apenas se colide ou não colide;
Deslocamento do Mapa quando o Player Andar: No LibGDX isto é feito com cameras, já sei como fazer e já testei :D

No mais é isso. Próximo Post espero falar mais sobre os mapas, e quem sabe já falar sobre os eventos!

E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !

RPG Maker XP Converter - Extração e conversão de dados

2014-06-15T20:01:00.002-03:00

Salve Pessoas!

Assim como foi dito neste post estou trabalhando numa ferramenta que vai aproveitar dados e recursos do RPG Maker XP, que roda apenas em Windows, para ser executado em várias plataformas como Android, IOS, Web, Linux e Mac.

Resolvi ir escrevendo sobre os passos e dificuldades, pois pretendo que esta seja uma ferramenta aberta para uso, nada de "código fonte para estudos e blablabla" de coisas que não funcionam ou dão um trampo maluco pra funcionar, aqui a coisa vai funcionar como o próprio LibGDX, é pegar, executar e ser feliz! :D

Aqueles que já leram materiais meus tanto sobre RPG Maker, Game Maker ou LibGDX sabem que eu tento deixar a coisa o mais explicada possível, pra que qualquer um também se aventure a fazer. Vamos começar então:

A etapa principal deste projeto maluco é bem mais a conversão dos dados que estão no banco de dados e nos mapas do RPG Maker para um formato que possa ser lido depois por outras ferramentas. Bem, o que temos de mais atual para isso é o JSON, que na minha opinião supera o XML por um motivo simples: Tamanho e estrutura. Ainda sim, usar um pouco de XML para a transformação não faz mal nenhum.

Mas o que foi preciso fazer?

A primeira coisa era entender o comportamento dos objetos do RPG Maker XP, ou seja, quais são, se possuem listas, outros objetos internos, etc. Para isso, nada melhor que uma mãozinha da própria Enterbrain. Para quem já mexeu com o RPG Maker XP em Inglês, sabe que o Help Oficial possui essa informação, no nó Game Library -> RPGXP Data Structure. Lá, todos os objetos internos do Banco de dados como Actors, Classes, Events, Maps, etc estão descritos de forma clara. Para facilitar sua vida, está AQUI o download do Help em Inglês do RPG Maker XP para estudo/verificação/morte de curiosidade ou algo assim. :D

Sabendo essas informações, o que precisei fazer foi um script em Ruby que transformasse os objetos internos do database em JSON / XML em arquivos .json ou .xml. para matar um pouco da curiosidade, olha como é simples gravar um arquivo texto usando RGSS:

def write_file(nomeArquivo, conteudo)
f = File.open(nomeArquivo, "w")
f.write(conteudo)
f.close
end

No mais, para cada tipos de objetos (Actors, Classes, etc) eu criei um método e na sequencia, extraio o dado criado para um arquivo. Veja por exemplo o método que cria o script de Actors:

def export_actors_JSON
saida = '"actors":['
v = "";
$data_actors.each{ |actor|
if actor != nil then
#character_hue
#battler_hue
saida += v + '{"id":' + actor.id.to_s +
',"name":"' + actor.name +
'","class_id":' + actor.class_id.to_s +
',"char_name":"' + actor.character_name +
'","batt_name":"' + actor.battler_name +
'","exp_basis":' + actor.exp_basis.to_s +
',"char_hue":' + actor.character_hue.to_s +
',"batt_hue":' + actor.battler_hue.to_s +
',"exp_inflat":' + actor.exp_inflation.to_s +
',"lvl_ini":' + actor.initial_level.to_s +
',"lvl_fim":' + actor.final_level.to_s +
',"wn_id":' + actor.weapon_id.to_s +
',"wn_fix":' + (actor.weapon_fix ? '1' : '0') +
',"a1_id":' + actor.armor1_id.to_s +
',"a1_fix":' + (actor.armor1_fix ? '1' : '0') +
',"a2_id":' + actor.armor2_id.to_s +
',"a2_fix":' + (actor.armor2_fix ? '1' : '0') +
',"a3_id":' + actor.armor3_id.to_s +
',"a3_fix":' + (actor.armor3_fix ? '1' : '0') +
',"a4_id":' + actor.armor4_id.to_s +
',"a4_fix":' + (actor.armor4_fix ? '1' : '0') +
',"parameters":['
temp = ""
v1 = ""
for i in 0...6
temp += v1 + '{"type":' + i.to_s +
',"values":['
v2 = ""
for j in 1..99
temp += v2 + '{"vl":' + actor.parameters[i, j].to_s +
',"lvl":' + j.to_s + '}'
v2 = ","
end
temp += ']}'
v1 = ","
end
saida += temp
saida += ']}'
v = ",";
end
}
return saida + "]"
end

Como a minha intenção é apenas demonstrar como estou fazendo, não vou postar todo o código. Mas uma coisa é certa: No final, para o Maker que for usar a ferramenta, ele só precisará inserir um script que será disponibilizado por mim em seu projeto e toda a mágica acontecerá.

Por enquanto é isso amigos. Na próxima prometo falar já sobre a conversão dos Mapas de RPG Maker XP para o Tiled, uma das ferramentas suportadas pelo LibGDX para criação de mapas baseados em Tiles. Até lá!
E como eu digo sempre : Be Brave, Be Bold, Create !!

Até a próxima !

RPG Maker XP Converter - O início

2014-06-13T14:25:00.001-03:00

Salve Pessoas!

A tempos não escrevo nada por aqui. Muito se passou, novos jogos foram publicados, o LibGDX se tornou melhor em vários sentidos, e nós da Deploy Games também.

A muito tempo atrás eu sonhei em poder levar tudo de bom que o RPG Maker tem para outros mundos, já que a Enterbrain ainda não decidiu fazer isso. No inicio, pensei que reinventar a roda seria a melhor forma, como pode ser visto aqui.

Hoje, com toda a experiência que tenho, vejo que é completamente inviável fazer isso, já que no início a proposta era que um desenvolvedor de jogos de RPG Maker pararia de usar o mesmo e usaria minha ferramenta, como é o caso do IRM Project.

Foi então que pensei: Porque não aproveitar tudo que a IDE do RPG Maker tem de melhor, e usar isso para portar os jogos?

Fazendo algumas análises, cheguei numa conclusão bem simples:

Todos os dados que são gerados pelo RPG Maker (Chars, Mapas, Classes, Animações, etc) poderiam ser exportados em um formato comum como XML ou JSON e lidos por outras ferramentas para uma pós-configuração ou diretamente por um interpretador;
Mesmo que não seja possível usar Ruby como linguagem de programação (esqueça JRuby, não passa nem perto do que é preciso) posso converter código Ruby para outra linguagem como javascript e então usar o que foi programado pelo criador do jogo;
A semelhança dos Mapas do RPG Maker com os Mapas criados pelo Tiled, ferramenta com suporte total no LibGDX, é muito grande;
Todas as plataformas que pretendo portar tem suporte a MIDI;
Tudo que o Executor de Jogo do RPG Maker faz, é possível fazer com o LibGDX;

Olhando para tudo isso, só me veio uma pergunta: Por que não? É algo que eu quero a tempos, a comunidade Maker é enorme, há vários makers que não se importam com RGSS para fazer seus jogos e por fim, seria uma forma de tornar viável a construção de RPGs para a Deploy.

Depois de postar uma Enquete no Mundo RPG Maker e ver que a maioria dos Makers apoia a idéia, comecei o trabalho e espero conseguir ir postando o andamento por aqui. Minha idéia é que pelo menos o formato de PC/Linux/Mac e de Android seja possível converter sem maiores problemas. De cara já há algumas restrições:

AutoTiles Animados: Eu tenho uma idéia de como fazer, mas ainda não darei foco nisso;
Programação RGSS: Não será possível customizar nada usando código ruby. Estou pensando em como fazer para que as principais telas de jogo (Menus, Mensagens, Título, Batalha, etc) possam ser customizadas mas nada usando ruby;
Touch X Teclado: As duas opções estarão disponíveis, ou seja, um item de menu poderá ser tocado e clicado, o movimento do heróí se dará tanto pelas setas direcionais quanto pelo toque na tela, entre outras coisas;
Audio no formato .ogg: Todas as plataformas suportam o ogg, exceto o IOS no qual o LibGDX ainda não conseguiu fazer funcionar. Como é uma restrição do Framework e não minha, nada pode ser feito;

Por enquanto é isso. Espero que vire.

E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !

LibGDX Tutoriais - Escrevendo texto / Criando BitmapFonts

2012-09-20T12:47:00.000-03:00

Salve pessoas!

Para quem ainda não conhece o início desses tutoriais pode acessá-los aqui(1) e aqui(2).

Continuo eu aqui tentando ensinar sobre LibGDX. Vou falar sobre como escrever texto. Eu sei, parece bobagem, coisa simples, mas acaba não sendo, por um motivo bem simples: o OpenGL não interpreta diretamente fontes instaladas no OS para escrever texto. Para isso, é necessário haver um intermediário, que é o caso do LibGDX, onde usaremos o BitmapFont.

Usando os projetos criados nos tutoriais anteriores, agora vamos escrever um pouco de texto. Abra o projeto LibgdxCore, o arquivo GameRoot, e acrescente essa declaração:

private BitmapFont currentFont;

No método create(), adicione a Instancia do objeto:

currentFont = new BitmapFont();

No método dispose(), adicione a descarga do objeto:

currentFont.dispose();

E por fim, vamos escrever algum texto. Como eu detesto Hello World, que tal desenharmos os Frames for segundo da aplicação? É claro, o LibGDX facilita a vida e disponibiliza esse dado num método estático, bastando chamá-lo, o Gdx.graphics.getFramesPerSecond(). No método render(), após a chamada begin() do spriteBatch, adicione a chamada para desenhar. Note que agora o SpriteBatch é passado como parametro para o Bitmapfont:

currentFont.draw(currentBatch, "FPS:" + Gdx.graphics.getFramesPerSecond(), 20, 20);

Até este ponto, sua classe deve estar assim:

E ao executar:

Você vai notar que vai ficar borrado e estranho. Bem, para processos de desenho que possuem variação, como esse caso, precisamos limpar o buffer. Para isso, adicione no método render(), como primeira linha, esta aqui:

Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT);

Mas o que essa linha faz? ela informa ao openGL que ele deve limpar o buffer da GPU, usando a cor padrão, que pode ser alterada a qualquer hora pelo método abaixo:

Gdx.gl.glClearColor(r, g, b, 1.0f);

R, G e B são os valores que você deve aplicar, de 0.0 a 1.0, para formar a cor desejada. Para exemplificar, coloque este código no método create():

Gdx.gl.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);

Ao executar, o resultado será esse:

Agora que brincamos um pouco com as cores de fundo, vamos voltar a falar das fontes. Quando um objeto Bitmapfont é criado sem parametros, internamente o LibGDX cria uma instancia de uma fonte default que ele possui, do tipo Arial de 15 pontos. Você pode criar suas próprias fontes para usar em seus jogos, usando uma ferramenta que a equipe LibGDX fornece, o Hiero. Para fazer o download do Hiero clique aqui. Não vou ficar aqui falando de como funciona, o que tem de mais e tal, basta ler no blog da BadLogic.

Você escolhe a fonte, o tamanho, coloca efeitos, mais um monte de coisas. Crie uma fonte do tipo Verdana de 32, salve o arquivo como verdana-32.fnt. Ao gravar, ele vai criar dois arquivos, o .fnt e um .png. Copie os dois para o diretório assets do projeto de Android:

Agora, na instancia do objeto Bitmapfont, acrescentaremos os parametros necessários para a leitura do arquivo. Para isso, você deve usar o gerador de FileHandle do LibGDX, como abaixo:

currentFont = new BitmapFont(Gdx.files.internal("verdana-32.fnt"), false);

Também é necessário fazer um ajuste no desenho da fonte. Ah, a fonte o LibGDX usa como referencia o topo e não o fundo, ou seja, sempre na posição Y é necessário colocar no mínimo o tamanho da fonte para que ela apareça na tela:

currentFont.draw(currentBatch, "FPS:" + Gdx.graphics.getFramesPerSecond(), 20, 40);

E por fim:

E é isso. Para facilitar a vida estou disponibilizando o arquivo GameRoot.java, para que você compare com o seu e ajuste o que for necessário.

Tem muita, mas muita coisa que o LibGDX facilita, e eu espero conseguir falar de pelo menos um décimo. No próximo tutorial pretendo falar de interação do usuário, toques, sensores, e mais algumas coisas.

E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !

LibGDX Tutoriais - Configurando o projeto Android / Desenhando a primeira Textura

2012-09-19T12:48:00.001-03:00

Salve Pessoas!

Como eu disse no tutorial anterior, vou tentar ensinar o máximo sobre o LibGDX, um dos melhores frameworks de desenvolvimento de jogos para Android.

Continuando o tutorial anterior, vamos criar e configurar o projeto de Android para testarmos no emulador ou telefone, e desenharemos nossa primeira textura. O LibGDX facilita muito as coisas, e você vai ver que com poucas linhas de código vamos colocar uma imagem para ser exibida.

Primeiro, vamos criar e configurar o projeto de Android. Seguindo o que disse tutorial anterior, você já tem que ter pronto aí a IDE Eclipse já baixada e instalada, o ADT, que é o plugin do Eclipse para se programar para Android e a SDK do Android baixada e configurada.

Crie um novo projeto de Android no Eclipse, indo em File -> New -> Android Application Project:

Configure-o, com o nome da aplicação de ActivityPrincipal, o Project Name de LibgdxAndroid (Seguindo o padrão de nomenclatura que falei no tutorial anterior), o Package Name como com.deploy.libgdx, e o Build SDK, coloque a versão que quiser. Eu costumo usar a 2.2 por causa do meu Galaxy 5.

Projeto criado, agora as configurações. Volte ao diretório do LibGDX que você baixou no primeiro tutorial, e copie os seguintes para o diretório libs:

Diretório armeabi e seu conteúdo;
Diretório armeabi-v7a e seu conteúdo;
gdx-backend-android.jar

Vá no projeto Android, (Botão Direito -> Properties), selecione Java Build Path, e vá na aba Libraries. Adicione o Jar que copiamos anteriormente e o jar gdx.jar, como foi feito no tutorial anterior:

Vá na aba Projects, e adicione o projeto LibgdxCore, como foi feito no tutorial anterior:

Assim como fizemos nos outros projetos, crie o package inicial com o nome de com.deploy.libgdx :

A próxima configuração é bem interessante. Como o foco do nosso desenvolvimento é o Android, todo e qualquer recurso, gráfico ou não, deve ser colocado no diretório assets por questões de padronização. Para que possamos utilizar estes mesmos recursos no projeto Desktop, basta fazermos referência ao diretório assets do projeto Android, e pronto! São esses detalhes que facilitam e muito o desenvolvimento usando a LibGDX. Vá nas propriedades do projeto LibgdxDesktop (Botão Direito -> Properties), selecione Java Build Path, e vá na aba Source:

Clique no botão Link Source, e configure da seguinte forma:

Linked folder Location: WORKSPACE_LOC\LibgdxAndroid\assets\

Folder Name: assets

WORKSPACE_LOC é uma referência ao local atual do Workspace do Eclipse, e o restante do caminho aponta para o projeto de Android que criamos. Caso tenha problemas com isso (eu sempre tenho pois meus projetos não ficam no workspace) recupere o caminho real pelo Windows Explorer e coloque lá. Feito isso, nosso projeto Desktop agora possui mais um diretório disponível, o assets. Todo e qualquer recurso que for colocado agora lá no diretório assets do Android poderá ser utilizado aqui.

Por enquanto as configurações são essas, eu acho. Está na hora de codificar!

Primeiro, vamos colocar um recurso gráfico para podermos desenhá-lo. Eu vou usar esse, use o que quiser:

Coloque o recurso no diretório assets do projeto Android, como falamos anteriormente. Veja que ele ficará disponível no diretório linkado do projeto Desktop:

Agora vamos ao código. Abra a classe GameRoot, que se encontra no projeto Core. Como eu disse anteriormente, implementando ApplicationListener ela é uma classe básica, muito boa para quem está começando a entender o LibGDX. Uma coisa boa do LibGDX é a facilidade de se fazer a maioria das coisas. Para se desenhar uma textura, vulgo imagem, só precisamos de algumas linhas de código. O grande responsável por isso é um objeto de nome SpriteBatch, que faz o trabalho pesado de aplicar as texturas diretamente no GPU usando o openGL. O objeto de Textura também deve ser criado, para ser usado pelo SpriteBatch.

Na classe, declare nossos objetos Spritebatch e Texture:

private SpriteBatch currentBatch;

private Texture currentTexture;

Algumas informações aqui são necessárias. Toda e qualquer criação de instâncias deve ser feita no método create, todos os objetos devem ser descartados no método dispose e qualquer renderização deve ser feita no método render. Então vamos lá. Instancie o SpriteBatch e a Texture, como abaixo, dentro do método create:

currentBatch = new SpriteBatch();

currentTexture = new Texture("pikachu.png");

Veja que passei diretamente o nome da imagem para a criação da textura. O LibGDX sabe que essa textura vai estar no diretório assets, então basta fazer assim. Como eu disse, todo objeto criado deve ser descartado quando não for mais utilizado. Dentro do método dispose, coloque o descarte dos objetos como abaixo:

currentBatch.dispose();

currentTexture.dispose();

Até esse momento, sua classe deve estar mais ou menos assim:

Estamos quase lá. Agora vamos renderizar esse pikachu logo! no método render, temos alguns passos importantes: o SpriteBatch deve ser iniciado com a chamada do método begin(), desenhar o que for para desenhar com a chamada do método draw() e por fim fechar a renderização com o método end(). Modifique o método render como abaixo:

currentBatch.begin();

currentBatch.draw(currentTexture, 0, 0);

currentBatch.end();

Os parametros 0,0 são respectivamente a posição X e Y onde a textura será desenhada dentro da janela. Um detalhe importante sobre o LibGDX é que ele usa a direção do Y de baixo para cima, como no plano cartesiano padrão, diferente do que já vimos em outras formas de se desenhar:

Então, o Y sendo zero será sempre no lado de baixo da janela e quanto maior, mais para cima. Mais uma vez olhando a classe ela deve estar assim:

Agora, só executar a classe LibgdxGame no projeto desktop, e nosso Pikachu estará lá:

Você pode brincar com a posição, e desenhar mais vezes a mesma textura! Lembre-se que a ordem de desenho no código influencia diretamente na saída, ou seja, o ultimo a ser desenhado sempre ficará por cima do anterior e por aí vai. Outra coisa que é possível fazer com o SpriteBatch é aplicar coloração na textura, mudando como a mesma será renderizada. O código abaixo é uma experiência desenhando mais uma vez a textura em outra posição e mudando sua cor:

currentBatch.begin();

currentBatch.setColor(1, 1, 1, 1);

currentBatch.draw(currentTexture, 0, 0);

currentBatch.setColor(1, 0, 1, 1);

currentBatch.draw(currentTexture, 200, 20);

currentBatch.end();

E o resultado:

Parece complicado, mas tudo isso que foi feito até agora, dependendo do framework ou biblioteca utilizados, gastaria toneladas de linhas de código e horas de programação. Para encerrar, vamos construir a classe base do Android? Vamos lá.

Vá no projeto Android, no pacote que foi criado e crie uma classe de nome LibgdxActivity que estenda a classe AndroidApplication:

Sobreponha o método onCreate. Assim como fizemos com o projeto desktop, precisamos criar um objeto de configuração, neste caso o AndroidApplicationConfiguration. Altere o método como abaixo:

AndroidApplicationConfiguration config = new AndroidApplicationConfiguration();

config.useAccelerometer = false;

config.useCompass = false;

config.useWakelock = false;

config.useGL20 = true;

config.numSamples = 2;

E por fim, instanciar a classe GameRoot, usando desta vez o método initialize da classe:

this.initialize(new GameRoot(), config);

Até este ponto, sua classe deve estar assim:

Todos os parametros de configurações eu poderei explicar aos poucos, não se preocupe com isso agora. Agora vamos para as configurações finais, que são muito importantes para o funcionamento da aplicação no Android. Se você criou uma Activity durante a criação do projeto, o que vou mostrar agora deve sobrescrever tudo que estiver no arquivo.

No projeto Android, abra o arquivo AndroidManifest.xml. Deixe seu conteúdo como abaixo:

agora, adicione as tags abaixo logo abaixo da tag de fechamento de uses-sdk:

<supports-screens android:largeScreens="true" android:anyDensity="false" />

Agora, dentro da tag application, coloque este bloco:

<activity android:name="com.deploy.libgdx.LibgdxActivity"

android:screenOrientation="landscape"

android:label="@string/app_name">

<intent-filter>

</intent-filter>

</activity>

Até este ponto, seu arquivo deve estar assim:

E está pronto, pode publicar e ver a mágica.

UFA! escrevi muito, e não fizemos tanto. Começar costuma dar mais trabalho, mas com o tempo fica simples e automático. Muita coisa ficou obscura, como as configurações, mas espero poder esclarecer a cada novo tutorial.

No próximo eu pretendo falar sobre escrever na tela, e vamos conhecer o Hiero, o gerador de fontes do LibGDX.

E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !

LibGDX Tutoriais - Inicio básico no LibGDX

2012-09-18T23:45:00.004-03:00

Salve Pessoas!

Me foi feito um pedido amigável no grupo Programadores Android do Facebook para que eu falasse ou ensinasse sobre o LibGDX, essa biblioteca fantástica para desenvolvimento de jogos. Eu não sou um exímio conhecedor dela, e uso muita coisa criada por mim, mas vou tentar abrir o caminho para esses prezados que querem começar nela.

Não pretendo ensinar como configurar ou Utilizar o Eclipse, então se você não sabe essa parte, eu aconselho a procurar por tutoriais na net que te ensinem isso.

A grande vantagem do LibGDX é que não precisamos construir todo o jogo apenas para Android ou diretamente nele. A biblioteca permite que se construa e teste no PC e, com poucas linhas de código, se publique o mesmo jogo para Android e HTML5. O tempo de desenvolvimento é completamente aproveitado dessa forma, pois tanto testar quanto depurar usando o emulador do Android ou um telefone é demorado e doloroso. Chega de conversa e vamos lá.

Primeiramente você precisará estar com a IDE Eclipse já baixada e instalada, o ADT, que é o plugin do Eclipse para se programar para Android e a SDK do Android baixada e configurada.

Vá ao site do LibGDX e baixe a ultima versão, que na data desta matéria era a 0.9.6: Download.

Deste pacote vamos precisar configurar algumas coisas. Como é um básico, eu vou explicar como criar um projeto de PC e nos próximos falaremos do projeto de Android. No Eclipse, crie um novo projeto Java(A screen pode variar de versão do Eclipse e de configurações do usuário, mas a nomenclatura é a mesma):

Coloque o nome de LibgdxCore. Seguiremos uma nomenclatura que gosto de usar para meus projetos.

Seguindo os dois passos acima, crie outro projeto de nome LibgdxDesktop. eles aparecerão no workspace assim:

Nos dois projetos, siga os passos abaixo:

Crie o pacote com.deploy.ligbdx;
crie um diretório de nome libs;

Agora começaremos a configurar os projetos. Descompacte o pacote do Libgdx que você baixou. copie os seguintes arquivos para o diretório libs dos projetos, como abaixo:

LibgdxCore:

gdx.jar

LibgdxDesktop:

gdx-backend-lwjgl-natives.jar
gdx-backend-lwjgl.jar
gdx-natives.jar

Botão direito no projeto LibgdxCore e selecione "Properties". Selecione o item Java Build Path. Na aba Libraries, Clique no botão "Add JARs", selecione o gdx.jar que está no libs do projeto.

Mesmo caminho no projeto LibgdxDesktop , adicionando os três jars da libs dele. Aqui um detalhe, marque o projeto LibgdxCore e selecione a gdx.jar dele, como abaixo:

Ainda com a janela aberta, selecione a aba "Projects" e adicione o projeto LibgdxCore , como abaixo:

As configurações básicas são essas. Mas porque essa estrutura? vou explicar... Toda a programação do jogo ficará no projeto LibgdxCore , e os outros projetos, como o LibgdxDesktop serão apenas executores dele, distinguindo a plataforma. Ou seja, quando fizermos um projeto para Android, referenciaremos o projeto Core e pronto!

Para não dizer que foi um tutorial apenas de configuração, vamos pelo menos fazer uma janela aparecer(nada de Hello world escrito, eu odeio isso). No projeto LibgdxCore , crie uma classe de nome GameRoot . Ela deve implementar a interface ApplicationListener do libgdx, como abaixo:

Não precisamos escrever nada nela agora, ela apenas precisa implementar a interface padrão do Libgdx. Eu não faço usando AppListener, mas ela dá uma base melhor para quem está começando. No projeto LibgdxDesktop crie uma classe com nome de LibgdxGame, sem implementações ou especializações:

Estamos quase lá. Na classe criada, adicione os imports abaixo:

import com.badlogic.gdx.backends.lwjgl.LwjglApplication;

import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;

Depois, adicione o Main, para ser uma classe executável:

public static void main (String[] args) {}

Vamos criar um objeto de configuração. Ele dará forma à janela, com alguns detalhes como versão do openGL, título e tamanho.

LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();

config.title = "Jogo de Exemplo Libgdx";

config.fullscreen = false;

config.resizable = false;

config.width = 540;

config.height = 430;

config.samples = 2;

config.useGL20 = true;

Agora por fim, a instancia da classe GameRoot, junto com a inicialização de um objeto do tipo LwjglApplication, que é a versão de PC de execução do Libgdx:

new LwjglApplication(new GameRoot(), config);

Se os passos foram seguidos certinho, sua classe LibgdxGame deve estar assim:

Veja que estamos instanciando a classe GameRoot , que se encontra no projeto Core. Só para conferir, sua árvore no Eclipse deve estar assim:

E pronto. Selecione a classe LibgdxGame e execute (seta verde ou CTRL+F11). A janela preta com as configurações irá aparecer:

Super simples. Eu darei continuidade a este tutorial, a partir desses projetos criados. Vou tentar ensinar o máximo que eu puder e souber. Na próxima, vamos direto para a criação e configuração do projeto de Android, e vamos desenhar uma textura. Espero que estes tutoriais facilitem sua vida com o uso do LibGDX, essa biblioteca fantástica.

E como eu digo sempre : Be Brave, Be Bold, Create !!

Até a próxima !

Deploy Games na Indie Game Magazine!

2012-09-12T12:17:00.000-03:00

Salve amigos!

É eu sei, estou meio atrasado, mas o tempo anda curto e as atividades não acabam! Para ficar registrado, fomos matéria no Indie Game Magazine, um dos maiores fóruns/blogs/outras coisas do mundo independente: Deploy Games na Indie Game Magazine.

Que o mundo nos conheça, e descubra que no brasil tem muito mais que bunda e carnaval!

E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !

Game Design - Construindo Sistemas de Jogo de Causa e Efeito - 1º Parte

2012-08-16T15:57:00.002-03:00

Olá amigos!

Esta é a tradução da postagem original feita no blog The Lost Garden:

Para jogar um jogo bem, um jogador deve dominar um modelo mental de causa e efeito. Você aprende que pressionar um botão específico move para a frente. Você descobre que uma seqüência de movimentos do controlador permite desviar de um foguete disparado. É possível observar uma pequena pausa antes de um ataque inimigo e acreditam que você pode disparar um tiro na cabeça naquele exato momento. Em cada fase de aprendizado, você cria uma hipótese, testa através de suas ações e aprimora seus modelos mentais da caixa preta no coração do jogo. Este refinamento crescente e domínio de novos modelos mentais e ferramentas é essencial para o que faz um jogo entre muitos ser agradável. Tal maestria, obviamente, depende do jogador. No entanto, também é dependente do designer e dos sistemas que o constroem. Você pode acidentalmente criar uma caixa preta quebrada. Nem todos os sistemas são facilmente passíveis de formação intuitiva de modelos de causa e efeito. Como um Game designer, é seu trabalho criar sistemas que são intrigantes para dominar sem se tornar completamente desconcertante. Se o sistema é muito previsível, torna-se chato. Se não é previsível em tudo assumimos que o sistema é ou aleatório ou espiritual na natureza. Ambos são condições de falha, se você está tentando incentivar maestria.

Sistemas fortes e fracos

Eu sou um mecânico que conserta caixas-pretas quebradas. Um conceito importante que me serviu bem é pensar a relação entre os sistemas e os comentários que o jogo usa para descrever as interações com os sistemas como 'forte' ou 'fraco'. Um sistema forte define claramente a causa e o efeito. Já o sistema fraco é mais difícil distinguir essas relações. Não há uma 'força' correta de um loop. No entanto, existem métodos claros de aumento de qualquer força ou fraqueza.

Técnicas para ajustar dificuldade

Para seu prazer da leitura, eu coloquei uma lista de ferramentas que eu uso para ajustar a dificuldade de um sistema. Nem todas são aplicáveis ??a um determinado sistema, mas todos eles devem ser parte do conjunto de ferramentas de um designer especialista. Algumas das ferramentas são dignas de livros dedicados por isso peço desculpas antes de qualquer superficialidade óbvia. Por exemplo, a probabilidade tem tantos sabores sutis que alguns designers dedicam suas vidas a estudar como ela afeta a capacidade de um jogador para prever os resultados. Na melhor das hipóteses esta é apenas uma visão. Para reforçar um sistema, deve-se tornar a causa e o efeito mais óbvios. Para afrouxar um sistema, deve-se fazer a conexão entre causa e efeito menos óbvia.

Força da Opinião

Peggle

Forte: Múltiplos canais de feedback alinhados, tais como cor, animação, som e toque que se reforçam mutuamente. O exemplo clássico é Peggle que utiliza partículas, arco-íris, Ode a Alegria dilatação e tempo para que você saiba que sim, o jogo é longo e gloriosos pontos estão sendo marcados.

Estou usando todos os canais possíveis que eu preciso para fazer um impacto?
É o feedback seqüenciado corretamente para que o jogador pode lê-lo claramente?
O feedback aproveita um esquema mental existente, de modo que se torna mais impactante?

Fraco: Um canal de feedback que é fracamente evidente. Em jogos FPS multiplayer muitas vezes o único sentido que você tem que outro jogador está perto vem do som fraco de seus passos. Jogadores experientes ganham imensa satisfação de ser capazes de prever a localização de seu oponente, combinando conhecimento dos níveis com pequenas sugestões de onde elas possam vir.

Será que o feedback tem nuances que não são compreensíveis em uma inspeção casual?
O feedback pode ser combinado com informações não-óbvias para dar uma imagem clara de um usuário experiente?

Barulheira

Space Giraffe

Forte: Um sinal claro de efeito que está relacionado com a causa.

Qual é a peça mais importante de informação que o jogador precisa agora?
Já tirei elementos estranhos que distraem a atenção do jogador?
É o meu feedback no centro da atenção do jogador?

Fraco: A multiplicidade de sinais conflitantes e atenção não convergida que não estão relacionadas com a causa. Uma das habilidades críticas em Jeff Minter’s Space Giraffe é aprender a ver através do ruído visual dos fundos psicodélicos.

Existem elementos ambientais posso acrescentar que acrescentem distrair, mas sem causar irritação?
Pode o ruído criar um quebra-cabeça perceptual para o jogador?

Tipo sensorial

Assassin's Creed 3: Nice use of contrast and perspective

Forte: Onde o feedback visual ou tátil é muitas vezes mais claramente percebido. Considere os muitos bilhões de dólares gastos na melhoria do feedback visual a cada ano para que possamos demonstrar aos jogadores o impacto visceral de uma bala na carne simulada com fidelidade cada vez maior. O Feedback visual forte é altamente funcional, ele comunica o efeito para o jogador de um modo elegante e eficiente. Não se trata apenas de fazer fotos bonitas. Em uma recente atualização de "Triple Town", mudamos o esquema de cores para que o fundo realçasse os objetos em primeiro plano. O resultado era atraente, mas os jogadores estavam putos porque os ícones não eram quase tão visíveis como antes.

Estou usando o design visual de cor, movimento, contraste, linha, espaço em branco, sombra, volume, perspectiva, de modo que os meus visuais sejam claros?
Eu tive que fazer algo bonito quando eu precisava era de algo funcional?
O feedback é funcional e o que é evocativo ou estética?
Devo investir mais em feedback visual?

Fraco: Onde o feedback auditivo e do olfato são claramente menos percebidos. Não tem sido feito sempre, mas devido à fraqueza de tais sistemas parece que não há potenciais sistemas de mestria. É talvez irónico que a maioria dos jogos de música, um tema tipicamente associado com o domínio auditivo, pode ser jogado com o som desligado.

Usar Modelos Mentais existentes

Plants vs Zombies

Forte: Mapear intimamente o tema, feedback e sistema para os atuais modelos mentais. Devido a décadas de exposição à cultura pop, os jogadores sabem como zumbis se movem e que eles devem ser evitados. Uma simples forma de comunicação visual, onde um grupo de monstros se move lentamente, leva a identificá-los como zumbis.

Qual é o modelo de desenho que os jogadores têm em suas cabeças (vs do modelo realista de como o mundo real funciona)?
Como meu tema pode apoiar a mecânica do jogo?
Como meu tema pode inspirar variações úteis sobre a mecânica do meu núcleo?
Estou engajar no pecado original de diluir minha mecânica para caber o tema?

Fraco: Afaste-se dos modelos existentes no mercado e introduza os jogadores a novos sistemas que eles nunca experimentaram. Considere as metáforas envolvidas no Tetris. Elementos em queda são coisas que nosso cérebro pode processar como razoavelmente familiar. Objetos que se encaixam em linhas que desaparecem para ganhar pontos, enquanto toca música russa? Isso não se enquadra em nenhuma metáfora conhecida, mas que resulta em um grande jogo.

Em que ponto já não é preciso de um esquema de gateway e o jogo pode ficar em sua própria consistência interna?
Existem oportunidades para o surrealismo ou desorientação intencional?
Podemos nos afastar dos clichês para novas experiências de síntese?

Diferenciação

Advance Wars: Limited units and small numbers.

Forte: Aplicar estados discretos ou números de baixo valor. O binário é o mais forte. Por exemplo, recentemente testamos com unidades movendo a velocidades diferentes, Tornando-os passar uma 1, 2 e 4 casas/seg, e de repente tornou-se muito evidente para o jogador de como cada tipo de unidade foi diferenciada. Esta é uma das minhas técnicas favoritas para a obtenção de sistemas indisciplinados sob controle.

Qual é o número mínimo de valores que eu preciso para criar escolhas significativas?
Pode o jogador distinguir claramente entre o efeito de cada incremento em valor?
O que aconteceria se eu tivesse que reduzir essa variável para 3 valores discretos?

Fraco: Aplicar valores analógicos ou números de valor muito alto. Por exemplo, em Angry Birds, você pode dar a seu pássaro uma grande variedade de ângulos e velocidades. Isto faz com que os resultados sejam surpreendentemente incertos. Pense em como previsível (e chato) o jogo seria se você pudesse escolher apenas dois tipos de ângulos e velocidades.

Eu tenho bastante intervalo para que os jogadores possam jogar de forma criativa?
Os meus valores adicionam uma incerteza interessante de escolhas?

Estimulação

Diablo Loot Pacing

Forte: Adicionar pequenos lapsos de tempo entre causa e efeito. Ao passar o mouse sobre caixas como você encontra em Diablo, um erro comum é adicionar um atraso entre quando o mouse está sobre o item de estoque e quando o diálogo aparece. Se o atraso for muito curto, o diálogo em foco aparece quando o jogador não espera. Se o atraso for muito longo, o diálogo parece com lag e não-responsivo. (Na minha experiência, 200ms parece ideal. É isso mesmo dentro da percepção de onde você decidiu fazer algo, mas para a sua mente consciente não foi reconhecido).

Onde é que o jogo deve aplicar lag?
O que acontece se eu acelerar o tempo de espera?
O que acontece se desacelerar o sincronismo?
Quais são os sistemas permitem que haja variação de tempo de uma forma indireta?
Estou ajustando a estimulação através de arcos de conteúdo manuais quando eu poderia usar algoritmos com laços?

Fraco: Adicionar grandes lapsos de tempo entre causa e efeito. É quando o tempo e que o jogador espera é demasiado e a causa se perde do efeito. Imagine um RPG onde você tem um interruptor e um temporizador. Se você acertar o interruptor, a porta abre-se 60 segundos depois. Surpreendentemente poucas pessoas vão descobrir que a porta está ligada ao interruptor. Por outro lado, o investimento da indústria no início de Alpha Centauri resultou em ataques alienígenas no final do jogo .Isto criou um rico sistema de trade off interessante para os jogadores de manipular mais de um longo período de tempo.

Quais são os longos laços de tempo no jogo?
Há muito tempo queimando efeitos que causam jogadores a reconsiderar os seus modelos para loops de jogo a longo prazo?

Esta matéria continua...

Regras do Jogo (Rules of Play) lançado no Brasil pela editora Blucher

2012-08-16T11:24:00.000-03:00

Salve pessoas!

Como bom Game Developer a leitura de bons livros deve fazer parte do dia a dia. Segue uma excelente matéria do blog GameDeveloper.com.br que tenho o prazer de divulgar:

O livro Regras do Jogo: Fundamentos do Design de Jogos (Rules of Play: Game Design Fundamentals) é uma obra famosa sobre Design de Jogos, uma referência em diversos cursos de desenvolvimento de jogos no mundo inteiro, e aeditora Blucher lançou no Brasil uma versão traduzida deste livro.

Escrito por Katie Salen e Eric Zimmerman (ambos designers de jogos e professores em universidades americanas), este livro trata a criação de um jogo de forma lúdica, desde os conceitos básicos sobre o que é jogar, segundo o filósofo Johan Huizinga (que escreveu Homo Ludens), até conceitos mais atuais, todos aplicados a Design de Jogos.

Sua abordagem é muito ampla, cobrindo tudo que um Game Designer precisa saber a respeito de criar conceitos e mecânicas de jogos. Este livro também faz o leitor pensar e rever conceitos sobre a importância da atividade lúdica para o ser humano. Eles livro é um guia para o Designer de Jogos entender vários aspectos que um jogo possui, como sua influência cultural, e também ensina a explorar mais a capacidade lúdica que os jogos possuem.

A editora Blucher dividiu o livro em 4 volumes, cada um com uma parte diferente do livro. Abaixo está o conteúdo de cada volume:

Volume 1 – Principais Conceitos – tem como temas a interação lúdica significativa, o design, os sistemas, a interatividade, a definição de jogos e de jogos digitais, o circulo mágico e os esquemas primários.

Volume 2 – Regras – tem como temas a definição das regras, as regras em três níveis e dos jogos digitais, os jogos como sistemas emergentes, de incerteza, de teoria da informação, de informação, cibernéticos, da teoria dos jogos e por fim como sistemas de conflitos, além de abordar a quebra das regras.

Volume 3 – Interação Lúdica – tem como temas a definição de interação, os jogos como experiência lúdica e do prazer, os jogos como interação lúdica de significados, narrativa e da simulação, e ainda os jogos como experiência social.

Volume 4 – Cultura – tem como temas a definição de cultura e os jogos como retórica cultural, cultura aberta, resistência cultural e ambiente cultural.

A qualidade da tradução do livro está muito boa, e este é um livro obrigatório para estudantes e game designers! A leitura é bem tranquila, e o conteúdo é realmente bom para qualquer pessoa que gosta de desenvolvimento de jogos. Mesmo pesquisadores que desenvolvem trabalhos acadêmicos relacionados a video games podem aproveitar este livro, graças a visão única dos autores e de todo material que eles pesquisaram para criar este livro.

Postagem original: http://gamedeveloper.com.br/blog/2012/08/15/regras-do-jogo-editora-blucher/#more-1471
E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !

Max the Gold Hunter no Game Music Brasil - Melhor Game Indie!

2012-08-14T17:04:00.001-03:00

Salve pessoas!

Depois de muito trabalho, empenho, ajuda dos amigos e noites sem dormir, finalmente o projeto Max the Gold Hunter está se tornando realidade, e pra deixar as coisas mais legais ainda, ele vai participar do Concurso Game Music Brasil - Melhor Game Indie!

As votações vão até 16/09/2012, então quem puder, vote lá!
Para aqueles que não tem acesso a Youtube, segue o vídeo no Vimeo:

Max the Gold Hunter - Puzzle Game for Android from DeployGamesVideos on Vimeo.

E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !

libGDX - Vale a pena?

2012-05-30T16:56:00.000-03:00

Salve pessoas!
A muito estou afastado, e o maior motivo é o trabalho. Quem dera fazer jogos desse dinheiro no Brasil, e Uberlândia /MG tivesse gente interessada nisso. Deixando as chatisses de lado, hoje quero falar sobre a Engine na qual eu tenho focado todos os meus estudos, o libGDX: http://code.google.com/p/libgdx/

libGDX é um Framework de desenvolvimento de jogos em Java. Sendo em Java é multiplataforma, e com alguns diferenciais:

Trabalha diretamente em cima do openGL, ou seja, é possível fazer maravilhas em 2D e em 3D;
É possível escrever um "core" sem se preocupar com a saída de publicação (Desktop, HTML5, Android) o que facilita e muito para quem não quer morrer de tédio em cima do emulador do Android;
É livre, e pode ser extendida com coisas suas!
Editor de Fontes: o openGL não trabalha com fontes locais (arquivos .ttf por exemplo) então para isso a equipe do libGDX criou o HIERO: http://code.google.com/p/libgdx/downloads/detail?name=hiero.jar. Com ele, você cria e modela a fonte como desejar, e depois utiliza dentro do libGDX, bem fácil;

Agora na ultima versão (atualmente 0.9.3) vem junto com o pacote uma ferramenta para criação de projetos de Eclipse, já preparados para rodar o libGDX. Técnicamente há uma grande vantagem, pois as partes que precisam de muito processamento (Ex: Física com Box2D) são compiladas em JNI, linguagem nativa que provê uma melhoria significativa na performance.
Depois de tudo isso, vem a pergunta: E aí, o libGDX vale a pena?
Se olharmos pelo lado técnico, sim. A quantidade de funcionalidades e padrões disponíveis é impressionante, com muita, mas muita coisa pronta para faciltiar o desenvolvimento, inclusive para 3D.
Se olharmos pelo lado do Game Designer, não serve para nada, pois apenas as ferramentas de apoio são visuais, o resto é tudo código.

Eu tenho me empenhado em aprender cada vez mais sobre este framework, já que meu foco é dev e não design. Se o seu também é, fica a dica, vale muito a pena.

É isso. Espero voltar em breve, com algumas boas notícias.

E como eu digo sempre : Be Brave, Be Bold, Create !!
Até a próxima !

Out There Somewhere - Nostalgia pura !

2012-02-21T14:18:00.003-02:00

Como vai pessoal !

Estou aqui de novo, desta vez para falar do fruto de muito trabalho da galera do Studio MiniBoss. : Out There Somewhere.

Como eu sou alguém que ADORA jogos antigos (Diga-se jogos de NES, Master System, SNES, etc.) eu me interessei por este jogo quando eles começaram a divulgar vídeos e imagens.

Durante o Pre-Order eu comprei, esperando para ver o que viria. Hoje, no dia do seu lançamento, finalmente eu constatei: FANTÁSTICO !

Gráficos excelentes, som impecável, mecânica extremamente funcional e bem produzida. Destaque para a Teleport Gun, uma idéia sensacional para aumentar a dificuldade do jogo. E sim, é difícil ! vou ter que comprar pilhas pro meu controle de Xbox de PC para conseguir jogar ele! hauahuahauahua !

O jogo me lembrou o quanto eu me diverti com os jogos de NES principalmente (Naquela época Master System, Mega Drive, Etc era coisa de rico, pobre tinha Top Game) e o quanto os jogos eram realmente divertidos.

Como eu comprei durante o Pre-Order, o pacote veio completo: OST, Manuais, Artworks e uma versão do jogo em português.

Indico e recomendo, Out There Somewhere é uma excelente demonstração de como os Indies são poderosos, e de como a união faz a força. Parabéns novamente aos amigos Santo e Amora pelo excelente trabalho feito neste projeto.

E como eu digo sempre : Be Brave, Be Bold, Create !!

Até a próxima !

Be Fast - Projeto de Game Educativo

2012-02-03T22:46:00.000-02:00

Como vão pessoas !

Hoje venho aqui falar sobre uma idéia ULTRA legal na qual começei a trabalhar ontem (02/02/12). Fui me encontrar com a minha Irmã mais nova, power vocalista, sempre amiga e madrinha de casamento Carol Scarabucci.

Nosso assunto era óbvio, ou falaríamos de banda ou de jogos ! E não é que acabamos falando de jogos?!

A idéia é criar alguns títulos específicos para educação, no caso dela de crianças especiais. Já saí de lá com mil coisas na cabeça, mas o principal delas: Um novo projeto ! Depois de falarmos sobre alguns possíveis títulos, concordamos com um : Be Fast -> Seja Rápido. O Título é sugestivo, um jogo ao melhor estilo Time Attack voltado para educação.

Bom, por enquanto é o que eu posso falar, já que mal começamos. Uma coisa MARAVILHOSA disso é que a Carol será a ilustradora, e ela desenha extremamente bem !!! Finalmente eu posso me sentir tranquilo com relação a um projeto, não existe nada mais frustante que começar projetos a 4 ou mais mãos e sempre terminar em duas, as minhas. :(.

É isso, mais informações eu falo por aqui depois.

E como eu digo sempre : Be Brave, Be Bold, Create !!

Até a próxima !

Deploy RPG Maker - Comandos de Evento

2012-01-26T09:24:00.000-02:00

Olá de novo pessoas !

Desde o dia que postei o vídeo sobre o editor de mapas, tenho trabalhado bastante em vários aspectos da ferramenta, e posso dizer que já estou com uns 25% do projeto concluído.

Mas espere aí, 25%? ENTÃO VOCÊ NÃO FEZ NADA AINDA !

Fiz, e continuo fazendo, mas vale lembrar que o RPG Maker possui uma EQUIPE por trás, e eu sou só um né.. :).

Eu calculo essa porcentagem porque eu começei a fazer parte do Interpretador em Java, pois como eu expliquei anteriormente eu acho, a ferramenta, assim como o RPG Maker, será composta por um Editor e um Interpretador.

E como água e óleo não se misturam, pra fazer um XML em .Net ser lido no Java tá dando um trampo danado, estou focando meu empenho no Editor, pois quando este terminar eu posso ficar por conta do Interpretador.

Começei na segunda-feira (23/01/2012) a construção e edição de eventos no mapa. Como todo maker sabe, os eventos são a vida dos jogos no RMK. começou a caminhar bem:

Mas agora estou fazendo o mais importante. A lista de comandos. E vou falar, vai dar um trabalhão danado.

Conforme o Helper do RPG Maker, a lista de comandos nada mais é do que um objeto que possui um código que representa aquele comando, para ser lido depois pelo interpretador e o mesmo saber do que se trata, e uma coleção de valores que, de acordo com o comando escolhido o interpretador tomará uma determinada decisão.

Parece bem simples, mas vamos à tela de comandos ro RMK:

A lista de comandos possível é ENORME, além de possuir o ulitmo botão "Chamar Script" onde um código ruby pode ser escrito. A probabilidade de se fazer um jogo burro ou um RPG fantástico está toda aqui, na combinação destes comandos.

Para o DRMK, eu iniciei organizando os botões por categorias e removendo aquilo que não faz parte do contexto:

É preciso lembrar que o DRMK construirá jogos para Android, então certos comandos como "Opções de teclas" estão completamente fora do contexto, e opções como "Vibrar Device" podem facilmente entrar na lista.

Continuo a trabalhar com empenho, pois cada botão destes representa uma janela que precisa ser construída, e nesse exato momento são 87 !!

Ainda esta semana (Eu acho) eu devo falar sobre o lançamento do meu próximo jogo, Max the Gold Hunter.

E como eu digo sempre : Be Brave, Be Bold, Create !!

Até a próxima !

Deploy RPG Maker - Editor de Mapas

2012-01-17T13:30:00.000-02:00

Como vai Pessoal !

Estou eu aqui de novo pra falar mais um pouco do andamento do DRMK. Estou tentando fazer as coisas aos poucos, mas a vontade de ver pronto tá me deixando louco !

Depois do sucesso na construção do Editor de Tilesets eu começei logo o Editor de Mapas. Este com certeza é bem mais complexo, e mais uma vez o WPF se sobresaiu.

Fiz um video para que vocês vejam o funcionamento básico:

Deploy RPG Maker - Tiled Map Editor from joaoneto on Vimeo.

Os comandos principais de edição já funcionam, com multipla seleção de tiles que é uma verdadeira Mão-na-roda. Um preenchimento e exclusão dos tiles da camada em Lote pra poder compensar algumas coisas que eu não conseguirei colocar, e o próximo passo é os atalhos de teclado e menu de contexto com o básico: Copiar, Colar, Excluir, etc.

O editor de Eventos eu devo começar em breve, mas como ainda não decidi se o Interpretador vai ser em RGSS ou BASIC estou deixando esse mais pra frente.

É isso. Mais notícias eu voltarei aqui.

Até a próxima.

Janken Game - O Primeiro de Muitos !

2012-01-15T15:54:00.000-02:00

Olá de novo pessoal !

Tenho falado muito da minha ferramenta pra RPG, e tenho esquecido de falar do mais importante, os Títulos !

Lá por meados de Agosto/2011, logo que me formei, com muitas glórias por causa desse projeto aqui, Over Horizon Tribute, Eu já estava estudando a plataforma Android a algum tempo. Começei a fazer um Framework pra me auxiliar (Meu foco é arquitetura, então fazer Framework faz parte do processo) a desenvolver um jogo bem simples. Eu pensei em várias coisas: Pipe Puzzles, Quebra-Cabeça de peças, e mais uma infinidade de coisas, até chegar num que parecia a solução: Janken-pô.

Dei uma pesquisada, e vi que haviam poucos títulos do gênero para a plataforma. Isso me animou a fazer pelo menos o Beta, onde não é possível jogar contra um amigo nem há contagem de pontos: Janken Game

Esses tempos atrás eu estava pensando em fazer um vídeo, colocar pontuação, ser possível jogar por BlueTooth com um amigo e mais um monte de coisas, mas acabei focando em outros projetos como o Tom Balla Adventures e o Max the Gold Hunter, que estão em andamento mas logo logo estarão disponíveis para download no Market.

Fazer jogos tem que ser paixão. Se for por dinheiro ou entretenimento apenas, não perca seu tempo.

E como eu digo sempre : Be Brave, Be Bold, Create !!

Até a próxima !

Deploy RPG Maker - Editor de Tilesets

2012-01-15T15:36:00.000-02:00

Como diria Steven Tyler: I'm Back in the Saddle Again !

Hoje vou falar de uma parte do DRMK (Deploy RPG Maker) que tem me dado trabalho: O Editor de Tilesets. Para tentar seguir à risca o que o RMXP faz, eu tenho que tentar reproduzir ao máximo suas ferramentas, até porque meu foco é trazer os Makers do RMXP para este novo mundo.

O maior de todos os desafios até agora é a configuração Tile by Tile dos seguintes itens:

Bloqueado: Informa diretamente se aquele tile é passável ou não.
Direções Bloqueadas: Configura se um tile é Não passável em alguma direção, para que o próximo tile naquela direção seja passável por exemplo. É muito utilizado em pontes por exemplo, onde as laterais da ponte são bloqueadas mas no rio é livre.
Prioridades: Configura a prioridade de desenho, muito usada em objetos altos como copas de árvores.
Gramado: Este é um item interessante: Se estiver configurado como Gramado o Tile é Half-Drawed, ou seja, tem só uma porção do mesmo desenhada com transparência sobre o objeto que está passando no momento, dando a impressão de que o objeto está mergulhado no tile.
Balcão: Outro item interessante: Ele bloqueia a passagem do lado de baixo do objeto, mas muda a prioridade de desenho de acordo com a direção a posição Y do mesmo.
Terreno: Configura até 8 tipos de terreno para o tile. isto pode ser usado por exemplo para criar terrenos com lama onde o objeto se move mais lentamente, ou terrenos venenosos, onde se o objeto tocar ele fica envenenado.

Depois de muito apanhar do Winforms para fazer a configuração, apelei pro WPF. Com muito menos código e configurações o resultado já está satisfatório:

A vantagem do uso do WPF está na facilidade de desenho de objetos com fundo transparente. Estou muito satisfeito com o resultado e pretendo mudar o editor de grupo de Inimigos para WPF também, além de fazer o Editor de Animações do mesmo modo.

Por enquanto é isso. Devo falar de outras coisas, como os jogos que já desenvolvi, mas continuo falando do DRMK assim que possível.

E como eu digo sempre : Be Brave, Be Bold, Create !!

Até a próxima !

Deploy RPG Maker - Banco de dados

2012-01-04T21:19:00.000-02:00

Estou de volta, Feliz ano novo !

Enquanto estava por conta, começei a trabalhar no projeto pela parte mais importante: A modelagem de dados. Seguindo um velho Help do RPG Maker XP em inglês que eu tenho aqui (Disponível pra download no final do post) começei a analisar o que seria necessário pra dar andamento no projeto.

Fazer um RMXP Like pode ter suas vantagens, e com certeza a principal delas é atrair os usuários dessa maravilhosa ferramenta para usar esta que está começando a nascer. Algumas imagens de como anda:

Estou trabalhando com empenho, e no que mais vai interessar a todos: Código para customização. A parte mais complicada, pois eu terei que construir o Parser do zero. Estou com vontade de fazer pra Ruby, mesmo que o BASIC também seja uma linguagem na qual eu tenho pensado.

Mais notícias no próximo post.

Como prometido, Segue o Link do Help em Inglês do Rpg Maker XP, uma mão na roda pra quem quiser aprender mais sobre RGSS: Help em Ingles do RMXP

E como eu digo sempre : Be Brave, Be Bold, Create !!

Até a próxima !

Deploy RPG Maker - When the code Begins!

2011-12-16T10:02:00.000-02:00

Há muito muito tempo atrás, lá por meados de 2001/2002, eu conheci uma ferramenta que mudaria a minha vida. Era o RPG Maker 2000. Com ela, além de entender melhor como funcionavam os jogos de RPG que tanto gosto, como Final Fantasy 6 e outros, começei a aprender programação. Entender variáveis, condições, loops.

Alguns anos mais tarde a Enterbrain, dona do RPG Maker, lançou uma versão que literalmente veio para ficar: RPG Maker XP. com ele, além de tudo que já era possível com o 2k/2k3, foi adicionada a opção de desenvolvimento usando a linguagem Ruby, o RGSS.

Hoje, quase 10 anos depois do meu primeiro contato com o RPG Maker, sou um profissional da área de Desenvolvimento de sistemas, mas minha paixão por jogos continua aqui, firme e forte.

Nos dias de hoje, programar para PC é programar para um grupo muito restrito de pessoas. Se houvesse uma forma de se fazer jogos, como no RPG Maker, mas para plataformas como Android, seria algo maravilhoso, certo? Pensando nisso há várias ferramentas hoje no mercado, que facilitam o desenvolvimento e a publicação para a plataforma, entre elas a grande Corona SDK, o IRM Project, entre outros.

Mas então porque fazer uma ferramenta, já que o mercado está abarrotado delas?
1º detalhe: A maioria das boas ferramentas são pagas e caras.
Eu concordo, passar anos fazendo algo pra colocar de graça na net e o povo ainda falar que é ruim é uma Me#$%.
2º detalhe: Eu já vi jogos fantásticos feitos em no RM2K, ou seja, mesmo que o RGSS tenha vindo para mudar tudo, existem pessoas que com uma ferramenta sem codificação fazem milagres.
3º detalhe: São poucas as ferramentas de mercado que usam o termo "write once, run anywhere", ou seja, no caso dos RPG Makers, o que é feito nele só roda em PC com Windows, então se um "Maker" fizer um grande jogo e quiser portá-lo já era.

Estes são alguns dos detalhes que me levaram a querer fazer uma ferramenta assim. Estou começando a desenhar, e logo logo eu terei mais novidades.

Até a próxima, e como eu digo sempre: Be Brave, Be Bold, Create !

Hora de Bloggar !

2011-12-15T20:26:00.000-02:00

Olá pessoal !

Estou eu aqui começando um Blog do meu portal de jogos para Android e HTML5. Mas porque essas plataformas e porque jogos?

Bem, os dois tem muito em comum: Estão na "moda" e hoje em dia as produções independentes estão cada vez mais ganhando mercado. Salve Google !

Já tenho um game publicado, bem simples, mas foi a primeira boa impressão que tive tanto da plataforma: Janken Game.

No portal já estão divulgados mais três títulos que estão em andamento, logo logo tem coisa nova por aí: Deploy Games.

Bom, é isso. Espero estar de vez em quando por aqui para falar das novidades.

Até a próxima!