Aulas
Disciplinas

Cursos / Informática para Internet / Programação Estruturada / Aula

arrow_back Aula 13 - Desenvolvendo um jogo da velha

4. Fazendo e Validando as Marcações

Já desenhamos o tabuleiro. Como fazer, então, para definir de que forma serão feitas as marcações de cada jogador?

Vimos, há pouco, que precisamos definir uma variável (jog) para armazenar o jogador da vez.

Com base nessa variável é que o computador vai definir de quem é a vez e o símbolo que será marcado. A função jogar, cujo código completo você verá mais adiante, recebe como argumento uma variável do tipo int, a que chamamos jogador.

O programa lê o argumento e define, a partir dele, quem é o jogador da vez para, em seguida, informar isso aos usuários. Veja o trecho de código a seguir.

AخA
1
public static void jogar (int jogador) {
2
    if (jogador == 1) {
3
        jog = 1;
4
    }  else {
5
        jog = 2;
6
    }
7
}

O programa recebe o argumento no procedimento jogar e, caso o valor da variável jogador seja 1, esse valor é armazenado na variável jog. O mesmo ocorre se o valor da variável for 2. Esse valor é determinado na rotina principal (main, que veremos mais adiante) do programa, quando o procedimento jogar é “chamado”.

A variável jog será utilizada na mensagem que informa ao usuário de quem é a vez.

1
1
System.out.println("\n\n Vez do Jogador " + jog);

Bom, já sabemos como mostrar de quem é a vez de jogar. Mas ainda temos que determinar como serão feitas as marcações no tabuleiro. Precisamos, para isso, oferecer as opções para que o jogador escolha em que campo do tabuleiro (em que linha e coluna da matriz) irá fazer a sua marcação.

As variáveis (linha e coluna) do tipo int que declaramos junto com a variável jog lá no início serão utilizadas nesse momento, para armazenar os valores das linhas e colunas digitados pelo jogador. Podemos fazer isso acrescentando ao código anterior a solicitação para que o jogador da vez escolha a linha e a coluna em que fará sua marcação. Veja:

6
1
System.out.print("Escolha a Linha (1,2,3):");
2
// lendo a linha escolhida
3
linha = leitor.nextInt();
4
System.out.print("Escolha a Coluna (1,2,3):");
5
// lendo a coluna escolhida
6
coluna = leitor.nextInt();

Mas não é só isso. Precisamos validar a escolha do jogador. Se a linha ou coluna escolhida for maior que 3 ou menor que 1, a marcação não pode ser feita, pois o nosso tabuleiro só tem linhas e colunas de 1 a 3.

É importante avisar ao jogador, caso isso ocorra. Veja o código a seguir, com o procedimento jogar ainda incompleto, mas um pouco mais elaborado, com a validação da escolha do usuário.

