Engine 2D Parallax - Screens Game Teste

Show de bola.

Obrigado. ^^

Desde que iniciei o mestrado este ano, não tive tempo para quase nada, estive aos poucos trabalhando nesta versão do projeto, este mês de Dezembro resolvi dar um gás, coisa que consegui.

Estou decidindo como vou fazer o sistema de batalha, se deixo como na versão 2.0 (Onde víamos os monstros no mapa e ficavam dando spawn) ou se deixo ao estilo Pokemon (Andar em uma zona de agressão pode levar a uma batalha).

Michel.Montenegro:

Obrigado. ^^

Desde que iniciei o mestrado este ano, não tive tempo para quase nada, estive aos poucos trabalhando nesta versão do projeto, este mês de Dezembro resolvi dar um gás, coisa que consegui.

Estou decidindo como vou fazer o sistema de batalha, se deixo como na versão 2.0 (Onde víamos os monstros no mapa e ficavam dando spawn) ou se deixo ao estilo Pokemon (Andar em uma zona de agressão pode levar a uma batalha).

Eu gosto mais do primeiro estilo. O ideal mesmo seria implementar os dois, como fazia o Neverwinter Nights.

ViniGodoy, lembra como calculamos o tempo em minutos utilizando o delta?

To pensando em usar o tempo com "System.currentTimeMillis()"
ex.: a cada 10 minutos faço uma checagem, mas não sei qual seria o “melhor” caso.

private static final void UM_MINUTO = 60000;

...

tempoTranscorrido += delta;
if (tempoTranscorrido > UM_MINUTO * 10) {
   //Faz o que quer fazer
   tempoTranscorrido = 0;
}

Claro que seria legal criar uma classezinha de timer que encapsulasse essa lógica.

Obrigado. ^^
A função da LibGDX “Gdx.app.getGraphics().getDeltaTime()” retorna o delta em segundos.

if(time >=60)
			{
			    //do your stuff here
			    System.out.println("timer after 60 sec :>");
			    time = 0; //reset
			}

Agora a X minutos ou segundos vou fazer com que o surgimento dos monstros no mapa seja checado.

Estou pensando se a cada minuto seria um bom tempo para checar isso.

Eu geralmente converto o tempo para segundos também quando trabalho com jogos. É uma unidade muito mais conveniente para o cálculo físico. As engines de física, como a Box2D, também trabalha com essa unidade.

Alguém aqui conhece alguma função ou algoritmo que me retorne aleatoriamente um grupo de valores dentro de uma lista?
Exemplo:

Tenho o seguintes valores: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Dos 10 valores acima tenho que pegar 4(Quatro) valores aleatoriamente (Não pode repetir valor!)

Exemplo de resposta correto: 3,5,6,9
Exemplo de resposta errada: 3,5,5,9

Pensei em usar um método recursivo aplicando “random” até conseguir os valores que desejo, mas algo me diz que tem forma melhor de se fazer isto.

Use o método Collections.shuffle:

List<Integer> numeros = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    numeros.add(i);
}

Collections.shuffle(numeros);
for (Integer numero : numeros) {
    System.out.println(numero);
}

Entendi, caso queira pegar 4 valores aleatórios, misturo e pego os 4 primeiros.

Obrigado. ^^

Indo nesta mesma linha, tem alguma forma de pegar dentro de uma lista o valor mais próximo com base em um numero?
Exemplo:
Valores: 1, 5, 12, 18
pivô: 14
Resposta: 12 (14 esta mais próximo de 12 que 18 ).

public static int findNearestNumber(int[] array,final int myNumber) {
    	List<Integer> valores = new ArrayList<Integer>(array.length);
    	for (int i = 0; i < array.length; i++) {
			valores.add(array[i]);
		}

    	Collections.sort(valores,  new Comparator<Integer>(){
    		  public int compare(Integer valorA, Integer valorB) {
    			  int value1 = (valorA-myNumber)*(valorA-myNumber);
    			  int value2 = (valorB-myNumber)*(valorB-myNumber);
    		    return value1 - value2;
    		  }});

    		return valores.get(0).intValue();
    }

