Simulação de reprodução em JAVA

,

Então, estou fazendo um programa que simula reprodução de duas espécies, as passivas e agressivas, se uma espécie pega 1 comida ela apenas sobrevive no jogo, se uma espécie pega 2 comidas ela reproduz e sobrevive. Cada especie é locada para encontrar 1 par de comida, com uma probabilidade de encarar outra especia, um passivo, no qual eles dividem o par igualmente, e a agressiva, que pega 3/2 da comida, tendo assim 50% de chance de reproduzir e a passiva tendo 50% de chance de sobreviver, e assim indo. Porém meu programa apresenta um erro de calculo que não consigo, no qual a população reproduz de maneira incontrolavel, eis o código:

public class Simulação {

    public static void main(String[] args) {

    int mansos=5;
    int putos = 1;
    int reserva;
    int comidas;
    int prob; // Probabilidade de encontro padrão
    int probI; // Probabilidade de encontros de distintas raças
    int probS; // Probabilidade de sobrevivencia
    
    //Para uma determinada quantidade de comida
    //Os mansos vão aleatoriamente pegar o par de vetores de uma dessas comidas
    //Caso se encontrem eles dividem a comida e sobrevivem sem se reproduzir
    //Caso peguem o par sem se deparar com outros mansos, eles se reproduzem
    
    for(int i=0;i<300;i++){
        reserva = mansos;
        comidas=5;
        System.out.println(" - - - - - - - - - - - - - - - - Rodada numero: "+(i+1)+" - - - - - - - - - - - - - - - -");
        for(int j=0;j<mansos;j++){
            prob = 1+ (int) (Math.random() *100);
            probI = 1+ (int) (Math.random() *100);
         //Se tiver comida suficiente para reproduzir e sobreviver
            if(comidas>=0){
    
            if(prob>=0 && prob<=30){
               if(probI>=0 && probI<=50){
                   System.out.print("Um puto encarou um manso e ");
                   comidas -=2;
                   probI = 1+ (int) (Math.random() *100);
                   if(probI>=0 && probI<=50){
                       System.out.print("conseguiu reproduzir e ");
                       putos = putos + 1;
                   }
                   probS = 1+ (int) (Math.random() *100);
                   if(probS>=0 && probS<=30){
                       System.out.print("manso sobreviveu\n");
                   }
                   if(probS>50 && probS<=100){
                       System.out.print("manso morreu\n");
                       reserva -= 1;
                   }
               }
               else{
                System.out.println("Dividaram a comida");
                    comidas -=2;                
               }
            }
            
                else{
                    System.out.println("Individuo Reproduziu");
                    reserva +=1;
                    comidas -=2;
                }
            }
            }
        System.out.println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
        mansos = reserva;
    }
        System.out.println("Controle populacional de mansos: "+mansos);
        System.out.println("Controle populacional de putos: "+putos);
    }
}

Talvez retirar essas variáveis do for resolva

No caso a cada rodada a comida reinicia a contagem e as especies vao tendo um limite dessa comida devido sua quantidade, veja esse vídeo que me baseei: https://www.youtube.com/watch?v=YNMkADpvO4w

?

Depois disso daí, acrescenta isso:

		System.out.println("mansos: " + mansos);
		System.out.println("putos: " + putos);
		System.out.println("reservas: " + reserva);
		System.out.println("comidas: " + comidas);

Vai te ajudar a entender o que está acontecendo. E reduz de 300 rodadas para 10. Facilite sua vida para debugar.

Aqui está o erro! A cada rodada ele reatualiza a situação da comida, então você terá comida eternamente.

Veja as adaptações que fiz, pra ver se é isso que você precisa…

package estudos;

public class Principal {

	/*
	 * Então, estou fazendo um programa que simula reprodução de duas espécies, as
	 * passivas e agressivas, se uma espécie pega 1 comida ela apenas sobrevive no
	 * jogo, se uma espécie pega 2 comidas ela reproduz e sobrevive. Cada especie é
	 * locada para encontrar 1 par de comida, com uma probabilidade de encarar outra
	 * especia, um passivo, no qual eles dividem o par igualmente, e a agressiva,
	 * que pega 3/2 da comida, tendo assim 50% de chance de reproduzir e a passiva
	 * tendo 50% de chance de sobreviver, e assim indo. Porém meu programa apresenta
	 * um erro de calculo que não consigo, no qual a população reproduz de maneira
	 * incontrolavel, eis o código:
	 * 
	 */

