Problems with Casino Roulette

Question

My programming teacher asked us to do a casino roulette that had the option of playing American, European and French roulette.

But after some changes I made to the code when I type the name of the first player does not appear anything else, someone knows how to fix this?

import java.util.Scanner;
public class Jogo {

public static void main(String[]args){

    Scanner input = new Scanner(System.in);
    Jogador[] jogadores = new Jogador[2];

//--------------------------------------
    //-------PRENCHER O ARRAY--------
    for(int i=0; i < jogadores.length;i++){
        if(jogadores[i]== null){
            System.out.println("Deseja adicionar jogador? sim ou não");
            while(input.next().equals("sim")){
                System.out.println("Digite um nome");
                String nome = input.next();
                Jogador J = new Jogador(nome);
                jogadores[i] = J;

            }
        }
    }
    //----------SABER SE JOGADORES QUEREM APOSTAR OU NÃO------------
    for(int i=0; i < jogadores.length;i++){
        if(jogadores[i]!=null){
            System.out.println(jogadores[i].getNome()+ " Deseja apostar? sim ou não");
            if(input.next().equals("sim")){ // quer apostar
                apostar(jogadores[i]);                  
            }else 
                if(jogadores[i].getSemapostas()==3){
                    System.out.println("Você esta sem apostar a tres rodadas");
                    apostar(jogadores[i]);
                }else
                    jogadores[i].SemApostar();
        }
    }
    Rodar(jogadores);

}


//@overwarnigs(ressources);
    //----------APOSTAR--------------
    private static void apostar(Jogador J){

        Banca banc = new Banca();
        Scanner input = new Scanner(System.in);
        if(J.getFichas()>0){ //verificar fichas suficientes
            System.out.println("Apostar");
            System.out.println("--------");
            System.out.println("par ou impar\npreto ou vermelho\nnumero\nmaior ou menor");
            String aposta = input.next();
            J.setAposta(aposta);

            System.out.println("Insere o valor (número de fichas)");
            J.setFichasApostadas(input.nextInt());
            banc.ganharDoJogador(J.getFichasApostadas());
            if(J.getAposta().equals("numero")){
                System.out.println("Qual número deseja apostar?");
                J.setNumeroAposta(input.nextInt());
            }
        }
    }
    public static void Rodar(Jogador[] jogadores){
        Roleta rol = new Roleta();
        Banca banc = new Banca();
        rol.rodar();
        int numero = rol.getNumero();
        String cor = rol.getCor();
        for (int i =0;i<jogadores.length;i++){
            Jogador JG = jogadores[i];
//----------------------------------PAR------------------------------------------------
            if(JG.getAposta().equals("par")) // caso "PAR"

                    if((numero>0 && (numero%2)==0)){ // acertou
                        if(banc.getBudget()>= JG.getFichasApostadas()*2){// verifique o budget da banca (Suficiente)
                            banc.pagarJogador(JG.getFichasApostadas()*2);// Atualise o budget da banca
                            JG.ganharFichas(JG.getFichasApostadas()*2); //pagar jogador
                            System.out.println(JG.getNome());
                            System.out.println(numero);
                            System.out.println(JG.getNome() + " acertou");
                            System.out.println("saldo atual : " + JG.getFichas());
                        }else                               // verifique o budget da banca (Insuficiente)
                            System.out.println(JG.getNome() + " quebrou a banca");
                    }
                    else{                           //não acertou
                        System.out.println(JG.getNome());
                        System.out.println(numero);
                        System.out.println(JG.getNome() + " não acertou");
                        System.out.println("saldo atual : " + JG.getFichas());
                    }


//----------------------------------IMPAR------------------------------------------------
            if(JG.getAposta().equals("impar")) // caso "IMPAR"


                    if((numero>0 && (numero%2)==1)){ // acertou
                        if(banc.getBudget()>= JG.getFichasApostadas()*2){// verifique o budget do banco (Suficiente)
                            banc.pagarJogador(JG.getFichasApostadas()*2);// Atualise o budget do banco
                            JG.ganharFichas(JG.getFichasApostadas()*2); //paga jogador
                            System.out.println(JG.getNome());
                            System.out.println(numero);
                            System.out.println(JG.getNome() +" acertou");
                            System.out.println("saldo atual : " + JG.getFichas());
                        }else                               // verifique o budget do banco (Insuficiente)
                            System.out.println(JG.getNome() + " deixou a banca pobre");
                    }
                    else{                           //não acertou
                        System.out.println(JG.getNome());
                        System.out.println(numero);
                        System.out.println(JG.getNome() +" não acertou");
                        System.out.println("saldo atual : " + JG.getFichas());
                    }


//----------------------------------VERMELHO------------------------------------------------
            if(JG.getAposta().equals("vermelho")) // caso "VERMELHO"

                    if(cor.equals("vermelho")){ // acertou
                        if(banc.getBudget()>= JG.getFichasApostadas()*2){// verifique o budget do banco (Suficiente)
                            banc.pagarJogador(JG.getFichasApostadas()*2);// Atualise o budget do banco
                            JG.ganharFichas(JG.getFichasApostadas()*2); //paga joador
                            System.out.println(JG.getNome());
                            System.out.println(numero + " "+cor);
                            System.out.println(JG.getNome() + " acertou");
                            System.out.println("-------------------------");
                            System.out.println("saldo atual : " + JG.getFichas());
                        }else                               // verifique o budget do banco (Insuficiente)
                            System.out.println(JG.getNome() + " deixou a banca pobre");

                    }
                    else{                           //não acertou
                        banc.ganharDoJogador(JG.getFichasApostadas());
                        System.out.println(JG.getNome());
                        System.out.println(numero + " "+cor);
                        System.out.println(JG.getNome() +" não acertou");
                        System.out.println("-------------------------");
                        System.out.println("saldo atual : " + JG.getFichas());
                    }

//----------------------------------PRETO------------------------------------------------
            if(JG.getAposta().equals("preto")) // caso "PRETO"

                    if(cor.equals("preto")){ // acertou
                        if(banc.getBudget()>= JG.getFichasApostadas()*2){// verifique o budget do banco (Suficiente)
                            banc.pagarJogador(JG.getFichasApostadas()*2);// Atualise o budget do banco
                            JG.ganharFichas(JG.getFichasApostadas()*2); //paga joador
                            System.out.println(JG.getNome());
                            System.out.println(numero + " "+cor);
                            System.out.println(JG.getNome() +" acertou");
                            System.out.println("-------------------------");
                            System.out.println("saldo atual : " + JG.getFichas());
                        }else                               // verifique o budget do banco (Insuficiente)
                            System.out.println(JG.getNome() +" deixou a banca pobre");

                    }
                    else{                           //não acertou
                        banc.ganharDoJogador(JG.getFichasApostadas());
                        System.out.println(JG.getNome());
                        System.out.println(numero + " "+cor);
                        System.out.println(JG.getNome() +" não acertou");
                        System.out.println("-------------------------");
                        System.out.println("saldo atual : " + JG.getFichas());
                    }


//----------------------------MENOR------------------------
            if(JG.getAposta().equals("menor")) // caso "MENOR"

                if(numero>= 1 && numero<19){ // acertou
                    if(banc.getBudget()>= JG.getFichasApostadas()*2){// verifique o budget do banco (Suficiente)
                        banc.pagarJogador(JG.getFichasApostadas()*2);// Atualise o budget do banco
                        JG.ganharFichas(JG.getFichasApostadas()*2); //paga joador
                        System.out.println(JG.getNome());
                        System.out.println(numero);
                        System.out.println(JG.getNome() +" acertou");
                        System.out.println("-------------------------");
                        System.out.println("saldo atual : " + JG.getFichas());
                    }
                    else                                // verifique o budget do banco (Insuficiente)
                        System.out.println(JG.getNome() + " deixou a banca pobre");

                }
                else{                           //não acertou
                    banc.ganharDoJogador(JG.getFichasApostadas());
                    System.out.println(JG.getNome());
                    System.out.println(numero);
                    System.out.println(JG.getNome() +" não acertou");
                    System.out.println("-------------------------");
                    System.out.println("saldo atual : " + JG.getFichas());
                }

//----------------------------MAIOR------------------------
            if(JG.getAposta().equals("maior")) // caso "MAIOR"

                if(numero>= 19 && numero<37){ // acertou
                    if(banc.getBudget()>= JG.getFichasApostadas()*2){// verifique o budget do banco (Suficiente)
                        banc.pagarJogador(JG.getFichasApostadas()*2);// Atualise o budget do banco
                        JG.ganharFichas(JG.getFichasApostadas()*2); //paga joador
                        System.out.println(JG.getNome());
                        System.out.println(numero);
                        System.out.println(JG.getNome() +" acertou");
                        System.out.println("-------------------------");
                        System.out.println("saldo atual : " + JG.getFichas());
                    }
                    else                                // verifique o budget do banco (Insuficiente)
                        System.out.println(JG.getNome() +" deixou a banca pobre");

                }
                else{                           //não acertou
                    banc.ganharDoJogador(JG.getFichasApostadas());
                    System.out.println(JG.getNome());
                    System.out.println(numero);
                    System.out.println(JG.getNome() +" não acertou");
                    System.out.println("-------------------------");
                    System.out.println("saldo atual : " + JG.getFichas());
                }

//----------------------------NUMERO--------------------------------------
            if(JG.getAposta().equals("numero")) // caso "NUMERO"

                if(numero == JG.getNumeroAposta()){ // acertou
                    if(banc.getBudget()>= JG.getFichasApostadas()*36){// verifique o budget do banco (Suficiente)
                        banc.pagarJogador(JG.getFichasApostadas()*36);// Atualise o budget do banco
                        JG.ganharFichas(JG.getFichasApostadas()*36); //paga joador

                        System.out.println(JG.getNome());
                        System.out.println(numero);
                        System.out.println(JG.getNome() +" acertou");
                        System.out.println("-------------------------");
                        System.out.println("saldo atual : " + JG.getFichas());
                    }
                    else                                // verifique o budget do banco (Insuficiente)
                        System.out.println(JG.getNome() +" deixou a banca pobre");

                }//fim do if num
                else{                           //não acertou
                    banc.ganharDoJogador(JG.getFichasApostadas());
                    System.out.println(JG.getNome());
                    System.out.println(numero);
                    System.out.println(JG.getNome() +" não acertou");
                    System.out.println("-------------------------");
                    System.out.println("saldo atual : " + JG.getFichas());
                }   //fim do else de numero
        }
    }
 }

