The king of space (TKOS)

Aproveitando que meu filho está com preguiça de nascer eu resolvi tirar um projeto do papel \o/ (mais um dos que não devo terminar? XD)

The king of space (TKOS) será um jogo de batalha espacial, onde o objetivo vai ser pegar a coroa do rei pirata.  Esse projeto, na realidade, será um grande estudo das ferramentas que escolhi usar .

No momento eu só tenho a base do projeto, agora focarei em fazer o gameplay…

tkos.png

Classe da primeira tela

#javascript #node #babel #webpack #es6 #es7 #phaser3 #yarn #vscode #SOCKETIO

#tkos #indieGame #soloGame #craftGame

As Chaves de Isópolis

As Chaves de Isópolis

As Chaves de Isópolis surgiu de uma desafio proposto pela empresa Tamboro, onde tínhamos que escolher uma mecânica do livro 10 melhores jogos de todos os tempos  e transforma em um jogo educativo que atendesse os requisitos da Plataforma Ludz com o tema do Sr.X,  que você pode encontrar na Google Play e na App Store.

Escolhemos Agon também  conhecido como Guarda Real, ou Guarda da Rainha (The Queen’s Guard). Um jogo de confronto estratégico para 1 jogador. O tabuleiro é formado por casas hexagonais e, na nossa releitura, a quantidade de casas varia de acordo com a progressão do jogador.

Para tornar o joga um pouco mais divertido, colocamos no final, depois de dominar o centro, um cofre com uma senha super secreta, e para desvenda-la o jogador vai ter que coletar e decifrar enigmas matemáticos ao longo do jogo.

Isópolis se trata de uma cidade pacata que teve seu equilíbrio perturbado pelo Sr.X, que com sua incrível astucia descobriu onde o prefeito guardou as preciosas chaves da cidade e pretende controlar a cidade tomando-as pra si.  Em meio ao caos, o(a) xerife deve chegar primeiro nos cofres e garantir que tudo ficará bem.

No desenvolvimento de As Chaves de Isópolis seguimos todas as regras proposta pelo jogo original e tomamos a liberdade de colocar uns powerups, como: teletransporte, poder voltar, andar mais de uma casa e outros.
Pra montar o tabuleiro eu procurei um bocado na internet, e, rapidamente, encontrei varias abordagens.
Segue o link do material que mais me ajudou ->
http://catlikecoding.com/unity/tutorials/hex-map/part-1/
http://www.redblobgames.com/grids/hexagons/

Usamos como ferramenta Unity que, sem dúvidas, é uma ferramenta espetacular. Tentei explorar o máximo possível do que  “UnityEntityManager” e C# tinham pra dar usando bastante namespaces, signals, extension method, delegate, event, action, generics, lambda, reflection, annotations, customização do editor e etc.

 

Maestria – Jogo de Cartas

Maestria – Jogo de Cartas

Maestria é um jogo de cartas onde o jogador, no papel de maestro, deve evoluir sua orquestra para que possa ser feito um bom show. Seu nível de maestria controla a quantidade de músicos que podem estar sob sua regência. Os músicos permitem que seja feito a música e a platéia faz seu papel de encher a casa. Entretanto, encher só a casa não basta, você também deve agradar o público, que as vezes é bastante criterioso. Não se preocupe com a pressão de estar no palco, com alguns C[Dó], D[Ré], E[Mi], semicolcheia, colcheia e semínima o seu show será incrível!

O jogo suporta até 4 jogadores com um conjunto de 70 cartas podendo chegar a 8 jogadores com 2 pacotes de cartas. Se a casa estiver cheia, prepare um bom espaço para jogar.

Possui uma extensão que trara ao jogo mais personagens e um lindo tabuleiro.

Com poucas regras acaba sendo um jogo de rápido entendimento.

Use os tokens de maneira adequada para facilitar a contagem de pontos. Mas com uma mesa de jogadores pro os tokens podem nem entrar no jogo.

mastria_blog

Maestria – Arte – v0.2

foto

Maestria – Arte – v0.1

#MasteryCardGame
#MaestriaJogoDeCartas

Entidade – Jogo de tabuleiro

Entidade – Jogo de tabuleiro

Entidade é um jogo de investigação cercado de eventos paranormais, onde os jogadores devem desvendar os mistérios, manter-se vivos e manter-se sãos.

O jogo e composto por contos, pisos, cômodos, objetos(faca, crânio, bandagem e etc), dicas e eventos. Alguma sorte é preciso para que ao manipular uma arma não atire no próprio pé, ou quando se deparar com um crânio não perca as estribeiras.

O tabuleiro e divido em três partes, os pisos, que podem ser usados individualmente pelo conto. O tabuleiro e dividido em tiles (quadradinhos) e o jogador se movimenta ortogonalmente por ele. Os cômodos dentro do piso (nome dado para as partes do tabuleiro) são organizados de acordo com o conto. Cada cômodo guarda um segredo, um fragmento da trama e/ou um objeto. Os cômodos possuem 4 possíveis temas, normalmente um conto usa um tema.

O objetivo do jogo vai variar de conto pra conto, mas posso adiantar que ele e bem dinâmico podendo ter no mesmo conto objetivos diferentes para jogadores diferentes, ou, mudar ao logo do jogo, fora isso e só decifrar o que a entidade está querendo para parar de perturbar a vida de todo mundo 🙂

Há… Sim… A entidade por vezes pode pegar o corpo de algum jogador pra poder ficar  mais “”divertido””.

Como podem ter notado, o conto dita as regras. Dita mesmo! Um conto pode ter suas próprias regras, mudando como algo se comporta no jogo.

 

Entidade é um jogo para toda a família, complexo, que envolve estratégia e lógica. Ler bem as regras antes e/ou ter na mesa alguém que já saiba jogar pode ajudar.