	public static void main(String[] args) {

		int mansos = 5;
		int putos = 1;
		int reserva;
		int comidas;
		int prob; // Probabilidade de encontro padrão
		int probI; // Probabilidade de encontros de distintas raças
		int probS; // Probabilidade de sobrevivencia
		
		int rodadas =0;

		// Para uma determinada quantidade de comida
		// Os mansos vão aleatoriamente pegar o par de vetores de uma dessas comidas
		// Caso se encontrem eles dividem a comida e sobrevivem sem se reproduzir
		// Caso peguem o par sem se deparar com outros mansos, eles se reproduzem

		comidas = 5;
		for (int i = 0; i < 10; i++) {
			reserva = mansos;
			System.out.println(" - - - - - - - - - - - - - - - - "
					+ "Rodada numero: " + (i + 1) + " - - - - - - - - - - - - - - - -");
			for (int j = 0; j < mansos; j++) {
				prob = 1 + (int) (Math.random() * 100);
				probI = 1 + (int) (Math.random() * 100);
				// Se tiver comida suficiente para reproduzir e sobreviver
				if (comidas >= 0) {

					if (prob >= 0 && prob <= 30) {
						if (probI >= 0 && probI <= 50) {
							System.out.print("Um puto encarou um manso e ");
							comidas -= 2;
							probI = 1 + (int) (Math.random() * 100);
							if (probI >= 0 && probI <= 50) {
								System.out.print("conseguiu reproduzir e ");
								putos = putos + 1;
							}
							probS = 1 + (int) (Math.random() * 100);
							if (probS >= 0 && probS <= 30) {
								System.out.print("manso sobreviveu\n");
							}
							if (probS > 50 && probS <= 100) {
								System.out.print("manso morreu\n");
								reserva -= 1;
							}
						} else {
							System.out.println("Dividaram a comida");
							comidas -= 2;
						}
					}

					else {
						System.out.println("Individuo Reproduziu");
						reserva += 1;
						comidas -= 2;
					}

					System.out.println("- - - - - - - - - - - - - - - - - - - - - - - -");
					System.out.println("mansos: " + mansos);
					System.out.println("putos: " + putos);
					System.out.println("reservas: " + reserva);
					System.out.println("comidas: " + comidas);
					mansos = reserva;
				} else {
					System.out.println("Acabou a comida!");
					rodadas = i;
					break;
				}
				
				
			}
			
			if (comidas < 0) {
				break;
			}
		}
		System.out.println("\nFinal:");
		System.out.println("Total de rodadas antes de acabar a comida: " + rodadas);
		System.out.println("Controle populacional de mansos: " + mansos);
		System.out.println("Controle populacional de putos: " + putos);
	}

}

Não expliquei muito bem, mas no caso a comida deve realmente reiniciar toda rodada, no caso se na primeira rodada tem-se 10 comidas, quando acaba a rodada e começa outra ela volta para 10.
No caso é um sistema que reinicia a comida a cada rodada, quandos as especies vão se reproduzindo, essa mesma quantidade de comida que permanece a mesma setada desde o inicio fica limitada para tantos indivíduos numa dada rodada, tal qual não vai ser possível os mesmos reproduzirem mais pois não a comida suficiente para tal(Lembrando que com 2 comidas eles reproduzem e com apenas 1 eles sobrevivem nas próximas rodadas), e com isso as rodadas vão passando e consistindo nos putos brigando por comida e alguns mansos morrendo.

E o problema no caso e que com o passar das rodadas o programa excede o limite de criaturas para a comida disponível, por exemplo tem: 50 mansos no ambiente, sendo que o programa inicializa com 10 de comida, isso não faz sentido pois para o manso sobreviver ele tem que ao menos pegar 1 comida;

Não vou sugerir uma solução porque não entendi bem as regras (como assim pegar 3/2 da comida? Se tiver 4 de comida, então 3/2 de 4 é igual a 6 :man_shrugging:).

Mas vou sugerir algumas melhorias. Para gerar um número aleatório de 1 a 100, você pode criar um java.util.Random e usar o método nextInt:

Random rand = new Random();

...
prob = rand.nextInt(100) + 1;

Além disso, dá para melhorar os if's. Como eu sei que as probabilidades sempre estarão entre 1 e 100, é redundante e desnecessário testar se são menores que zero ou maiores que 100. Então poderia ser:

Random rand = new Random();

if (prob <= 30) { // não precisa ver se é menor que zero
    if (probI <= 50) { // idem
        System.out.print("Um puto encarou um manso e ");
        comidas -=2;
        probI = rand.nextInt(100) + 1;
        if (probI <= 50) {
            System.out.print("conseguiu reproduzir e ");
            putos++; // para somar 1 pode ser assim
        }
        probS = rand.nextInt(100) + 1;
        if (probS <= 30) {
            System.out.print("manso sobreviveu\n");
        } else if (probS > 50) {
            System.out.print("manso morreu\n");
            reserva--; // para subtrair 1 pode ser assim
        }
    } else {
         System.out.println("Dividaram a comida");
         comidas -= 2;
    }
} else {
    System.out.println("Individuo Reproduziu");
    reserva++;
    comidas -= 2;
}

Quanto à lógica em si, como já disse, não sugeri nada porque não compreendi bem as regras.

1 curtida

Essas anotações eu tava meio doidão quando tava fazendo kkkk, tava um barulhão quando eu fui fazer esse código no meu estágio, refiz ele em casa usando c++ bem mais bonito e limpo o codigo, porém com o mesmo problema.

Assista a esse vídeo que é basicamente o mesmo programa que eu estou tentando simular PORÉM sem as animações obviamente, apenas os dados: https://www.youtube.com/watch?v=YNMkADpvO4w

Se puder me dar uma orientação de como reproduzir isso, irei ficar muito grato mesmo

Não assisti tudo por motivos de “só parei pra ver enquanto fazia build”, mas enfim, o que dá pra pensar inicialmente:

  • se a comida vem sempre em pares, não faz sentido ter comidas = 5. A quantidade de comida sempre será par, e entendi que ela sempre é consumida em pares. Então uma alternativa seria a variável ter a quantidade de pares (pois me parece que tanto faz: paresComida = x e diminui 1 quando alguém come ou comidas = x e diminui 2 quando alguém come)
  • o que vc tem que simular de fato é se há encontros ou não, baseado nas quantidades de cada um. Por exemplo, se tem 5 doves e 3 hawks (ou seja, 8 indivíduos), e 10 pares de comida, pode ser que ninguém se encontre, mas pode ser que haja no máximo 4 encontros. Mas se tiver 100 doves e 50 hawks (150 indivíduos) e 70 pares de comida, então haverão com certeza 70 encontros e 10 morrerão de fome pois não encontrarão comida (aliás, é falado algo sobre a quantidade de comida? Sempre tem o suficiente ou eventualmente alguns morrerão de fome?)

Enfim, parece ser um pouco mais complicado do que você pensou inicialmente, pois entre, por exemplo, 3 doves e 2 hawks, temos os possíveis encontros:

  • dove1 × hawk1, dove2 × hawk2 e dove3 não encontra ninguém
  • dove1 × dove2, hawk1 × hawk2 e dove3 não encontra ninguém
  • dove1 × dove2, o resto não se encontra (supondo que hajam pelo menos 4 pares de comida)
  • ninguém se encontra (supondo que hajam pelo menos 5 pares de comida)
  • etc…

O que é aleatório então é:

  • escolher as combinações possíveis entre doves e hawks (os encontros e os que não encontram ninguém) - e talvez nem precise subtrair a quantidade de comida, pois você só precisa saber se sobrou ou faltou, baseado na quantidade de encontros
  • as probabilidades do que acontece quando um dove encontra um hawk (o primeiro tem 50% de chance de morrer, o segundo tem 50% de chance de se reproduzir) - pois nos outros casos não há probabilidades (2 doves, ambos sobrevivem; 2 hawks, ambos morrem).
1 curtida

Então é basicamente isso que eu tentei fazer, pelo visto simplifiquei demais as coisas kkk, mas pode me dar algum norte de por onde fazer essas varias probabilidades sem usar IF e tudo mais? Eu entendi a lógica porém não faço ideia de por onde começar no próprio código a fazer esse tipo de jogo aparentemente.

  • Alias sobre a questão que você perguntou, sim havera em alguns momentos os que morrerão de fome, quando um dove encontra um hawk ele tem a chance de não sobreviver e tudo mais, porém a reprodução deles ira cessar quando a população atingir seu limite baseado na quantidade de pares de comida existentes

Percebe que é um código em C no subfórum de Java né…