Answer 1

Understanding your problem

Let’s see that stretch:

    for(int i=0; i < jogadores.length;i++){
        if(jogadores[i]== null){
            System.out.println("Deseja adicionar jogador? sim ou não");
            while(input.next().equals("sim")){
                System.out.println("Digite um nome");
                String nome = input.next();
                Jogador J = new Jogador(nome);
                jogadores[i] = J;

            }
        }
    }

First, that at that point the if always true. Soon it is unnecessary.

Notice that we have a while within a for. The for traverse the player array. Already the while does what? Fills the same player several times. It should not be what you want. So I recommend that the code was this:

    out: for (int i = 0; i < jogadores.length; i++) {
        boolean adicionar = lerBoolean(
                input,
                "Deseja adicionar jogador? sim ou não",
                "Não entendi. Vamos tentar novamente.");
        if (!adicionar) break;
        System.out.println("Digite um nome");
        String nome = input.next();
        jogadores[i] = new Jogador(nome);
    }

That method lerBoolean would be so:

    public static boolean lerBoolean(String mensagem, String naoEntendi) {
        while (true) {
            System.out.println(mensagem);
            String resposta = input.next().toUpperCase().trim();
            if (resposta.startsWith("S")) return true;
            if (resposta.startsWith("N")) return false;
            System.out.println(naoEntendi);
        }
    }

