jogo_da_velha.trabalho.c

/*

Universidade de Brasilia
Instituto de Ciencias Exatas
Departamento de Ciencia da Computacao
Computacao Basica – 01/2012
Aluno(a): Wagner Alberto Soares Junior
Matricula: 12/0023857
Turma: A
Versão do compilador: versão do gcc 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5)
Descricao: O programa consiste em um jogo da velha baseado em matrizes,
a grande vantagem de ser baseado em matrizes se deve ao fato de assim
podermos modificar o tamanho do jogo para qualquer valor entre 3 e 12,
o valor deve ser passado como parâmetro no início do programa para que
a área útil da matriz seja inicializada.


*/

#include <stdio.h>



#include "cbtactoe_library.h"


/*a função verificarFim funciona da seguinte maneira, para ela é passado os parâmetros Tabuleiro, linha do cursor atual,
coluna do cursor atual, tamReal da matriz inicalizada e o simbolo atual. Nela são feitas as verificações se houveram ganhadores
somente na linha e coluna e se o número estiver em uma diagonal  faço o teste para ver se houve vitória na jogada. */



int verificarFim (char tabuleiro[][23],int linha_cursor,int coluna_cursor,int tamReal,char simbolo_atual) {
    int vitoria=1;
    int i=0;


    /*testou se houve ganhadores na coluna marcada*/
    while (i<tamReal && vitoria) {
        vitoria=1;
            if (simbolo_atual!=tabuleiro[linha_cursor][i]) {
                vitoria=0;
            }
        i+=2;

    }
    /*testou se houve ganhadores na linha marcada, essa condição só é testada
    também se não houve vitória na ultima linha.*/
    if (vitoria==0){
        i=0;
        vitoria=1;
        while (i<tamReal && vitoria){

            if (simbolo_atual!=tabuleiro[i][coluna_cursor]){
                vitoria=0;

            }
        i+=2;
        }
    }
    /*testou se houve ganhadores na diagonal principal, a condição para que seja testado
    se houve vitoria na diagonal principal , é de que o indice da linha tem que ser igual
    o da coluna, essa condição só é testada também se não houve vitória na ultima linha.*/
    if (linha_cursor==coluna_cursor){
        if (vitoria==0){
            i=0;
            vitoria=1;
            while (i<tamReal && vitoria){
                if (simbolo_atual!=tabuleiro[i][i]){
                    vitoria=0;
                }
            i+=2;
            }
        }
    }
    /*aqui testo se foi marcado algum valor na diagonal secundária, para eu saber se
    é a diagonal secundária eu uso a seguinte condição, o indice i+ o indice j, tem que
    ser igual ao tamanhoReal menos um, já que numa matriz 3x3 seria 5 o tamReal todos os
    valores da diagonal secundária terão a soma do indice 4,essa condição só é testada também
    se não houve vitória na ultima linha.*/
    if (linha_cursor+coluna_cursor==tamReal-1){
        if(vitoria==0){
            i=0;
            vitoria=1;
            while (i<tamReal && vitoria){
                if(tabuleiro[tamReal-i-1][i]!=simbolo_atual)
                    vitoria=0;
            i+=2;
            }

        }
    }
    /*se houve vitória retorno 1*/
    if (vitoria) {
        return 1;
    }
    else {
        /* se não ouve vitoria retorno 0*/
        return 0;
    }
}