tumblr_nhil1hAE3P1u5cg6io1_1280[1]

1ª versão da arte e dos elementos que compõem o jogo


O jogo ainda esta em beta faltando bem pouco para fechar (apenas finalizar o ultimo conto)  \o/

#EntityBoardGame
#EntidadeJogoDeTabuleiro

Angular 2 – Bundle

Angular 2 trouxe muitas coisas legais, mas algumas coisas NÃO tem sido fácil =’/
Uma dessas coisas ruins que estou enfrentando com Angular 2 tem sido gerar um bundle pra produção num fluxo fluido de trabalho…
Pensando nisso (sofrendo com)…
Resolvi fazer uns protótipos com diversas ferramentas pra saber o caso de uso de cada uma delas.

 

Webpack

(work in progress)
https://github.com/Espigah/JavascriptRepo/tree/master/Angular2/casework_6_bundle/webpack

JSPM + SystemJS

(work in progress)
https://github.com/Espigah/JavascriptRepo/tree/master/Angular2/casework_6_bundle/jspm

Rollup

(work in progress)
https://github.com/Espigah/JavascriptRepo/tree/master/Angular2/casework_6_bundle/rollup

Angular “official”

(work in progress)
https://github.com/Espigah/JavascriptRepo/tree/master/Angular2/casework_6_bundle/official

Gradle

Coming soon…
https://github.com/Espigah/JavascriptRepo/tree/master/Angular2/casework_6_bundle/gulp

Gulp

(Coming soon) https://github.com/Espigah/JavascriptRepo/tree/master/Angular2/casework_6_bundle/gradle

 

 

Gradle vs Gulp

gulp_vs_gradle


Um pouco sobre as duas ferramentes

Gulp tem sido usado em larga escala por desenvolvedores front-end para automatização de processos. Tendo algumas concorrências diretas como o Grunt.
http://gulpjs.com/

 

Gradle vem ganhando forças principalmente por ter sido adotado pelo Google e por ser um ótima opção pra quem usa Apache Maven.
http://gradle.org/

 

Irei apenas mostrar algumas diferenças dos pontos mais básicos das duas ferramentas, ou seja, serei bem superficial, mas irei colocando links para quem tiver interesse em mais conteúdo.

Instalação:

Gulp Gradle
Ter feito a instalacao do node
Criar um npm project
Depois instalar globalmente e localmente o gulp

npm init
npm i --global gulp
npm i --save gulp

https://github.com/gulpjs/gulp/blob/master/
docs/getting-started.md

Faze download do Gradle no site e configurar o GRADLE_HOME
https://docs.gradle.org/current/
userguide/installation.html

 

Arquivo principal:

Gulp Gradle
gulpfile.js  build.grade

 

Primeira tarefa:

Gulp Gradle
var gulp = require('gulp');
gulp.task('HelloTask', 
function() { 
 console.log(‘gulp_vs_gradle’)
});

No prompt de comando:

 gulp HelloTask 
task HelloTask<< {
 println 'gradle_vs_gulp'
}

No prompt de comando:

gradle HelloTask

ou

gradle HT

 

Ciando variáveis:

Gulp Gradle
Como o Gulp é puramente javascript basta usar o var


gulp.task('Task2', 
function() {
var foo="gulp_vs_gradle"; 
console.log(foo);
});
Como o Gradle tira proveito do Groovy podemos ter tipagem ou não.

task Task2 << {
String foo='gradle_vs_';
def bar = 'gulp';
println (foo+bar);
}

 

Usando plugins:

Gulp Gradle
Pra instalar tem que usar o node

npm install --save-dev PLUGIN

e no gulpfile.js “importa-lô”

 

var plugin = require('plugin');


http://gulpjs.com/plugins/

Coloque os imports no build.gradle

 plugins { 
id "com.moowork.node"
 version "0.12"

id "com.moowork.gulp" 
 version "0.12" 
} 

Execute ‘gradle tasks’ e veja que já teremos tasks para o node e para o gulp
feito magica!

gradle tasks

https://plugins.gradle.org/

Garbage-Collector Post-Mortem

Estáááá no aaaar Garbage Collector 2

E agora estou aqui para hablar um pouco do que foi desenvolver em Flambe e em OpenFl
Primeiro estudo foi usar OpenFl (Escrevi sobre aqui)
OpenFl parece funcionar de forma mais natural com Haxe do que Flambe.
Flambe se propõem a ser uma engine completa para jogos 2D, mas tem algumas coisas não tão naturais de se fazer.
Uma vantagem/Um atalho que Flambe disponibiliza é o “_” que atrapalhou mais do que ajudou =/

Não sei se tem como usar AIR com OpenFl, porem, com Flambe-Mobile funciona so com AIR.
Cuido com o ID =/ Onde era pra ser ‘app.espigah.garbagecollector2’ virou ‘air.app.espigah.garbagecollector2’

Eu basicamente quis portar de OpenFl+HaxePunk para Flambe, pensando que seria fácil, mas….só pensei! =/
Flambei não funcionou bem com PARTICLE-EDITOR e fica bem preso a FLUMP

Outra diferença foi o tamanho do app, não sei porque ficou tão diferente, mas… Com OpenFl o app não passou de 2MB enquanto com Flambe ficou em 12MB =/

E ainda não consegui fazer o Analytics funcionar para a versão Mobile
Em suma, eu não voltaria a criar algo com Flambe (muito sofrido)
mesmo tendo um app rodando bem em HTML5, FirefoxOS e outros

Garbage Collector 1 – OpenFl / Haxe
Garbage Collector 2 – Flambe / Haxeopenfl_haxe_flambe

%d blogueiros gostam disto: