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:

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:

pelas seguintes declarações:

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.

pelo seguinte código:

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

que trocamos por:

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:

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():

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():

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: