none
Alguém aí manja em CODE BLOCKS, programação C++? Ficarei grato com a ajuda de vocês nesse projeto. RRS feed

  • Pergunta

  • Segue o bloco de código, com alguns comentários para facilitar o entendimento de vocês. Como percebe-se, esses comandos estão todos no main, ok? Eu tenho que tirar do main, e realizar as 4 funções cita à baixo, somente a função 5, que é a chamada das funções que deve ser feita no MAIN. Por favor me ajudem nesse projeto, ficarei muito agradecido. Desde já, obrigado pela atenção. CODE BLOCKS 12.11 é programa que deve ser utilizado para compilar isso tudo.

    1

    Nome da função: desenhar_tabuleiro
    Objetivo: desenhar o tabuleiro e o mapa de posições do
    jogo
    Tipo de retorno: nenhum
    Parâmetro(s): o vetor que representa o tabuleiro do jogo
    2
    Nome da função: qual_jogador
    Objetivo: determinar qual é o jogador da vez
    Tipo de retorno: char (o jogador que tem a vez)
    Parâmetro(s): a variável que contém o número da
    jogada
    3
    Nome da função: determinar_coordenadas
    Objetivo: a partir da posição informada pelo usuário,
    encontrar a linha e a coluna equivalentes da matriz do
    tabuleiro
    Tipo de retorno: nenhum
    Parâmetros: a variável que contém a posição e as
    variáveis da linha e da coluna (ATENÇÃO: os dois
    últimos parâmetros devem ser passadas POR
    REFERÊNCIA!)

    4
    Nome da função: verificar_vencedor
    Objetivo: determinar se já existe vencedor no jogo,
    verificando as jogadas no tabuleiro
    Tipo de retorno: char (o jogador que venceu, X ou O, ou
    um espaço em branco se ninguém tiver vencido ainda
    Parâmetro(s): vetor que representa o tabuleiro do jogo
    5
    Nome da função: main
    Objetivo: função principal do programa, que deve conter
    a chamada às demais funções
    Tipo de retorno: int
    Parâmetro(s): nenhum.


        char tabuleiro[3][3] = {{' ', ' ', ' '}, {' ', ' ', ' '}, {' ', ' ', ' '}};
        int linha, coluna, posicao, jogada, jogada_ok;
        char jogador, vencedor = ' ';
    
        setlocale(LC_ALL, "Portuguese");
    
        // O jogo da velha dura, no máximo, nove jogadas
        for(jogada = 1; jogada <= 9; ++jogada) {
    
            /*
                Determina qual é o jogador que tem a faz a jogada da vez.
                Nas vezes ímpares, é o jogador X.
                Nas vezes pares, é o jogador O.
            */
            if(jogada % 2 == 1) {
                jogador = 'X';
            }
            else {
                jogador = 'O';
            }
    
            // Desenha o tabuleiro e o mapa de posições na tela
            cout << endl << endl;
            cout << "TABULEIRO        POSIÇÕES" << endl;
            cout << "---------        --------" << endl;
            cout << endl;
            cout << " " << tabuleiro[0][0] << " | " << tabuleiro[0][1] << " | " << tabuleiro[0][2] << "       1 2 3" << endl;
            cout << "---+---+---" << endl;
            cout << " " << tabuleiro[1][0] << " | " << tabuleiro[1][1] << " | " << tabuleiro[1][2] << "       4 5 6" << endl;
            cout << "---+---+---" << endl;
            cout << " " << tabuleiro[2][0] << " | " << tabuleiro[2][1] << " | " << tabuleiro[2][2] << "       7 8 9" << endl;
    
            /*
                Verifica se há vencedor e, se for o caso, dá a mensagem correspondente e
                quebra o loop, encerrando assim o programa
            */
            if(vencedor != ' ') {
                cout << endl << "O JOGADOR '" << vencedor << "' VENCEU A PARTIDA!!!";
                break;
            }
    
    
            // Loop para repetir o pedido de jogada enquanto o usuário não informar uma posição válida
            jogada_ok = 0;
            while(!jogada_ok) {
                cout << "Vez do jogador " << jogador << ". Informe a posição desejada: ";
                cin >> posicao;
    
                /*
                    Determina as coordenadas de linha e coluna da matriz
                    com base na posição informada
                */
                if(posicao == 1) {
                    linha = 0;
                    coluna = 0;
                }
                else if (posicao == 2) {
                    linha = 0;
                    coluna = 1;
                }
                else if (posicao == 3) {
                    linha = 0;
                    coluna = 2;
                }
                else if (posicao == 4) {
                    linha = 1;
                    coluna = 0;
                }
                else if (posicao == 5) {
                    linha = 1;
                    coluna = 1;
                }
                else if (posicao == 6) {
                    linha = 1;
                    coluna = 2;
                }
                else if (posicao == 7) {
                    linha = 2;
                    coluna = 0;
                }
                else if (posicao == 8) {
                    linha = 2;
                    coluna = 1;
                }
                else if (posicao == 9) {
                    linha = 2;
                    coluna = 2;
                }
    
                /*
                    Uma posição válida é
                    1) Um número inteiro entre 1 e 9 e
                    2) Que já não tenha sido usado ainda
                */
                if(posicao >= 1 && posicao <= 9 && tabuleiro[linha][coluna] == ' ') {
                    tabuleiro[linha][coluna] = jogador;
                    jogada_ok = 1;
                }
                else {
                    cout << "JOGADA INVÁLIDA. Tente novamente." << endl;
                }
    
            }
    
            // Matematicamente, só é possível haver um vencedor após a 5ª jogada
            if(jogada >= 5) {
    
                /* Verifica se o jogador X ganhou o jogo */
                if(
                    // Jogador X, primeira horizontal
                    (tabuleiro[0][0] == 'X' && tabuleiro[0][1] == 'X' && tabuleiro[0][2] == 'X') ||
    
                    // Jogador X, segunda horizontal
                    (tabuleiro[1][0] == 'X' && tabuleiro[1][1] == 'X' && tabuleiro[1][2] == 'X') ||
    
                    // Jogador X, terceira horizontal
                    (tabuleiro[2][0] == 'X' && tabuleiro[2][1] == 'X' && tabuleiro[2][2] == 'X') ||
    
                    // Jogador X, primeira vertical
                    (tabuleiro[0][0] == 'X' && tabuleiro[1][0] == 'X' && tabuleiro[2][0] == 'X') ||
    
                    // Jogador X, segunda vertical
                    (tabuleiro[0][1] == 'X' && tabuleiro[1][1] == 'X' && tabuleiro[2][1] == 'X') ||
    
                    // Jogador X, terceira vertical
                    (tabuleiro[0][2] == 'X' && tabuleiro[1][2] == 'X' && tabuleiro[2][2] == 'X') ||
    
                    // Jogador X, diagonal para a direita
                    (tabuleiro[0][2] == 'X' && tabuleiro[1][1] == 'X' && tabuleiro[2][0] == 'X') ||
    
                    // Jogador X, diagonal para a esquerda
                    (tabuleiro[0][0] == 'X' && tabuleiro[1][1] == 'X' && tabuleiro[2][2] == 'X')
    
                ) {
                    vencedor = 'X';
                }
    
                /* Verifica se o jogador O ganhou o jogo */
                else if(
                    // Jogador O, primeira horizontal
                    (tabuleiro[0][0] == 'O' && tabuleiro[0][1] == 'O' && tabuleiro[0][2] == 'O') ||
    
                    // Jogador O, segunda horizontal
                    (tabuleiro[1][0] == 'O' && tabuleiro[1][1] == 'O' && tabuleiro[1][2] == 'O') ||
    
                    // Jogador O, terceira horizontal
                    (tabuleiro[2][0] == 'O' && tabuleiro[2][1] == 'O' && tabuleiro[2][2] == 'O') ||
    
                    // Jogador O, primeira vertical
                    (tabuleiro[0][0] == 'O' && tabuleiro[1][0] == 'O' && tabuleiro[2][0] == 'O') ||
    
                    // Jogador O, segunda vertical
                    (tabuleiro[0][1] == 'O' && tabuleiro[1][1] == 'O' && tabuleiro[2][1] == 'O') ||
    
                    // Jogador O, terceira vertical
                    (tabuleiro[0][2] == 'O' && tabuleiro[1][2] == 'O' && tabuleiro[2][2] == 'O') ||
    
                    // Jogador O, diagonal para a direita
                    (tabuleiro[0][2] == 'O' && tabuleiro[1][1] == 'O' && tabuleiro[2][0] == 'O') ||
    
                    // Jogador O, diagonal para a esquerda
                    (tabuleiro[0][0] == 'O' && tabuleiro[1][1] == 'O' && tabuleiro[2][2] == 'O')
    
                ) {
                    vencedor = 'O';
                }
            }
    



    segunda-feira, 3 de junho de 2013 11:37