POO - Onde está o erro?

Marcos Ivo Peruzzo · 15 de maio de 2017

To aprendendo POO na faculdade e fiz esse Mini UFC para brincar, só que tem algo errado na CLASSE LUTA (eu acho). porque sempre quem está vencendo a luta é o Desafiante.

Sempre quem está vencendo é o Desafiante. Alguma ideia de onde possa estar errado? Eles tem uma vida, e quando chegar a 0 por meio de socos anuncia o vencedor.

------------------------------------- classe lutador -------------------------------------------------------------------------

public class Lutador {
// ATRIBUTOS
 private String nome;
 private String nacionalidade;
 private int idade;
 private float altura;
 private float peso;
 private String categoria;
 private int vitorias;
 private int derrotas;
 private int empates;
 private int vida;
 private char sexo;
 
 public int getVida() {
  return vida;
 }

 public void setVida(int vida) {
  this.vida = vida;
 }

 public void apresentar(){
  System.out.println("------------------------------------------------------------");
  System.out.println("CHEGOU A HORA! Apresentamos o lutador: " + this.getNome());
  System.out.println("Diretamente de: " + this.getNacionalidade());
  System.out.println("com " + this.getIdade() + " anos e " + this.getAltura() + " metros de altura");
  System.out.println("pesando " + this.getPeso() + "Kg");
  System.out.println("Ganhou: " + this.getVitorias());
  System.out.println("Perdeu: " + this.getDerrotas());
  System.out.println("Empatou:" + this.getEmpates());
 }
 
 public void status(){
  System.out.println("----------------------------");
  System.out.println(this.getNome() + " é um peso " + this.getCategoria());
  System.out.println("Ganhou " + this.getVitorias() + " Vezes");
  System.out.println("Perdeu " + this.getDerrotas() + " Vezes");
  System.out.println("Empatou " + this.getEmpates() + " Vezes");
  System.out.println("Vida " + this.getVida());
 }
 
 public void ganharLuta(){
  this.setVitorias(this.getVitorias() + 1);  
 }
 
 public void perderLuta(){
  this.setDerrotas(this.getDerrotas() + 1);
 }
 
 public void empatarLuta(){
  this.setEmpates(this.getEmpates() + 1);
 }
 
 public Lutador(String no, String na, int id, float al, float pe, int vi, int de,
   int em,int vid, char sex) {
  super();
  this.nome = no;
  this.nacionalidade = na;
  this.idade = id;
  this.altura = al;
  this.setPeso(pe);
  this.vitorias = vi;
  this.derrotas = de;
  this.empates = em;
  this.vida = vid;
  this.sexo = sex;
 }

 public String getNome() {
  return nome;
 }
 public void setNome(String no) {
  this.nome = no;
 }
 public String getNacionalidade() {
  return nacionalidade;
 }
 public void setNacionalidade(String nacionalidade) {
  this.nacionalidade = nacionalidade;
 }
 public int getIdade() {
  return idade;
 }
 public void setIdade(int idade) {
  this.idade = idade;
 }
 public double getAltura() {
  return altura;
 }
 public void setAltura(float altura) {
  this.altura = altura;
 }
 public double getPeso() {
  return peso;
 }
 public void setPeso(float pe) {
  this.peso = pe;
  setCategoria();
 } 
 private void setCategoria(){
  if (this.peso<52.2){
   this.categoria = "Inválido";
  } else if (this.peso<=70.3){
   this.categoria = "Leve";
  } else if (this.peso<=83.9){
   this.categoria = "Médio";   
  } else if (this.peso <= 120.2){
   this.categoria = "Pesado";
  } else {
   this.categoria = "Inválido";
  } 
 }
 public String getCategoria() {
  return categoria;
 }
 public void setCategoria(String categoria) {
  this.categoria = categoria;
 }
 public int getVitorias() {
  return vitorias;
 }
 public void setVitorias(int vitorias) {
  this.vitorias = vitorias;
 }
 public int getDerrotas() {
  return derrotas;
 }
 public void setDerrotas(int derrotas) {
  this.derrotas = derrotas;
 }
 public int getEmpates() {
  return empates;
 }
 public void setEmpates(int empates) {
  this.empates = empates;
 }
 
 public void ReceberJab() {
        this.setVida(this.getVida() - 1);
    }
    
    public void ReceberUpper() {
        this.setVida(this.getVida() - 2);
    }
 
 public void ReceberDireto(){
  this.setVida(this.getVida() - 3);
 }
 
 public void ReceberCruzado(){
  this.setVida(this.getVida() - 2);
 }

 public char getSexo() {
  return sexo;
 }

 public void setSexo(char sexo) {
  this.sexo = sexo;
 }
 
}

---------------------------------------------------------CLASSE LUTA -------------------------------------------------------------------------------------------------------------------
import java.util.Random;

public class Luta {
 private Lutador desafiado;
 private Lutador desafiante;
 private int rounds;
 private boolean aprovada;
 
 public void marcarLuta(Lutador l1, Lutador l2){
  if(l1.getCategoria() == l2.getCategoria() && l1 != l2 && l1.getSexo() == l2.getSexo()){
   this.aprovada = true;
   this.desafiado = l1;
   this.desafiante = l2;
   System.out.println(" ### LUTA MARCADA ###\n");
  } else {
   this.aprovada = false;
   this.desafiado = null;
   this.desafiante = null;
  }  
 }
 
 public void lutar(Lutador l1, Lutador l2){
  if (this.aprovada){
   System.out.println("QUE COMECE A LUTA ENTRE " + this.getDesafiado().getNome()+ " Desafiado " + "E " + this.getDesafiante().getNome()+ " Desafiante" + "\n");
   
   while ((l1.getVida() > 0) && (l2.getVida() > 0)) {
    Random aleatorio = new Random();
    int vencedor = aleatorio.nextInt(7);
             switch (vencedor) {
                 case 0:
                     this.desafiado.ReceberJab();
                     System.out.println("----------------------------------------------------------------");
                     System.out.println(l1.getNome() + " Tomou um Jab e perdeu - 1 de vida, ficando com " + l1.getVida());
                     break;                    
                 case 1:
                     this.desafiante.ReceberJab();
                     System.out.println("----------------------------------------------------------------");
                     System.out.println(l2.getNome() + " Tomou um Jab e perdeu - 1 de vida, ficando com " + l2.getVida());
                     break;                 
                 case 2:
                     this.desafiado.ReceberDireto();
                     System.out.println("----------------------------------------------------------------");
                     System.out.println(l1.getNome() + " Tomou um Direto e perdeu - 3 de vida, ficando com " + l1.getVida());
                     break;
                 case 3:
                     this.desafiante.ReceberDireto();
                     System.out.println("----------------------------------------------------------------");
                     System.out.println(l2.getNome() + " Tomou um Direto e perdeu - 3 de vida, ficando com " + l2.getVida());
                 case 4:
                  this.desafiado.ReceberCruzado();
                     System.out.println("----------------------------------------------------------------");
                     System.out.println(l1.getNome() + " Tomou um Cruzado e perdeu - 2 de vida, ficando com " + l1.getVida());
                  break;
                 case 5:
                  this.desafiante.ReceberCruzado();
                     System.out.println("----------------------------------------------------------------");
                     System.out.println(l2.getNome() + " Tomou um Cruzado e perdeu - 2 de vida, ficando com " + l2.getVida());
                  break;
                 case 6:
                  this.desafiado.ReceberUpper();
                     System.out.println("----------------------------------------------------------------");
                     System.out.println(l1.getNome() + " Tomou um Upper e perdeu - 2 de vida, ficando com " + l1.getVida());
                  break;
                 case 7:
                  this.desafiante.ReceberUpper();
                     System.out.println("----------------------------------------------------------------");
                     System.out.println(l2.getNome() + " Tomou um Upper e perdeu - 2 de vida, ficando com " + l2.getVida());
                  break;
             }
         }
             
             if (l1.getVida() <= 0) {
                 l2.ganharLuta();
                 l1.perderLuta();
                 System.out.println("----------------------------------------------------------------");
                 System.out.println("");
                 System.out.println(l2.getNome() + " Venceu!");
                 System.out.println("----------------------------------------------------------------");
             } else if (l2.getVida() <= 0) {
                 l2.perderLuta();
                 l1.ganharLuta();
                 System.out.println("----------------------------------------------------------------");
                 System.out.println("");
                 System.out.println(l1.getNome()+ " Venceu!");
                 System.out.println("----------------------------------------------------------------");
             }
             
     } else {
             System.out.println("Luta não pode acontecer");
             }
         
     }