public static int returnItemProb(int[] array){
    	double p = Math.random()*100;
    	double cumulativeProbability = 0.0;
    	int index = 0;
    	for (int item : array) {
    	    cumulativeProbability += item;
    	    if (p <= cumulativeProbability && item != 0) {
    	        return index;
    	    }
    	    index++;
    	}
		return 0;
    }

Talvez com o método Collections.binarySearch, desde que a lista esteja ordenada. Quando ele não acha um número, ele retorna um valor negativo indicando o ponto de inserção. Provavelmente o valor desse ponto, ou imediatamente anterior a ele, será o que você quer.

Viny ou outro que queira dar uma opinião:
Já tenho os métodos de spawnMonster e resetAllMonster funcionando, porém estou em um dilema (Mesmo da versão antiga).
Quando devo criar os monstros e quando devo remover?

• Parece besta a pergunta, mas pensem comigo, tem 5 monstros em campo, eu derroto 2, ficando 3, pode ocorrer de cair no tempo do reset (Remover tudo e readicionar), fica meio “bruto” isto, deve ter uma forma mais suave de fazer isso.
  Obs.: Neste caso não precisa por algoritmos (Só se for ilustrar algo), mas o importante é a ideia.

Umas novidades para o projeto:
Criei o GameTime e implementei o conceito de Tempo e transição entre dia e noite.

• Madrugada->Amanhecendo.
• Dia->Entardecendo.
• Tarde->Anoitecendo.
• Noite->Alvorada.

Também adicionei suporte a caverna, onde o campo de visão e personalizável pelo criador do jogo (Caso ele não queira usar o default)

Olha algumas as imagens de exemplo:

Eu colocaria os seguintes parâmetros para o respawn:

• Tempo mínimo a após a morte do último monstro do grupo
• Delay entre respawns.

Essas informação são associadas as demais informações da área de respawn (tipo de monstro, tamanho do grupo, etc).

Veja como os parâmetros funcionam:

Situação 1:
Tempo minimo: 50 segundos
Delay: 0 segundos

Não haverá respawn enquanto o jogador estiver matando monstros em menos de 50 segundos. Caso o jogador finalize com o grupo, ou mate demore demais a matar, todos os monstros que estavam mortos ressuscitam juntos.

Situação 2:
Tempo minimo: 50 segundos
Delay: 0,5 segundos

Não haverá respawn enquanto o jogador estiver matando monstros em menos de 50 segundos. Caso o jogador finalize com o grupo, ou mate demore demais a matar, um monstro novo fará respawn a cada meio segundo.

Situação 3 (Horda Zumbi):
Tempo minimo: 0 segundos
Delay: 0,5 segundos

A cada 50 segundos, um monstro morto do grupo ressuscita, independente do jogador mata-los ou não.

Agora e engine marca a hora, dia e mês. ^^

Entendi, Pelo que li os exemplos são perfeitos para um numero “fixo” de monstros na hora de uma área. mas e no caso em que o Spawn dos monstros (Quantidade) é dentro de um intervalo?
Exemplo:
Na figura abaixo tem duas áreas de Spawn (Cor vermelha), onde este objeto (vermelho) tem alguns atributos indicados na outra figura.
O atributo relevante é o minMaxCountMonster, caso ponha de 1-10 ele aleatoriamente escolhe um valor entre 1 e 10, digamos 6 e cria 6 monstros, no próximo respawn pode ser sorteado 8 (Fiz isso para dar um pouco mais de mudança no ambiente).

Gostei do sistema de nenhum respawn pode ser executado enquanto algum monstro daquela área estiver sobre agressão (Respawn só quando esta tudo em “No Agress”), caso contrario o repawn geral dos monstros vai ocorrer. Correto?

Pronto deu para fazer isso, foi até mais fácil do que imaginei. Obrigado!

Cada área de agressão objetos vermelhos, são tratadas separadamente, se um monstro nesta área esta em “batalha” ele considera que esta área não sofre respawn. Enquanto as áreas não marcadas como “Em batalha” vão sofrer respawn normal.

Checo isto a cada minuto(60 seg).