35
1
public static void jogar(int jogador) {
2
    // inicializando contador da estrutura while
3
    int i = 0;
4
    // definindo o jogador da vez
5
    if (jogador == 1) {
6
        jog = 1;
7
    } else {
8
        jog = 2;
9
    }
10
    System.out.println("\n\n Vez do Jogador " + jog);
11
    while (i == 0) {
12
        linha = 0; // inicializando valor da linha
13
        coluna = 0; // inicializando valor da coluna
14
        while (linha < 1 || linha > 3) {
15
            System.out.print("Escolha a Linha (1,2,3):");
16
            // lendo a linha escolhida
17
            linha = leitor.nextInt();
18
            // Aviso de linha inválida, caso o jogador tenha
19
            // escolhido linha menor que 1 ou maior que 3
20
            if (linha < 1 || linha > 3) {
21
                System.out.println("Linha invalida! Escolha uma linha entre 1 e 3.");
22
            }
23
        }
24
        while (coluna < 1 || coluna > 3) {
25
            System.out.print("Escolha a Coluna (1,2,3):");
26
            // lendo a coluna escolhida
27
            coluna = leitor.nextInt();
28
            if (coluna < 1 || coluna > 3) {
29
                System.out.println("Coluna invalida! Escolha uma coluna entre 1 e 3.");
30
            }
31
        }
32
        // Ajusta índices para começar do zero
33
        linha = linha - 1;
34
        coluna = coluna - 1;
35
        (...)

Leia os comentários que estão no código (as linhas com //, lembra?).

Veja que, após a leitura da escolha do usuário (para a linha e para a coluna), temos um IF que valida a escolha, avisando que não é permitido escolher linha ou coluna menor que 1 ou maior que 3.

Veja, também, que a seleção da linha e a seleção da coluna estão inseridas, cada uma, em uma estrutura while. Isso é feito para que, enquanto o valor da linha e/ou da coluna digitado pelo jogador for inválido, a mensagem que solicita a escolha de uma linha e/ou coluna válida seja exibida.

Dessa forma, o programa só passa para a parte seguinte do código após a seleção validada desse ponto de vista (linha e coluna com valor entre 1 e 3). Feito isso, ainda falta uma validação importante: se o jogador tentar marcar um campo que não esteja vazio, ele deve ser avisado de que não pode fazer isso. Veja o trecho de código a seguir.

8
1
if (casa[linha][coluna] == 0) {
2
    // se não estiver marcado
3
    // marcar com o símbolo do jogador da vez
4
    casa[linha][coluna] = jog;
5
    i = 1;
6
} else { // se o campo escolhido já estivar marcado
7
    System.out.println("Posição ocupada!");
8
}

O trecho de código analisa se o campo selecionado pelo jogador da vez não está marcado. Se não estiver, é feita a marcação com o símbolo do jogador da vez (jog) e o contador do laço while recebe o valor 1. Essa alteração no valor do contador ocorre para que, ao ser feita a marcação, a execução saia do laço (lembre-se de que a condição para o laço era o contador i = 0). Já que a marcação foi realizada, não há mais porque permanecer no laço.

Caso o campo escolhido pelo jogador já esteja marcado, o IF não é executado, mas sim o ELSE, em que uma mensagem avisa ao jogador para escolher outro campo. A jogada só é concluída quando a condição do IF é atendida. Só assim a marcação é realizada e o contador é alterado, para a execução sair do laço. Veja o código do procedimento jogar completo a seguir.

44
1
public static void jogar(int jogador) {
2
    // inicializando contador da estrutura while
3
    int i = 0;
4
    // definindo o jogador da vez
5
    if (jogador == 1) {
6
        jog = 1;
7
    } else {
8
        jog = 2;
9
    }
10
    System.out.println("\n\n Vez do Jogador " + jog);
11
    while (i == 0) {
12
        linha = 0; // inicializando valor da linha
13
        coluna = 0; // inicializando valor da coluna
14
        while (linha < 1 || linha > 3) {
15
            System.out.print("Escolha a Linha (1,2,3):");
16
            // lendo a linha escolhida
17
            linha = leitor.nextInt();
18
            // Aviso de linha inválida, caso o jogador tenha
19
            // escolhido linha menor que 1 ou maior que 3
20
            if (linha < 1 || linha > 3) {
21
                System.out.println("Linha invalida! Escolha uma linha entre 1 e 3.");
22
            }
23
        }
24
        while (coluna < 1 || coluna > 3) {
25
            System.out.print("Escolha a Coluna (1,2,3):");
26
            // lendo a coluna escolhida
27
            coluna = leitor.nextInt();
28
            if (coluna < 1 || coluna > 3) {
29
                System.out.println("Coluna invalida! Escolha uma coluna entre 1 e 3.");
30
            }
31
        }
32
        // Ajusta índices para começar do zero
33
        linha = linha - 1;
34
        coluna = coluna - 1;
35
        if (casa[linha][coluna] == 0) {
36
            // se não estiver marcado
37
            // marcar com o símbolo do jogador da vez
38
            casa[linha][coluna] = jog;
39
            i = 1;
40
        } else { // se o campo escolhido já estivar marcado
41
            System.out.println("Posição ocupada!");
42
        }
43
    }
44
}
play_circle_filled
Vídeo 03 - rotina Jogar
[A] Anterior
6/13
Próxima [D]

Sumário

Versão 5.3 - Todos os Direitos reservados