Ajude nosso projeto a se manter online.

Jogo da Velha em C++ : Como programar

Neste tutorial, vamos te ensinar do mais absoluto zero, como programar o jogo da velha em C++, um game super bacana que você pode usar para jogar com algum amigo.

Código completo do jogo da velha em C++

Lógica do Jogo da Velha em C++

Vamos usar uma matriz, 3x3, de inteiros, para representar as jogadas.
Se a casa tiver o número 0, ela está vazia. Se tiver o número 1 é porque o jogador 1 jogou lá, e se tiver -1, é porque o jogador 2 jogou naquela posição.

Vamos explicar, por partes, as funções.

A função init(), inicializa o tabuleiro, colocando 0 em todas as casas.

A função show() vai exibir o tabuleiro, imprimir o tabuleiro bonitinho, com barras, underlines, espaçamentos corretos e, se tem X ou 0 em cada casa. Essa última parte quem faz é a função printBlock().
A função printBlock() vai em cada casa do tabuleiro, se tiver 0 lá, ela retorna um espaço vazio ' '.
Se tiver o número 1 lá, ela imprime X. Se tiver -1 lá, é porque o jogador 2 jogou nessa casa, e lá vai ter um O.

A função playMove() realiza uma jogada, ou seja, pede a linha e a coluna que o jogador vai jogar.
Lembrando que ele vai digitar valores de 1 até 3, e o array vai de 0 até 2, por isso temos que subtrair uma unidade dos dados digitados pelo usuário (row-- e col--). Também devemos checar se ela está ocupada (board[row][col]), e se o usuário digitou valores corretos (entre 1 e 3). Se tudo estiver ok, ela preenche com 1 ou -1 a casa que o jogador escolheu.

A função checkContinue() vai verificar se ainda tem espaço em branco, ou seja, se ainda é possível realizar alguma jogada. Se tiver espaço em branco, retorna 1, se não tiver, retorna 0.

A função checkWin() vai checar se alguém ganhou. Para isso, basta somar cada linha, cada coluna e cada diagonal, se alguma dessas fileiras tiver soma 3, o jogador 1 ganhou e retornamos 1. Se a soma for -3, o jogador 2 ganhou, e retornamos -1. Se ninguém tiver ganhado, até aquele momento, retornamos 0.

Agora vamos pra função main(). Ela cria o tabuleiro 3x3, a variável cont (que vai perguntar se o jogador vai querer jogar de novo ou não, as variáveis player1 e player2 , que vão armazenar o placar do jogo), e a variável result, que armazena a informação de quem ganhou o jogo.

O jogo vai ocorrer dentro de um DO WHILE.
Primeiro, inicializamos o tabuleiro com valores 0.

Agora vamos fazer uma partida, para isso, chamamos a função game().

A função game() é onde ocorre a magia, o desenrolar do jogo.
Primeiro, declaramos a variável turn, que vai dizer se é o jogador 1 ou 2 que vai jogar. A cada jogada, devemos incrementar ela em uma unidade (turn++), para mudar a vez para o próximo jogador.

Após dizer de quem é a vez, vamos fazer a jogada, através da função playMove(). Note que passamos a informação de quem é o jogador, através da expressão turn%2. Se ela der 0, é a vez do jogador 1 (e coloca o número 1, representado pelo X no tabuleiro), se der 1, é a vez do jogador (e preenchemos a matriz com o número -1, que vai ser representado pelo caractere O no tabuleiro).

Em seguida, devemos checar se o tabuleiro ainda tem posições vazias, pra jogar. Se tiver, armazenamos o número 1 na variável cont, senão, armazenamos o valor 0.

Também devemos checar se após essa jogada, alguém ganhou. Se o jogador 1 tiver ganhado, armazenamos 1 na variável win. Se o jogador 2 tiver ganhado, armazenamos o valor -1. Se ninguém tiver ganhado, armazenamos o valor 0.

Pronto. Uma jogada terminou. Vai ter uma próxima jogada? Isso depende.
Se ainda tiver espaço vazio (cont=1) e  ninguém tiver ganhado (win=0, o mesmo que !win), vai ter outra jogada.

Se não tiver mais espaço vazio (cont=0) ou alguém tiver ganhado (win=1 ou win=-1), não vai ter próxima jogada, e sai do laço DO WHILE.

Após o laço, vamos verificar o que ocorreu. Se win=1, o jogador 1 ganhou e a função game retorna 1.
Se win=-1, o jogador 2 ganhou e retornamos 2. Se nenhum tiver ganhado, é porque o tabuleiro tá cheio (cont=0) e deu empate, então retornamos 0.

Esse retorno, vai lá pra função main(), na variável result. Ele pega o resultado, e manda pra função scoreboard(), junto com os valores de player1 e player2, ela é responsável por controlar o placar.