Other possible code improvements

In order not to be limited to the number 2 players, I suggest changing this:

Jogador[] jogadores = new Jogador[2];

That’s why:

List<Jogador> jogadores = new ArrayList<>();

And then the code of the bow goes like this:

   while (true) {
        boolean adicionar = lerBoolean(
                input,
                "Deseja adicionar jogador? sim ou não",
                "Não entendi. Vamos tentar novamente.");
        if (!adicionar) break;
        System.out.println("Digite um nome");
        String nome = input.next();
        jogadores.add(new Jogador(nome));
    }

This also eliminates the variable i, allows you to have any amount of players and free you from the need to check if there are any null somewhere in the array. The second loop could then be simplified to this:

for (Jogador j : jogadores) {
    boolean aceita = lerBoolean(
                input,
                j.getNome() + " Deseja apostar? sim ou não",
                "Não entendi. Vamos tentar novamente.");
    if (aceita) {
        apostar(j);
    } else if (j.getSemapostas() == 3) {
        System.out.println("Você está sem apostar há três rodadas.");
        apostar(j);
    } else {
        j.SemApostar();
    }
}

You can best this by putting the method apostar within the class Jogador, after all who performs the after is the player, and therefore the method is his. With this apostar(j); becomes j.apostar();. I also suggest renaming the method getSemapostas for getSemApostas, SemApostar for semApostar and Rodar for rodar, because the convention states that the initial of each word (except the first) in the method name should be capitalized.

