3. Histórico de Vitórias e Derrotas – Implementação do Ranking

Para incrementar ainda mais o nosso jogo, vamos inserir um ranking, onde poderemos visualizar a quantidade de vitórias e derrotas de cada jogador que foi cadastrado.

Para implementar essa funcionalidade, precisamos encontrar uma maneira de armazenar a quantidade de vitórias e derrotas de cada jogador. Para isso, temos que declarar duas variáveis do tipo “int” (uma para armazenar a quantidade de vitórias e outra para armazenar a de derrotas) e associá-las ao nome do jogador. Como fazemos isso? Utilizando um registro.

Veja o seguinte código, que declara uma classe para representar o registro a ser criado:

public class Jogador { 

    public String nome; 

    public int vitorias; 

    public int derrotas;

}

Muito bem, agora precisamos indicar ao nosso código a forma com que essas informações serão acessadas para adicionar, a cada partida, os nomes e quantidades de vitórias e derrotas ao arquivo que criamos. Para isso, primeiro temos que fazer algumas alterações no código. A primeira delas será a de informar que utilizaremos o tipo de dados registro chamado de Jogador.

Faremos isso substituindo os dados que tínhamos anteriormente (só o nome) pelo registro. Dessa forma, trocamos a definição existente das seguintes variáveis:

private static String jogador1, jogador2;

pelas seguintes declarações:

private static Jogador jogador1, jogador2;

Essa alteração indica que queremos não só usar o nome dos jogadores (tipo String), mas todos os demais dados (quantidade de vitórias e de derrotas). Se você fizer essa alteração em seu código, você irá notar que ela irá gerar vários erros de compilação no código, mais especificamente na função cadastro(). Isso porque mudamos o tipo de dados das variáveis jogador1 e jogador2. Para corrigir esses problemas, basta substituir o código anterior da função cadastro.

public static void cadastro() { 

    System.out.println("Digite o nome do jogador 1:"); 

    //recebe nome do jogador 1 

    jogador1 = leitor.next(); 

    System.out.println("Digite o nome do jogador 2:"); 

    //recebe nome do jogador 2 

    jogador2 = leitor.next(); 

}

pelo seguinte código:

public static void cadastro() { 

    System.out.println("Digite o nome do jogador 1:"); 

    //recebe nome do jogador 1 

    String nome_jogador1 = leitor.next(); 

    jogador1 = buscarJogador(nome_jogador1); 

    System.out.println("Digite o nome do jogador 2:"); 

    //recebe nome do jogador 2 

    String nome_jogador2 = leitor.next(); 

    jogador2 = buscarJogador(nome_jogador2); 

}

Como você pode notar, agora criamos duas variáveis locais (nome_jogador1 e nome_jogador2) do tipo String para receber o nome dos jogadores 1 e 2. Em seguida, a cada leitura de nome, inicializamos os registros jogador1 e jogador2, de acordo com os nomes lidos. Nesse caso, precisamos verificar se esses jogadores já jogaram o jogo da velha e, se for esse o caso, precisamos recuperar os dados históricos das partidas deles (quantidades de vitórias e de derrotas). Esse é o objetivo da função buscarJogador(), o qual será mostrado mais adiante.

Além dessas modificações, precisamos trocar também o uso de jogador1 e jogador2 por jogador1.nome e jogador2.nome, respectivamente, como no caso de

System.out.println("Jogador " + jogador1 + " é o ganhador!");

que trocamos por:

System.out.println("Jogador " + jogador1.nome + " é o ganhador!");

Essas trocas acontecem nas rotinas main() e jogar().

Mas como implementar a função buscarJogador(), se os dados de vitória ou derrota não estão sendo salvos em nenhum lugar? Vamos resolver esse detalhe antes de mostrar o código de buscarJogador(), ok? Para armazenar os registros, vamos usar um array, como mostrado a seguir:

public class JogoDaVelha { 

    private static Jogador[] jogadores = new Jogador[50]; 

    private static int quantidadeJogadores = 0; 

    ...

}

O array jogadores será utilizado para guardar todos os jogadores, até o limite de 50. Para saber quantos jogadores estão cadastrados no array, utilizamos a variável quantidadeJogadores. Vamos agora ver o que precisamos fazer para buscar e guardar os dados sobre jogadores no array, através da função buscarJogador():