Com isto posso ir para a tela de batalha ^^

Agora a engine trata (Hora, dia e Mês durante o jogo. Só não trato a passagem dos anos).

Viny não sei se recorda, mas a muito tempo atrás implantei sistema de chuva, nuvem passando, tempestade de areia. Mas acho que fiz de forma muito bruta. Atualmente já deves também ter mais experiência nisso, como poderia fazer isso atualmente (Focando performance).

Gostaria de liberar a versão Alpha da Engine em sua versão atual de desenvolvimento para testes até no máximo em fevereiro, vamos ver se consigo. rsrsrs…

Michel.Montenegro:

Agora e engine marca a hora, dia e mês. ^^

Entendi, Pelo que li os exemplos são perfeitos para um numero “fixo” de monstros na hora de uma área. mas e no caso em que o Spawn dos monstros (Quantidade) é dentro de um intervalo?
Exemplo:
Na figura abaixo tem duas áreas de Spawn (Cor vermelha), onde este objeto (vermelho) tem alguns atributos indicados na outra figura.
O atributo relevante é o minMaxCountMonster, caso ponha de 1-10 ele aleatoriamente escolhe um valor entre 1 e 10, digamos 6 e cria 6 monstros, no próximo respawn pode ser sorteado 8 (Fiz isso para dar um pouco mais de mudança no ambiente).

Gostei do sistema de nenhum respawn pode ser executado enquanto algum monstro daquela área estiver sobre agressão (Respawn só quando esta tudo em “No Agress”), caso contrario o repawn geral dos monstros vai ocorrer. Correto?

Correto.

Agora, sobre o número variável, é uma boa pergunta. Talvez re-sortear esse número após esse número variável de monstros ser morto?

Alguém tem alguma ideia como jogos de RPG baseado em exp, usam sistema de ganho de experiência ?

Estou pensando em fazer mais ou menos assim:
- Basicamente defino o Cap máximo de experiência para o level máximo, informo que todo monstro derrotado da 5% da experiência necessária para passar de level. Porém este valor pode ser maior ou menor dependendo da diferença do level entre o herói e o monstro(Sendo que só é considerado uma diferença de até 10 leveis como no Lineage 2).

final int BONUS_PENALITY_LEVEL = 10; //10% de Bônus ou penalidade para cada 1 level de diferença.
final int LEVEL_MAX = 100; // Level maximo permitido é 100
final int EXP_MAX = 100000; //Experiencia maxima é 100.000
final int EXP_MONSTER = 5; //Todo monstro de mesmo level da 5% de exp. fixa.

int expUpLevel =  (LEVEL_MAX / EXP_MAX); // Resultado é 1.000 de exp para passar um level
int exp = (expUpLevel* EXP_MONSTER)/100; // 5% de 1k é 50

int difLevel = hero.getLevel()-monster.getLevel();
float varianceExp = (difLevel/BONUS_PENALITY_LEVEL)*exp ;

int expFinal=0;

if (difLevel >=0 && difLevel <=10) {expFinal = exp+varianceExp;}
if (difLevel >=-10 && difLevel <=-1) {expFinal = exp-varianceExp;}

Para fazer uma variação de um monstro para outro vou me valer do sistema de "Classe vs Classe" ao estilo pokémon (Fogo vs Agua), onde o multiplicador de dano vai influenciar na experiência.
Ex.: Multiplicador 0,5 reduz em 50% a exp ganha. (150exp final * 0,5 = 75 de exp final)

Isso varia muito de jogo para jogo. O importante é testar o seu sistema, bastante. Você também pode ler como isso funciona no D20.

Há formas estatísticas para se determinar o valor médio de experiencia e dificuldade dos encontros. Sobre isso, vale a pena os artigos do Tyler Sigman no GamaSutra:

Vou testar sim, com certeza.
A ideia básica é deixar que o balanceamento esteja na mão do criador do jogo, a engine somente de a base para ela ser construida.

Vou ler com calma estes links. ^^

Acredito que em fevereiro a versão alpha com manual e tudo já deve estar saindo. ^^
E com isso vou ter um feedback melhor do projeto.