Enfim… tem casos em que eu mexo tanto no código, que às vezes eu prefiro apagar tudo e recomeçar do zero.
(Na realidade nunca é do zero: você sempre parte da experiência adquirida).

1 curtida

Ja reescrevi o codigo umas 10 vezes hoje, foi melhorando e ficando mais eficiente com o tempo, porém ainda falta adicionar dados importantes pra rodar do jeito que vi naquele vídeo, vou tentar reescrever e pensar numa melhor solução para ele amanhã, se eu conseguir alguma coisa posto o codigo aqui

Persistência é a chave de qualquer realização. O que é bom não vem fácil; e se veio fácil, desconfie.

Continue firme que você vai conseguir! Parabéns pela mentalidade de superação!

Talvez eu tenha exagerado um pouco e feito uma solução over-engineered, mas enfim, segue o link: https://repl.it/@hkotsubo/SimulacaoBlobs#Main.java

Coloquei alguns comentários no código, e não cheguei a testar casos muito complexos (fiz poucas rodadas com quantidades pequenas, só pra ver se o básico funcionava).

Obviamente, tem muita coisa pra melhorar lá, principalmente a formatação da saída, e provavelmente deve ter algumas situações que não cheguei a testar (não sei se as quantidades podem ficar negativas dependendo do caso, por exemplo).

2 curtidas

Já falei aqui no fórum, mas preciso repetir: você é o cara! :clap: :clap: :clap:

1 curtida

Então guys, tentei fazer a simulação nesta manhã e na teoria esta tudo de acordo com a lógica, no código porém os blobs vão morrer caso os putos os confrontem e roubem a comida apenas para facilitar o entendimento do código no inicio, porém a simulação apenas roda com poucas rodadas e blobs, e dá vários erros de array que até agora não consegui resolver, quem puder me apresentar estes bugs agradeço:

package simulação;
import java.util.ArrayList;

public class Simulação {

public static void main(String[] args) {

int mansos=5;
int putos = 5;
int num=8;
int parcomida[] = new int[num];
int prob; // Probabilidade de par de comida a ser encontrado
int prob1;
int rodadas=8;

 ArrayList lista = new ArrayList(); 
blobDAO blobs = new blobDAO();
blobs.setPopulacao(mansos+putos);
   

for(int i=0;i<num;i++){ //Setando vetor de pares como zeros, ou seja, livres de blobs
    parcomida[i]=0;
}

for(int i=0;i<putos;i++){ //Setando população inicial de putos
     lista.add(new Object[]{(lista.size()),"P",null});
    }

for(int i=0;i<mansos;i++){ //Setando população inicial de mansos
      lista.add(new Object[]{(lista.size()),"M",null});    
}

for (int i=0; i<lista.size(); i++) { //Verificando agenda inicial
  System.out.print(((Object[])lista.get(i))[0]+" - ");
  System.out.print(((Object[])lista.get(i))[1]+"\n");
}
   System.out.println("População inicial: "+blobs.getPopulacao());
   
   
   
   
   for(int i=0;i<rodadas;i++){ //Rodadas da simulação
    
    System.out.println("- - - - - - - - - - - - - - - - - Rodada"+(i+1)+"- - - - - - - - - - - - - - - - - ");
   
    for(int j=0;j<lista.size();j++){
    prob = (int) (Math.random() * num); // Randomizar vetores dos pares de comida
    prob1 = (int) (Math.random() * lista.size());  // Randomizar quais blobs vão para esses vetores
    
    if(parcomida[prob]<2){ //Caso o par de comida tenha 2 blobs, ele ira ignorar esta etapa
            
            if(((Object[])lista.get(prob1))[2] == null){ //Se o vetor do id for nulo ele vai em busca de um vetor
                
            System.out.println("ID "+prob1+" ENCONTROU VETOR: "+prob);
            
            ((Object[])lista.get(prob1))[2] = prob;
            
            System.out.println("Vetor definido para o id: "+prob1+" - "+((Object[])lista.get(prob1))[2]);
            
            parcomida[prob] +=1;
            }
        }
        } //Setando blobs - FINISH
    
    String tipo1 = null;
    String tipo2 = null;
    int id1 = 0;
    int id2 = 0;
    for(int com=0;com<num;com++){ //Verificando pares de comida
   
     if(parcomida[com]==2){ //Detectou conflito
         
         for(int pes=0;pes<lista.size();pes++){ //Checando dois tipos de conflito
             if(tipo1==null){
             if(((Object[])lista.get(pes))[2] == Integer.valueOf(com)){
              id1=pes;
              if(((Object[])lista.get(pes))[1] == "P"){
                 System.out.println("O conflito no vetor "+com+" foi gerado por um Puto");
                 tipo1="P";
              }else{
              tipo1="M";
              }
         }
         } //Checando primeiro tipo
             else if(tipo1!=null){
              if(((Object[])lista.get(pes))[2] == Integer.valueOf(com)){
              id2=pes;
              if(((Object[])lista.get(pes))[1] == "P"){
                 System.out.println("O conflito no vetor "+com+" foi gerado por um Puto");
                 tipo2="P";
              }else{
              tipo2="M";
              }
         }      
             } //Checando segundo tipo
             
         } //Fim da checagem
         
         //Definindo os conflitos
         
         if(tipo1=="M" && tipo2=="M"){
             System.out.println("MANSO VS MANSO");
         }
         
         else if(tipo1 == "P" && tipo2=="M"){
         System.out.println("PUTO VS MANSO");
         lista.add(new Object[]{(lista.size()),"P",null});
         lista.remove(id2);
         putos +=1;
         mansos -=1;
         }
         else if(tipo1 == "M" && tipo2=="P"){
         System.out.println("PUTO VS MANSO");
         lista.add(new Object[]{(lista.size()),"P",null});
         lista.remove(id1);
         putos +=1;
         mansos -=1;
         }
         else if(tipo1=="P" && tipo2=="P"){
             System.out.println("PUTO VS PUTO");
         lista.remove(id1);
         lista.remove(id2);
         putos-=2;    
         }     
    
     }
    //Fim da checagem de conflitos gerais
     else{
            
         for(int reproduz=0;reproduz<lista.size();reproduz++){ //Vai checar novamente a lista para verificar a raça do blob e reproduzi-lo
         if(((Object[])lista.get(reproduz))[2] == Integer.valueOf(com)){
             if( ((Object[])lista.get(reproduz))[1] == "P" ){
             putos+=1;
             lista.add(new Object[]{(lista.size()),"P",null});
             }
             else{
             mansos+=1;    
             lista.add(new Object[]{(lista.size()+1),"M",null});
           
             }
         }
         }

         
     }
     
    }//Fim da verificação de pares de comida
    
    blobs.setPopulacao(mansos+putos);
    System.out.println("Putos: "+putos+"\nMansos: "+mansos);
    System.out.println("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ");
        
    for(int m=0;m<num;m++){ //Setando vetor de pares como zeros, ou seja, livres de blobs
        parcomida[m]=0;
    }
    for(int m=0;m<lista.size();m++){ //Setando os vetores pegos como nulo
        ((Object[])lista.get(m))[2] = null;
    }  
    }
  for (int i=0; i<lista.size(); i++) { //Verificando agenda final
  System.out.print(((Object[])lista.get(i))[0]+" - ");
  System.out.print(((Object[])lista.get(i))[1]+" - ");
  System.out.print(((Object[])lista.get(i))[2]+"\n");
}
  System.out.println("Putos: "+putos+"\nMansos: "+mansos);
           
   }
}

Pensei em outra solução.

Na minha primeira solução eu me preocupei em criar as criaturas e alocá-las nos pares de comida, inclusive mantendo uma lista com todas elas, e adicionando e removendo elementos desta lista conforme a população mudava.

Mas se a ideia é apenas controlar as quantidades, acho que dá para ser mais simples.

Eu fiz um array de int para representar os pares de comida, e defini que um dove tem valor 1, e um hawk tem valor 3.

Ou seja, se a posição do array for zero, é porque ela está vazia (ninguém está comendo aquele par de comida). Se não estiver vazia, ela pode ter os seguintes valores:

  • 1, caso tenha 1 dove
  • 2, caso tenha 2 doves
  • 3, caso tenha 1 hawk
  • 4, caso tenha 1 hawk e 1 dove
  • 6, caso tenha 2 hawks (atenção, não é 5 porque um hawk vale 3)

Esses são os valores possíveis. Um ótimo efeito colateral é que se o valor for um número par e maior que zero, quer dizer que aquela posição está cheia (já tem 2 criaturas). E um valor ímpar quer dizer que a criatura está sozinha.

Assim, fica fácil espalhar as criaturas pelos pares de comida, e também verificar o que acontece com cada um:

Random rand = new Random();
// quantidade de pares de comida, e de cada um dos tipos
int qtdPairs = 5, qtdDoves = 2, qtdHawks = 2;

/*
 * Array com os pares de comida (dove=1, hawk=3):
 * 
 * Se o valor é zero, está vazio
 * Se for 1, tem um dove
 * Se for 2, tem 2 doves
 * Se for 3, tem um hawk
 * Se for 4, tem um hawk e um dove
 * Se for 6, tem 2 hawks (atenção, não é 5, porque um hawk vale 3)
 * 
 * Isso tem um ótimo "efeito colateral": se o número for par e maior que zero, é porque aquela posição está cheia
 */
int[] food = new int[qtdPairs];

int rodadas = 3;
for (int i = 1; i <= rodadas; i++) {
    System.out.println("-------- rodada " + i + " --------");
    // deixa os pares de comida vazios (sem nenhum blob)
    for (int j = 0; j < food.length; j++) {
        food[j] = 0;
    }

    // verifica se tem doves e hawks que ficarão sem comida (se tiver mais blobs que comida disponível)
    while (qtdDoves + qtdHawks > food.length * 2) {
        if (rand.nextInt(100) < 50) { //  50% de chance de morrer um dove
            if (qtdDoves > 0)
                qtdDoves--;
            else // mas se acabaram os doves, um hawk morre
                qtdHawks--;
        } else { // 50% de chance de morrer um hawk
            if (qtdHawks > 0)
                qtdHawks--;
            else // mas se acabaram os hawks, um dove morre
                qtdDoves--;
        }
    }
    // fim das mortes por fome

    // distribui os doves e hawks pelos pares de comida
    int doves = qtdDoves;
    int hawks = qtdHawks;
    while (doves + hawks > 0) {
        int pos;
        do {
            // procura uma posição vazia (não é muito eficiente se a população for muito próxima da qtd de comida, pois pode iterar
            // muitas vezes até achar uma posição vazia)
            pos = rand.nextInt(food.length);
        } while (food[pos] != 0 && food[pos] % 2 == 0);

        // preenche a posição
        if (doves == 0) { // não tem mais doves, preenche com hawk
            food[pos] += 3;
            hawks--;
        } else if (hawks == 0) { // se não tem mais hawks, prenche com dove
            food[pos] += 1;
            doves--;
        } else { // tem hawks e doves, escolhe um para prencher
            if (rand.nextInt(100) < 50) { // 50% de chance de escolher cada um
                food[pos] += 1;
                doves--;
            } else {
                food[pos] += 3;
                hawks--;
            }
        }
    }
    // fim da distribuição de comida

    // verifica o que aconteceu com cada par de comida
    for (int f : food) {
        if (f == 0) // vazio, nada acontece
            continue;

        if (f == 1) { // 1 dove sozinho, se reproduz
            System.out.println("Dove sozinho, se reproduz");
            qtdDoves++;
        } else if (f == 2) { // 2 doves, ambos sobrevivem
            System.out.println("2 doves, nada acontece");
        } else if (f == 3) { // 1 hawk sozinho, se reproduz
            System.out.println("Hawk sozinho, se reproduz");
            qtdHawks++;
        } else if (f == 4) { // 1 dove e 1 hawk
            System.out.print("1 hawk e 1 dove: ");
            if (rand.nextInt(100) < 50) { // hawk tem 50% de chance de se reproduzir
                System.out.print(" hawk se reproduz");
                qtdHawks++;
            }
            if (rand.nextInt(100) < 50) { // dove tem 50% de chance de morrer
                System.out.print(" dove morreu");
                qtdDoves--;
            }
            System.out.println();
        } else if (f == 6) { // 2 hawks, ambos morrem
            System.out.println("2 hawks se encontram, ambos morrem");
            qtdHawks -= 2;
        }
    }

    System.out.printf("doves: %d\nhawks: %d\n", qtdDoves, qtdHawks);
    if (qtdDoves + qtdHawks <= 0) {
        System.out.println("Todos morreram");
        break; // se todos morreram, não tem porque continuar
    }
}

Mano do céu tu é um gênio, quer dizer eu pensei nessa possibilidade de representar os blobs como um único valor, mas eu sou bem lerdo então pensei que seria apenas idiotice minha, muito obrigado mesmo por solucionar esse mistério!!!

Love you meu chapa
1 curtida