public static Jogador buscarJogador(String nome) { 

    Jogador jogador = null; 

    for (int i = 0; (i < quantidadeJogadores) && (jogador == null); i++) { 

        if (jogadores[i] != null &&

            jogadores[i].nome.equalsIgnoreCase(nome)) { 

            jogador = jogadores[i]; 

        } 

    } 

    if (jogador == null) { 

        jogador = new Jogador(); 

        jogador.nome = nome;

        if (quantidadeJogadores < 50) { 

            jogadores[quantidadeJogadores] = jogador; 

            quantidadeJogadores = quantidadeJogadores + 1; 

        }

​

    } 

    return jogador; 

}

Note na função a declaração da variável jogador, responsável por armazenar o registro a ser retornado. Além dela, temos um laço for, o qual percorre os registros armazenados no array da posição 0 (zero) até a quantidade de jogadores (último índice utilizado no array + 1). Lembrando que, no início, o laço não será executado, visto que a quantidade de jogadores inicial é igual a zero. Outra condição para o laço ser executado é que o valor da variável “jogador” seja igual a null, valor que representa um registro não criado (não encontrado), ou seja, um valor vazio.

Dentro do laço for, usamos a expressão “jogadores[i]” para acessar o registro da posição “i” do array “jogadores”. A partir desse registro, fazemos duas verificações: se a posição acessada no array não está vazia (valor diferente de null); se o nome do jogador do registro acessado (jogadores[i].nome) é igual ao nome passado como parâmetro para a função. Se ambas as verificações forem confirmadas, isto quer dizer que encontramos o registro do jogador! Com isso, é só atribuí-lo à variável “jogador”.

Após a execução do laço, verificamos se a variável “jogador” é nula. Se isso acontecer, é porque não existe ainda um registro cadastrado no array para o nome passado como parâmetro. Dessa forma, dentro desse if temos a criação de um novo registro e a inicialização de seu nome (“jogador.nome”) com o nome passado como parâmetro para a função. Feito isso, adicionamos o registro criado na última posição do array (“quantidadeJogadores”), caso haja espaço disponível no array (quantidadeJogadores < 50), aumentando assim em uma unidade o valor da variável “quantidadeJogadores”.

Terminado esse processo, podemos então retornar o valor da variável “jogador”, o qual representa agora o registro utilizado para representar o jogador com o nome informado (parâmetro da função).

Essa função, utilizada dentro da função cadastro() é responsável por criar novos registros e por recuperar registros já existentes. Falta agora mostrar para o usuário a lista de jogadores e respectivos resultados de partidas (vitórias e derrotas). Isso é feito através da rotina imprimirJogadores():

public static void imprimirJogadores() { 

    System.out.println("------ Resultado dos jogadores --------"); 

    for (int i = 0; i < quantidadeJogadores ; i++) { 

        System.out.println("Nome: " + jogadores[i].nome); 

        System.out.println(" | vitórias:" + jogadores[i].vitorias); 

        System.out.println(" | derrotas:" + jogadores[i].derrotas); 

    }

}

Note que a função imprimirJogadores percorre o array, imprimindo os resultados de vitórias e derrotas de cada jogador cadastrado. Essa rotina deve ser chamada na última linha da rotina main(), a qual deve possuir os ajustes para registrar as vitórias e derrotas de cada jogador:

public static void main(String[] args) { 

    cadastro(); 

    setTempo(); 

    int i = 0; 

    // percorre todo o tabuleiro, nas nove posições: 

    for (i = 0; i < 9; i++) { 

        jogo();// chama a função jogo(), que desenha o tabuleiro 

        if (i % 2 == 0) { 

            jogar(2); 

        } else { 

            jogar(1); 

        } 

        // chama a função check (), para ver se alguém ganhou 

        check(); 

        if (win == 1 || win == 2) { 

            // sai do laço antes de completar o tabuleiro, 

            // se alguém tiver vencido 

            i = 10; 

        } 

    } 

    // chama a função jogo(), para desenhar novamente o tabuleiro 

    jogo(); 

    // verifica se houve vencedor 

    System.out.println(); 

    if (win == 1) { 

        // informa o vencedor 

        System.out.println("Jogador " + jogador1.nome + " é o ganhador!"); 

        jogador1.vitorias = jogador1.vitorias + 1; 

        jogador2.derrotas = jogador2.derrotas + 1; 

    } else if (win == 2) { 

        // informa o vencedor 

        System.out.println("Jogador " + jogador2.nome + " é o ganhador!"); 

        jogador2.vitorias = jogador2.vitorias + 1;

        jogador1.derrotas = jogador1.derrotas + 1; 

    } else { 

        // se não houve vencedor 

        System.out.println("Não houve vencedor! O jogo foi empate!!"); 

    } 

    System.out.println("O tempo total de jogo foi de " + getTempo() + "s"); 

    imprimirJogadores();

}