Após a exibição do placar, perguntamos se vai querer jogar novamente o jogo ou sair.
Se digitar 1 (continuar), a variável cont fica com valor 1, o laço WHILE dá verdadeiro, e outra partida será iniciada. Senão, se for 0, o laço termina junto com o jogo.

Bacana, não é?

Pessoal, o código abaixo tem quase 200 linhas. Podem existir erros, sem dúvidas.
Se encontrarem algum, ou alguma melhoria, por favor escreva nos comentários, ok?

Código do jogo da Velha em C++

#include <iostream>
using namespace std;

void init(int board[][3]);          // Initializes the board with 0's
char printBlock(int block);         // Prints each square of the board
void show(int board[][3]);          // Show the board
void playMove(int board[][3], int); // Play one move
int checkContinue(int *board[3]);   // Check if there is still white space
int checkWin(int *board[3]);        // Check if anyone won
int game(int board[][3]);           // PLay an entire game
void scoreboard(int, int &, int &); // Show the scoreboard

int main()
{
    int board[3][3];

    int cont=0, player1=0, player2=0, result;
    do{
        init(board);
        result = game(board);
        show(board);
        scoreboard(result, player1, player2);

        cout<<"\n Outra partida?"<<endl;
        cout<<"0. Sair"<<endl;
        cout<<"1. Jogar de novo"<<endl;
        cin >> cont;
    }while(cont);

    return 0;
}

void init(int board[][3])
{
    for(int i=0; i<3; i++)
        for(int j=0; j<3; j++)
            board[i][j]=0;

}

char printBlock(int block)
{
    if(block==0)
        return ' ';
    else if(block==1)
        return 'X';
    else
        return 'O';
}

void show(int board[][3])
{
    cout<<endl;
    for(int row=0 ; row<3 ; row++){
        cout<<" "<< printBlock(board[row][0]) <<" |";
        cout<<" "<< printBlock(board[row][1]) <<" |";
        cout<<" "<< printBlock(board[row][2]) <<endl;

        if(row!=2){
            cout<<"___ ___ ___\n"<<endl;
        }
    }
}

void playMove(int board[][3], int player)
{
    int row, col, check;
    do{
        cout<<"Linha: ";
        cin >>row;
        cout<<"Coluna: ";
        cin >> col;
        row--; col--;

        check = board[row][col] || row<0 || row>2 || col<0 || col>2;
        if(check)
            cout<<"Essa casa não está vazia ou fora do intervalo 3x3"<<endl;

    }while(check);

    if(player==0)
        board[row][col]=1;
    else
        board[row][col]=-1;
}

int checkContinue(int board[][3])
{
    for(int i=0 ; i<3 ; i++)
        for(int j=0 ; j<3 ; j++)
            if(board[i][j]==0)
                return 1;
    return 0;
}

int checkWin(int board[][3])
{
    int row, col, sum;

    // Adding the lines
    for(row=0 ; row<3 ; row++){
        sum=0;

        for(col=0 ; col<3 ; col++)
            sum += board[row][col];

        if(sum==3)
            return 1;
        if(sum==-3)
            return -1;
    }

    // Adding the columns
    for(col=0 ; col<3 ; col++){
        sum=0;

        for(row=0 ; row<3 ; row++)
            sum += board[row][col];

        if(sum==3)
            return 1;
        if(sum==-3)
            return -1;
    }

    // Adding the diagonals
    sum=0;
    for(row=0 ; row<3 ; row++)
        sum += board[row][row];
    if(sum==3)
        return 1;
    if(sum==-3)
        return -1;

    sum=board[0][2]+board[1][1]+board[2][0];
    if(sum==3)
        return 1;
    if(sum==-3)
        return -1;

    return 0;
}

int game(int board[][3])
{
    int turn=0, cont, win;

    do{
        show(board);
        cout<<"Jogador "<<1+turn%2<<endl;
        playMove(board, turn%2);
        turn++;

        cont=checkContinue(board);
        win = checkWin(board);
    }while(cont && !win);

    if(win==1){
        cout<<"Jogador 1 ganhou!\n"<<endl;
        return 1;
    }else
        if(win==-1){
            cout<<"Jogador 2 ganhou!\n"<<endl;
            return 2;
    }else
        cout<<"Empate\n"<<endl;
    return 0;
}

void scoreboard(int result, int &player1, int &player2)
{
    if(result==1)
        player1++;
    if(result==2)
        player2++;

    cout<<"Placar: "<<endl;
    cout<<player1<<" x "<<player2<<endl;
}

Desafio em C++

Crie uma versão modificada deste jogo, que pergunta ao usuário se ele deseja jogar com um amigo ou contra o computador. Se ele escolher jogar contra a máquina, faça com que seu código escolha alguma casa aleatória, quando for a vez da máquina.

Será que alguém seria capaz de fazer e postar nos comentários, o resultado?

Nenhum comentário:

Postar um comentário