/*aqui trato a entrada que o jogador fez, essa função é rodada 30 vezes por segundo.
ela nada mais faz do que tratar cada valor que foi inserido pelo usuário no jogo.*/
int  tratarInput (char tabuleiro[][23],int tamanho,int *linha_cursor,int *coluna_cursor,char *simbolo_atual,int *jogadas,int valor,char *resultado) {
        int tamReal=tamanho+tamanho-1;

        /*esse switch é a alma da função para cada caso ele faz uma coisa.*/
        switch (valor) {
                    /*aqui trato de abortar o jogo caso o usuário pressione q*/
                    case 'q':
                    case 'Q':
                        return 'q';
                        break;

                    /*aqui movo o cursor para CIMA caso esteja em uma posição válida*/
                    case CIMA:
                        if (*linha_cursor>0)
                            *linha_cursor-=2;
                            break;
                    /*aqui movo o cursor para BAIXO caso esteja em uma posição válida*/
                    case BAIXO:
                        if (*linha_cursor<tamReal-1)
                            *linha_cursor+=2;
                            break;
                    case ESQUERDA:
                    /*aqui movo o cursor para ESQUERDA caso esteja em uma posição válida*/
                        if (*coluna_cursor>0)
                            *coluna_cursor-=2;
                            break;
                    case DIREITA :
                    /*aqui movo o cursor para DIREITA caso esteja em uma posição válida*/
                        if (*coluna_cursor<tamReal-2)
                            *coluna_cursor+=2;
                        break;
                    case ENTER :

                        /*primeiro verifico se o local que o usuário quer marcar está vazio
                        se estiver marco com o simbolo atual*/
                        if (tabuleiro[*linha_cursor][*coluna_cursor]==VAZIO){
                            tabuleiro[*linha_cursor][*coluna_cursor]=*simbolo_atual;
                            *jogadas=*jogadas+1;
                            /*apos isso verifico o final do jogo, se alguém ganhou marco o resultado com o símbolo atual*/
                            if (verificarFim(tabuleiro,*linha_cursor,*coluna_cursor,tamReal,*simbolo_atual)){
                                *resultado=*simbolo_atual;
                                return 'q';
                            }
                            /*sempre faço o teste para saber se houveram empates,já q quando não houverem mais jogadas
                            disponíveis tenho q declarar empate.*/
                            if (*jogadas==(tamanho)*(tamanho)){
                                *resultado=EMPATE;
                                return 'q';
                            }

                            else {
                                /*se houverem jogadas válidas ainda, mudo o símbolo do jogador.*/
                                if (*simbolo_atual==NOUGHT){
                                    *simbolo_atual=CROSS;
                                }
                                else {
                                    *simbolo_atual=NOUGHT;
                                }
                            }
                        }
                    /*quando nada é feito simplesmente aborto o loop*/
                    default :
                        break;
        }
         return 0;
}


/*aqui simplesmente inicializo o tabuleiro nas posições válidas*/
void inicializarTabuleiro (char tabuleiro[][23],int tamanho) {
    int tamReal;
    int i,j,k;
    tamReal=tamanho+tamanho-1;

    for (i=0;i<tamReal;i++){
        for (j=0;j<tamReal;j++){
            if (j%2==1)
                tabuleiro[i][j]=BORDA;
            else
                tabuleiro[i][j]=VAZIO;
        }
        if (i%2==1){
            for (k=0;k<tamReal;k++){
                tabuleiro[i][k]=BORDA;
            }

        }

    }


}

/*essa função é a parte principal do jogo, aqui que fica o loop infinito
para que o jogo tenha andamento*/
void run (int tamanho){
        char tabuleiro[23][23],simbolo_atual,resultado;
        int jogadas,game,valor,linha_cursor,coluna_cursor;

        inicializarNcurses();
        inicializarTabuleiro(tabuleiro,tamanho);
        game=linha_cursor=coluna_cursor=jogadas=0;
        simbolo_atual='O';

        while (game==0){
            /*loop infinito enquanto nao houverem ganhadores ou seja abortado*/

                controlarFPS();
                mostrarTela(tabuleiro,tamanho,linha_cursor,coluna_cursor,simbolo_atual);
                valor = receberTecla();
                game=tratarInput(tabuleiro,tamanho,&linha_cursor,&coluna_cursor,&simbolo_atual,&jogadas,valor,&resultado);
        }

        finalizarNcurses();
        mostrarResultado(tabuleiro,tamanho,resultado);

}


/*na main , simplesmente testa-se se o tamanho da matriz é válido ou se houveram 2 parâmetros somente
passados para o programa.*/
int main  (int argc, char* argv[]) {
    int tamanho;

    sscanf(argv[1],"%d",&tamanho);
    if (tamanho>=3 && tamanho <=12 && argc==2){
        run (tamanho);

    }
    else {
        printf("ERRO: O PROGRAMA SERÀ ABORTADO,INSIRA UM VALOR ENTRE 3 e 12 E SOMENTE UM PARAMETRO\n");

    }




    return 0;
}