This can also be optimized in another way: If the player has already been three rounds without betting, then you don’t even have to ask whether or not he wants to bet because he is forced to do so:

for (Jogador j : jogadores) {
    if (j.semApostas() == 3) {
        System.out.println("Você está sem apostar há três rodadas.");
        apostar(j);
    } else {
        boolean aceita = lerBoolean(
                input,
                j.getNome() + " Deseja apostar? sim ou não",
                "Não entendi. Vamos tentar novamente.");
        if (aceita) {
            apostar(j);
        } else {
            j.SemApostar();
        }
    }
}

Incidentally, it would be interesting to put this as a separate method fazerApostas. I’m going to approach this further below.

In the method Rodar, that tie:

    for (int i =0;i<jogadores.length;i++){
        Jogador JG = jogadores[i];

Stay like this:

    for (Jogador jg : jogadores) {

However, the method apostar(Jogador) has problems too. Both the method main as to the apostar(Jogador) are creating Scanners different and you should only have one Scanner. The method apostar is also creating a Banca instead of using an existing one and another bankroll is being used in the method Rodar. Accordingly, the Banca and the input should be created in the main and passed on to both methods.

Copying and pasting code is one of the worst existing programming practices. Avoid doing it the most. In your method Rodar there is the following code copied and pasted a lot of times:

                if(<alguma condição>){ // acertou
                    if(banc.getBudget()>= JG.getFichasApostadas()*2){// verifique o budget do banco (Suficiente)
                        banc.pagarJogador(JG.getFichasApostadas()*2);// Atualise o budget do banco
                        JG.ganharFichas(JG.getFichasApostadas()*2); //paga joador
                        System.out.println(JG.getNome());
                        System.out.println(numero + " "+cor);
                        System.out.println(JG.getNome() + " acertou");
                        System.out.println("-------------------------");
                        System.out.println("saldo atual : " + JG.getFichas());
                    }else                               // verifique o budget do banco (Insuficiente)
                        System.out.println(JG.getNome() + " deixou a banca pobre");

                }
                else{                           //não acertou
                    banc.ganharDoJogador(JG.getFichasApostadas());
                    System.out.println(JG.getNome());
                    System.out.println(numero + " "+cor);
                    System.out.println(JG.getNome() +" não acertou");
                    System.out.println("-------------------------");
                    System.out.println("saldo atual : " + JG.getFichas());
                }

We can restructure this method by recording the condition of if in a variable and then make this logic only later (paying attention to the fact that the multiplication factor can be 2 or 36, depending on the case). Almost all the content of this method Rodar can be fully moved to the class Banca:

public void pagar(Roleta r, Jogador j) {
    System.out.println(j.getNome());
    int numero = r.getNumero();
    String cor = r.getCor();
    System.out.println(numero + " " + cor);
    String apostado = j.getAposta();
    boolean cond
            = apostado.equals("par") ? numero > 0 && numero % 2 == 0
            : apostado.equals("impar") ? numero > 0 && numero % 2 == 1
            : apostado.equals("vermelho") ? cor.equals("vermelho")
            : apostado.equals("preto") ? cor.equals("preto")
            : apostado.equals("menor") ? numero >= 1 && numero <= 18
            : apostado.equals("maior") ? numero >= 19 && numero <= 36
            : apostado.equals("numero") ? numero == j.getNumeroAposta();
    boolean fator = apostado.equals("numero") ? 36 : 2;

    int aposta = j.getFichasApostadas();
    int premio = aposta * fator;
    int budget = getBudget();
    if (premio > budget) premio = budget;

    if (!cond) {
        ganharDoJogador(aposta);
        System.out.println(j.getNome() + " não acertou");
    } else if (getBudget() >= premio) {
        pagarJogador(premio);
        j.ganharFichas(premio);
        System.out.println(j.getNome() + " acertou");
        if (premio == budget) System.out.println(j.getNome() + " deixou a banca pobre.");
    }

    System.out.println("-------------------------");
    System.out.println("Saldo atual: " + j.getFichas());
}

In your class Jogo, that would remain in the method rodar:

public static void rodar(Roleta r, Banca b, List<Jogador> jogadores) {
    r.rodar();
    for (Jogador j : jogadores) {
        b.pagar(r, j);
    }
}

Note that I have put the roulette and the bankroll as parameters, after all, you may want to do several rounds with the same players, the same bankroll and the same roulette. In fact, this suggests that these are the attributes of Jogo (and this method would be of instance), and therefore its class Jogo stays in its final form as it is below:

As it turns out

public class Jogo {
    private final List<Jogador> jogadores;
    private final Roleta roleta;
    private final Banca banca;
    private final Entrada entrada;

    public Jogo(List<Jogador> jogadores) {
        this.jogadores = jogadores;
        this.roleta = new Roleta();
        this.banca = new Banca();
        this.entrada = new Entrada();
    }

    public static void main(String[] args) {
        List<Jogador> jogadores = new ArrayList<>();

        while (true) {
            boolean adicionar = entrada.lerBoolean(
                    "Deseja adicionar jogador? sim ou não",
                    "Não entendi. Vamos tentar novamente.");
            if (!adicionar) break;
            String nome = entrada.lerString("Digite um nome");
            jogadores.add(new Jogador(nome));
        }
        Jogo j = new Jogo(jogadores);
        j.jogar();
    }

    private void fazerApostas() {
        for (Jogador j : jogadores) {
            if (j.semApostas() == 3) {
                System.out.println("Você está sem apostar há três rodadas.");
                j.apostar(entrada, banca);
            } else {
                boolean aceita = entrada.lerBoolean(
                        j.getNome() + " Deseja apostar? sim ou não",
                        "Não entendi. Vamos tentar novamente.");
                if (aceita) {
                    j.apostar(entrada, banca);
                } else {
                    j.semApostar();
                }
            }
        }
    }

    public void jogar() {
        rodar();
    }

    public void rodar() {
        fazerApostas();
        roleta.rodar();
        for (Jogador j : jogadores) {
            banca.pagar(roleta, j);
        }
    }
}

Use the strings "pair", "odd", "red", etc. to denote the bet type is a bag. Use enums and note that it already encapsulates the logic to determine whether or not the roulette number is accepted:

public enum Cor {
    VERMELHO, PRETO;
}

public enum TipoAposta implements Regra {
    PAR((n, c, a) -> n > 0 && n % 2 == 0),
    IMPAR((n, c, a) -> n > 0 && n % 2 == 1),
    VERMELHO((n, c, a) -> c == Cor.VERMELHO),
    PRETO((n, c, a) -> c == Cor.PRETO),
    MENOR((n, c, a) -> n >= 1 && n <= 18),
    MAIOR((n, c, a) -> n >= 19 && n <= 36),
    NUMERO((n, c, a) -> n == a);

    private final Regra regra;

    private TipoAposta(Regra regra) {
        this.regra = regra;
    }

    @Override
    public boolean validar(int numero, Cor cor, int apostado) {
        return regra.validar(numero, cor, apostado);
    }

    public int getFator() {
        return this == NUMERO ? 36 : 2;
    }
}

public interface Regra {
    public boolean validar(int numero, Cor cor, int apostado);
}

With this, the method pagar class Banca gets like this:

public void pagar(Roleta r, Jogador j) {
    System.out.println(j.getNome());
    int numero = r.getNumero();
    Cor cor = r.getCor();
    System.out.println(numero + " " + cor);
    TipoAposta apostado = j.getAposta();
    boolean cond = apostado.validar(numero, cor, j.getNumeroAposta());
    int aposta = j.getFichasApostadas();
    int premio = aposta * apostado.getFator();
    int budget = getBudget();
    if (premio > budget) premio = budget;

    if (!cond) {
        ganharDoJogador(aposta);
        System.out.println(j.getNome() + " não acertou.");
    } else if (getBudget() >= premio) {
        pagarJogador(premio);
        j.ganharFichas(premio);
        System.out.println(j.getNome() + " acertou.");
        if (premio == budget) System.out.println(j.getNome() + " deixou a banca pobre.");
    }

    System.out.println("-------------------------");
    System.out.println("Saldo atual: " + j.getFichas());
}

The type of attribute cor in class Roleta becomes Cor instead of String. The type of attribute aposta in class Jogador becomes TipoAposta instead of String. The respective getters and setters also change in the same way.

We also take advantage to centralize all data reading operations in one class Entrada:

public class Entrada {

    private final Scanner input;

    public Entrada() {
        this.input = new Scanner(System.in);
    }

    public String lerString(String mensagem) {
        System.out.println(mensagem);
        return input.next();
    }

    public int lerInt(String mensagem) {
        System.out.println(mensagem);
        return input.nextInt();
    }

    public boolean lerBoolean(String mensagem, String naoEntendi) {
        while (true) {
            System.out.println(mensagem);
            String resposta = input.next().toUpperCase().trim();
            if (resposta.startsWith("S")) return true;
            if (resposta.startsWith("N")) return false;
            System.out.println(naoEntendi);
        }
    }

    public TipoCor lerTipo(String mensagem, String naoEntendi) {
        List<String> opcoes = Arrays.asList(escolhas);
        while (true) {
            System.out.println(mensagem);
            String resposta = input.next().toUpperCase().trim();
            try {
                return TipoCor.valueOf(resposta);
            } catch (IllegalArgumentException) {
                System.out.println(naoEntendi);
            }
        }
    }
}

In class Jogador, the method apostar gets like this:

public void apostar(Entrada entrada, Banca b) {
    if (getFichas() == 0) {
        System.out.println("Você não tem fichas!");
        semApostar();
        return;
    }
    System.out.println("Apostar");
    System.out.println("--------");
    String msg = "Par ou impar\nPreto ou vermelho\nNumero\nMaior ou Menor";
    TipoAposta aposta = entrada.lerTipo(msg, "Não entendi. Vamos tentar novamente.");
    setAposta(aposta);

    System.out.println("Insire o valor (número de fichas): ");
    int fichas = entrada.lerInt();
    setFichasApostadas(fichas);
    b.ganharDoJogador(fichas);
    if (aposta == TipoAposta.NUMERO) {
        System.out.println("Qual número deseja apostar?");
        setNumeroAposta(entrada.lerInt());
    }
}

It should be possible to do a lot more simplifications and improvements, but you did not give the code Banca, Roleta and Jogador for that reason.

Note that in the class Jogo I put a method jogar that for now just calls rodar. In this method you will make the logic to perform several rounds until all players except one are out of chips.

Answer 2

I don’t know if it will help, but I would do the code like this: So you’re sure it will fall into the loop at least.

 String option;
        do{
            System.out.println("Deseja adicionar jogador? sim ou não");
            option = input.next();
            if (option.equals("sim")){
                System.out.println("Digite um nome");
                String nome = input.next();
                Jogador J = new Jogador(nome);
                jogadores[i] = J;
            }
        }while(option.equals("sim"));