 public Lutador getDesafiado() {
  return desafiado;
 }

 public void setDesafiado(Lutador desafiado) {
  this.desafiado = desafiado;
 }

 public Lutador getDesafiante() {
  return desafiante;
 }

 public void setDesafiante(Lutador desafiante) {
  this.desafiante = desafiante;
 }

 public int getRounds() {
  return rounds;
 }

 public void setRounds(int rounds) {
  this.rounds = rounds;
 }

 public boolean isAprovada() {
  return aprovada;
 }

 public void setAprovada(boolean aprovada) {
  this.aprovada = aprovada;
 } 
}

--------------------------------------------------------------CLASSE PRINCIPAL -------------------------------------------------------------------------------------------------------------

public class UltraEmojiCombat {

 public static void main(String[] args) {

  Lutador l[] = new Lutador [6];
   l[0] = new Lutador("Pretty Boy", "França", 31, 1.75f, 68.9f, 11, 2, 1,50,'M');
   l[1] = new Lutador ("Putscript", "Brasil", 29, 1.68f, 57.8f, 14, 2, 3,50,'M');
   l[2] = new Lutador ("Snapshadow", "EUA", 35, 1.65f, 80.9f, 12,2,1,50,'M');
   l[3] = new Lutador ("Dead Code", "Austrália", 28, 1.93f, 81.6f,13,0,3,50,'M');
   l[4] = new Lutador ("UFOCobol", "Brasil", 37,1.70f,119.3f,5,4,3,50,'M');
   l[5] = new Lutador("Nerdaart", "EUA", 30,1.81f,105.7f,12,2,4,50,'M');
   
   
  
  
   Luta UEC01 = new Luta();
   UEC01.marcarLuta(l[0], l[1]);
   UEC01.lutar(l[0], l[1]);
   l[0].status();
   l[1].status();
   
   //l[0].apresentar();
  //l[0].status();
  //l[3].apresentar();
  //l[3].status();
  
  
 }

}

Alex Temnyk · 15 de maio de 2017

@Marcos Ivo Peruzzo Gostei da ideia, ficou bem bacana.
Não tive tempo de ler tudo, depois faço alguns testes, já verificou seu método aleatório ?

Marcos Ivo Peruzzo · 15 de maio de 2017

@Alex Temnyk Eu não entendi muito bem esse método aleatório, então não consegui fazer muita coisa, mexi no while no switch, mas não resolveu nada.

adicionado 7 minutos depois

Achei o erro. Acrecentei + 1 na linha int vencedor...

while ((l1.getVida() > 0) && (l2.getVida() > 0)) {
Random aleatorio = new Random();
int vencedor = aleatorio.nextInt(7) + 1;

Procurei na internet

Dica 1: suponha que você precise gerar um número aleatório entre 1 e 6 (ex: para simular um jogo de dados). Se você simplesmente usar o método nextInt(6), obterá números entre 0 e 5, algo que você não deseja. Resolver a situação é simples, bastando aplicar o seguinte recurso: int numDado = gerador.nextInt(6) + 1.

Alex Temnyk · 16 de maio de 2017

@Marcos Ivo Peruzzo hahahahha. testei aqui, ficou super divertido, parabéns, mas percebeu que só acha o Pretty Boy x Putscript?
Poderia colocar um math.random na hora de .marcarLuta

Marcos Ivo Peruzzo · 18 de maio de 2017

@Alex Temnyk Sim, para que outros lutem tem que mudar manualmente

Ex:

UEC01.marcarLuta(l[2], l[3]);

UEC01.lutar(l[2], l[3]);

Em 2017-5-16 às 16:48, Alex Temnyk disse:

Poderia colocar um math.random na hora de .marcarLuta

Boa ideia, vou tentar colocar.

Alex Temnyk · 18 de maio de 2017

@Marcos Ivo Peruzzo pensei na possibilidade de você criar 2 variáreis, e um método que atribuisse o random nessas variáreis, algo como A = l[math.random] .... Assim toda vez que "jogasse" outra vez, mudaria tudo. Na parte de programação é só declarar o random pra A e B e mudar a chamada dos arrays depois.

UEC01.marcarLuta(l[ A ], l[ B ]);

UEC01.lutar(l[ A ], l[ B ]);