Jump to content
PsySc0rpi0n

Função para verificar vitória em jogo

Recommended Posts

PsySc0rpi0n

Boas...

Estou aqui a tentar adaptar uma função para o que pretendo fazer, mas não consigo resolver uma parte.

A função verifica o tabuleiro do jogo do galo a ver se existe algum dos caracteres , X ou O, dispostos de forma a fazer os 3 em linha!

Como aloquei memória para a matriz usando a forma matrix[y + x * w], em que w é o número de colunas, estou a ter dificuldades em detectar vitória quando estão os caracteres dispostos na vertical.

Para o caso dos caracteres na horizontal, tenho o seguinte:

if(ptabuleiro[i * 11 + 1] != '_' &&
	ptabuleiro[i * 11 + 1] == ptabuleiro[i * 11 + DOIS] &&
	ptabuleiro[i * 11 + 1] == ptabuleiro[i * 11 + TRES]){
   printf("Mark 1\n");
   return ptabuleiro[i * 11 + 1] == psim ? -1 : 1;
}

O DOIS e o TRES é apenas para dizer que na verdade o 2 tem que ser um 5 e o TRES tem que ser um 9, porque a matriz não é 3 * 3 mas sim 3 * 12.

Isto porque eu quero que o desenho da matriz seja assim:

_01_|_05_|_09_

_12_|_16_|_20_

_23_|_27_|_31_

E portanto quando o jogador insere 2 para o X, na verdade na matriz será um 5. E quando o jogador insere um 3, na verdade é um 9!

Agora, não consigo fazer a verificação para as linhas verticais! Como hei-de fazer?

 


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
HappyHippyHippo

estás a misturar dados com apresentação
o que quero dizer é que é má implementação usar a matriz dessa forma somente devido à apresentação, porque nao é da responsabilidade dela saber como vais apresentar-la

no entanto, se pretendes então ter assim, o que deverias fazer seria:

#define MATRIX_SCANLINE 11
#define MATRIX_OFFSETS(col) (col == 0 ? 1 : (col == 1 ? 5 : 9))
#define MATRIX_CELL(m, x, y) (& (m)[(y) * MATRIX_SCANLINE + MATRIX_OFFSETS(x)])

int checkHorizontal(char * matrix) {
    return    MATRIX_CELL(matrix, 0, 0) == MATRIX_CELL(matrix, 1, 0) == MATRIX_CELL(matrix, 2, 0)
           || MATRIX_CELL(matrix, 0, 1) == MATRIX_CELL(matrix, 1, 1) == MATRIX_CELL(matrix, 2, 1)
           || MATRIX_CELL(matrix, 0, 2) == MATRIX_CELL(matrix, 1, 2) == MATRIX_CELL(matrix, 2, 2);
}

int checkVertical(char * matrix) {
    return    MATRIX_CELL(matrix, 0, 0) == MATRIX_CELL(matrix, 0, 1) == MATRIX_CELL(matrix, 0, 2)
           || MATRIX_CELL(matrix, 1, 0) == MATRIX_CELL(matrix, 1, 1) == MATRIX_CELL(matrix, 1, 2)
           || MATRIX_CELL(matrix, 2, 0) == MATRIX_CELL(matrix, 2, 1) == MATRIX_CELL(matrix, 2, 2);
}

int checkDiagonals(char * matrix) {
    return    MATRIX_CELL(matrix, 0, 0) == MATRIX_CELL(matrix, 1, 1) == MATRIX_CELL(matrix, 2, 2)
           || MATRIX_CELL(matrix, 2, 0) == MATRIX_CELL(matrix, 1, 1) == MATRIX_CELL(matrix, 0, 2);
}

int checkWin(char * matrix) {
    return    checkHorizontal(matrix)
           || checkVertical(matrix)
           || checkDiagonals(matrix);
}

 

  • Vote 1

IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
PsySc0rpi0n

E sem aqueles defines esquisitos?


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
thoga31
1 hora atrás, PsySc0rpi0n disse:

E sem aqueles defines esquisitos?

Os "defines esquisitos" são macros e são uma parte importante da linguagem C. Podes passá-los a funções.

Edited by thoga31
Correcção do erro ortográfico

Knowledge is free!

Share this post


Link to post
Share on other sites
PsySc0rpi0n
13 hours ago, thoga31 said:

Os "defines esquisitos" são macros e são uma parte importante da linguagem C. Podes passá-los a funções.

Sim, eu sei que são macros, para para mim não é fácil entendê-las! Até porque para usar isto agora desta maneira, tinha que alterar o meu código todo!


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
Flinger

Equivalem a um if -> else

#define MATRIX_OFFSETS(col) (col == 0 ? 1 : (col == 1 ? 5 : 9))

se col == 0 entao 1 senao

se col == 1 entao 5 senao 9

podes transformar isto numa função, int matrix_offsets(int col), que te devolve o índice da matriz onde tens o valor. 

Mas concordo com o Hippo, nem devias usar isso assim. É sempre desejável separar o mais possível a funcionalidade da interface.

Edited by Flinger

Share this post


Link to post
Share on other sites
PsySc0rpi0n

Essa eu percebi... Estava a falar da outra! xD


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
Flinger

:D tinha-me passado despercebida 

#define MATRIX_CELL(m, x, y) (& (m)[(y) * MATRIX_SCANLINE + MATRIX_OFFSETS(x)])

aqui acedes directamente à posição da matriz.

Uma matriz não passa de um array, onde gravas cada linha a seguir à outra. Ora se tens uma matriz X por Y, para aceder à posição [1][0] andas X posições para a frente. Neste caso, MATRIX_SCANLINE posições.

Para acederes à posição [1][1] andas MATRIX_SCANLINE posições + 1. para aceder à posição [2] [1] acedes ao elemento [MATRIX_SCANLINE * 2 +1], etc.

 Expandindo a macro, com MATRIX_CELL(matrix, 2, 2) ficas com 

(& (matrix)[(2) * MATRIX_SCANLINE + MATRIX_OFFSETS(2)]), 

(& (matrix)[(2) * 11 + 9]), 

o que é equivalente a matrix[2][9]

Edited by Flinger
  • Vote 1

Share this post


Link to post
Share on other sites
HappyHippyHippo

existe um erro no código que fiz, alguém consegue descobrir qual ?

dou até ao início da tarde


IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
Flinger

não tens por acaso o & a mais na macro MATRIX_CELL, não???

Não corri o código mas parece-me que como está estás a comparar apontadores e não os valores.

Share this post


Link to post
Share on other sites
HappyHippyHippo
1 hour ago, Flinger said:

Não corri o código mas parece-me que como está estás a comparar apontadores e não os valores.

sim, é isso, se bem que a remoção do & retira a funcinoalidade de atribuição de um valor ao resultado da macro function

tenho uma solução engraçada (que até acho já ter demonstrado num tópico semelhante à uns anos) mas tinha renitência em apresentar-la por ser ainda mais complexa,que resolve ainda outro bug

mas aqui vai :

#define SPACE   ' '
#define PLAYER1 'O'
#define PLAYER2 'X'

#define SCANLINE 11
#define OFFSETS(col) (col == 0 ? 1 : (col == 1 ? 5 : 9))
#define CELL(m, x, y) ((m)[(y) * SCANLINE + OFFSETS(x)])

int checkHorizontal(char * m) {
    return    ((CELL(m, 0, 0) + CELL(m, 1, 0) + CELL(m, 2, 0) == CELL(m, 0, 0) * 3) && (CELL(m, 0, 0) != SPACE))
           || ((CELL(m, 0, 1) + CELL(m, 1, 1) + CELL(m, 2, 1) == CELL(m, 0, 1) * 3) && (CELL(m, 0, 1) != SPACE))
           || ((CELL(m, 0, 2) + CELL(m, 1, 2) + CELL(m, 2, 2) == CELL(m, 0, 2) * 3) && (CELL(m, 0, 2) != SPACE));
}

int checkVertical(char * m) {
    return    ((CELL(m, 0, 0) + CELL(m, 0, 1) + CELL(m, 0, 2) == CELL(m, 0, 0) * 3) && (CELL(m, 0, 0) != SPACE))
           || ((CELL(m, 1, 0) + CELL(m, 1, 1) + CELL(m, 1, 2) == CELL(m, 1, 0) * 3) && (CELL(m, 1, 0) != SPACE))
           || ((CELL(m, 2, 0) + CELL(m, 2, 1) + CELL(m, 2, 2) == CELL(m, 2, 0) * 3) && (CELL(m, 2, 0) != SPACE));
}

int checkDiagonals(char * m) {
    return    ((CELL(m, 0, 0) + CELL(m, 1, 1) + CELL(m, 2, 2) == CELL(m, 0, 0) * 3) && (CELL(m, 0, 0) != SPACE))
           || ((CELL(m, 2, 0) + CELL(m, 1, 1) + CELL(m, 0, 2) == CELL(m, 0, 0) * 3) && (CELL(m, 2, 0) != SPACE));
}

int checkWin(char * m) {
    return    checkHorizontal(m)
           || checkVertical(m)
           || checkDiagonals(m);
}

int validCheck() {
  return    PLAYER1 != PLAYER2 + SPACE
         && PLAYER2 != PLAYER1 + SPACE;
}

int main(void) {
  char m[SCANLINE * 3];
  memset(m, ' ', SCANLINE * 3);

  if (!validCheck()) {
    printf("invalid check code for the selected tokens");
  }

  return 0;
}

 

  • Vote 1

IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
seuqram

I love your way of coding :]

Porque é que o array vai de index 4 a 4? Têm a ver com algum problema que envolva conversões de array de chars para array de inteiros e vice-versa?

Acrescento isto na função validCheck:

bool validCheck() {
  for(int i = 0; i < 3; i++)
  {
  	if(PLAYER1 == PLAYER2 * i + SPACE * (2 - i)
    || PLAYER2 == PLAYER1 * i + SPACE * (2 - i))return false;
  }
  return true;
}

 

Edited by seuqram

Share this post


Link to post
Share on other sites
PsySc0rpi0n

Isso é tudo muito lindo, mas não me estou a ver a alterar o que já tenho para incluir isto tudo!

Queria mesmo era usar a forma como eu estava a fazer originalmente para poder continuar com o que tenho! Senão assim, já sei que a coisa morre por aqui!


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
Flinger

Não conseguiste com o código do Hippo? É só substituíres as macros pela tua estrutura. partindo do princípio que também definiste "UM" como 1, para manter a coerência

int checkVertical(char * matrix) {
    return    pTabuleiro[0 * 12 + UM] == pTabuleiro[1 * 12 + UM] == pTabuleiro[2 * 12 + UM] != '_'
           || pTabuleiro[0 * 12 + DOIS] == pTabuleiro[1 * 12 + DOIS] == pTabuleiro[2 * 12 + DOIS] != '_'
           || pTabuleiro[0 * 12 + TRES] == pTabuleiro[1 * 12 + TRES] == pTabuleiro[2 * 12 + TRES] != '_'
}

 

Edited by Flinger
Adicionada verificação se não estão em branco

Share this post


Link to post
Share on other sites
PsySc0rpi0n

Ok, mas e porquê 12??? Eu tenho usado 11. Não percebi bem o 12. E com esse código, o loop que ue tenho não faz sentido. Mas preciso dele para as horizontais, certo?

Edited by PsySc0rpi0n

Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
Flinger

Desculpa é 11... Fiz de cabeça, pareceu-me que tinha visto que o comprimento da linha era 12.

Para a horizontal podes fazer igual a este, mas fixando a linha. Não faz muito sentido fazeres um loop para 3 posições, até porque o compilador vai provavelmente optimizar o código retirando o loop.

Edited by Flinger

Share this post


Link to post
Share on other sites
PsySc0rpi0n

E ainda outro pormenor. Isso vai retornar 0 ou 1. No entanto eu estava a devovler o -1 e o 1 que usava para identificar o jogador e devolvia 0 para o caso de empate e devolvia -2 caso ainda houvesse posições vazias!

Com esse código terei que reformular a função para manter as mesmas funcionalidades.


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
Flinger

ou então refazes estas funções, como:

int checkVertical(char * matrix) {
    int res=    pTabuleiro[0 * 12 + UM] == pTabuleiro[1 * 12 + UM] == pTabuleiro[2 * 12 + UM] != '_'
           || pTabuleiro[0 * 12 + DOIS] == pTabuleiro[1 * 12 + DOIS] == pTabuleiro[2 * 12 + DOIS] != '_'
           || pTabuleiro[0 * 12 + TRES] == pTabuleiro[1 * 12 + TRES] == pTabuleiro[2 * 12 + TRES] != '_'
	
	if (!res) return -1;
	else return 1;

}

 

Edited by Flinger

Share this post


Link to post
Share on other sites
PsySc0rpi0n

Ok, vou ver se consigo pôr isso a funcionar! Mas só depois de fazer um trabalho que aqui tenho! Sim, eu estou no meu trabalho! E fazer um programa par ajogar o ic tac toe não é o meu trabalho! xD


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
HappyHippyHippo

prontos ... se tens esses requisitos todos:

int checkHorizontal(char * m) {
    // para todas as linhas
    for (int line = 1; line < 3; ++line) {
        // verificar linha "line"
        if (   pTabuleiro[line * 11 + UM] == pTabuleiro[line * 11 + DOIS]
            && pTabuleiro[line * 11 + UM] == pTabuleiro[line * 11 + TRES]
            && pTabuleiro[line * 11 + UM] != '_')
            // retornar o valor associado ao vencedor
            return pTabuleiro[line * 11 + UM] == 'O' : -1 : 1;
    }

    return 0;
}

int checkVertical(char * m) {
    // para todas as colunas
    for (int column = UM; column <= TRES; ) {
        // verificar coluna "column"
        if (   pTabuleiro[0 * 11 + column] == pTabuleiro[1 * 11 + column]
            && pTabuleiro[0 * 11 + column] == pTabuleiro[2 * 11 + column]
            && pTabuleiro[0 * 11 + column] != '_')
            // retornar o valor associado ao vencedor
            return pTabuleiro[0 * 11 + column] == 'O' : -1 : 1;

        // incremneto do ciclo de coluna
        column = column == UM
                  ? DOIS
                  : (column == DOIS
                        ? TRES
                        : TRES + 1);
    }

    return 0;
}

int checkDiagonals(char * m) {
      // verificar diagonal principal
      if (   pTabuleiro[0 * 11 + UM] == pTabuleiro[1 * 11 + DOIS]
          && pTabuleiro[0 * 11 + UM] == pTabuleiro[2 * 11 + TRES]
          && pTabuleiro[0 * 11 + UM] != '_')
          // retornar o valor associado ao vencedor
          return pTabuleiro[0 * 11 + column] == 'O' : -1 : 1;

      // verificar diagonal secundaria
      if (   pTabuleiro[2 * 11 + UM] == pTabuleiro[1 * 11 + DOIS]
          && pTabuleiro[2 * 11 + UM] == pTabuleiro[0 * 11 + TRES]
          && pTabuleiro[2 * 11 + UM] != '_')
          // retornar o valor associado ao vencedor
          return pTabuleiro[0 * 11 + column] == 'O' : -1 : 1;

      return 0;
}

int checkWin(char * m) {
    // verificar vencedor
    int check =    checkHorizontal(m)
                || checkVertical(m)
                || checkDiagonals(m);
    if (check)
        return check;

    // verificar se existem espaços vazios
    for (int line; line < 3; ++line) {
        for (int column; column <= TRES; ) {
            // verificar se a célula iterada se encontra vazia
            if (pTabuleiro[line * 11 + column] == '_')
                return -2;

            // incremneto do ciclo de coluna
            column = column == UM
                      ? DOIS
                      : (column == DOIS
                            ? TRES
                            : TRES + 1);
        }
    }

    // empate ...
    return 0;
}

 

Edited by HappyHippyHippo
removed unacessary code

IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
PsySc0rpi0n

Tentei colocar o código a funcionar, mas algo nas funções de verificar as vitórias que não está a funcionar!

Alguém me ajuda a identificar?

O problema é que quando existe um vencedor, por alguma razão, é sempre o Jogador 2 e também acontece que nem sempre

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define CLEAR_INPUT while(getchar() != '\n') /*void*/

#define UM   1
#define DOIS 5
#define TRES 9


void MostraTabuleiro(char* ptabuleiro){
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 11; j++){
            printf("%c", ptabuleiro[j + i * 11]);
        }
        putchar('\n');
    }
}


char* AlocaMemoriaTabuleiro(char* tabuleiro){
    if( ( tabuleiro = malloc( sizeof(char) * 3 * sizeof(char)* 11 + 1) ) == NULL ){
        printf("Memory error!\n");
        exit(-1);
    }
    return tabuleiro;
}


void PedeCoord(int* pcx, int* pcy){
    int ok = 0;

    printf("Insira as coordenadas <x y>:\n");
    while(ok != 2){
        ok = scanf(" %d %d", pcx, pcy);
        if( (*pcx - 1 < 0)  || (*pcx - 1 > 2)  || (*pcy - 1 < 0) || (*pcy - 1 > 2) || ok != 2 ){
            printf("Coordenadas inválidas! Tente de novo:\n");
            ok = 0;
        }else if(*pcy == 2 ){
            (*pcx)--;
            *pcy = 5;
        }
        else if(*pcy == 3){
            (*pcx)--;
            *pcy = 9;
        }else
            (*pcx)--;
    }
}


int ActualizaTabuleiro(int* px, int* py, char* ptabuleiro, const char psim){
    if( ptabuleiro[*py + (*px) * 11] == '_' ? 1 : 0 ){//se caractér da posição for igual a '_', posição está livre
        ptabuleiro[*py + (*px) * 11] = psim;
        return 1;
    }else{
        printf("Posição ocupada!\n");
        return 0;
    }
}


void ResetTabuleiro(char* ptabuleiro){
    for(int i = 0; i < 3; i++)
        for(int j = 0; j < 11; j++)
            ptabuleiro[j + i * 11] = (j + 1) % 4 ? '_' : '|';
}

int VerificaHorizontal(char* ptabuleiro){
    for(int i = 0; i < 3; i++){
        if( ptabuleiro[i * 11 + UM] == ptabuleiro[i * 11 + DOIS]
         && ptabuleiro[i * 11 + UM] == ptabuleiro[i * 11 + TRES]
         && ptabuleiro[i * 11 + UM] != '_')
         return ptabuleiro[i * 11 + UM] == 'X' ? -1 : 1;
    }
    return 0;
}

int VerificaVertical(char* ptabuleiro){
    for(int i = UM; i < TRES; ){
        if( ptabuleiro[0 * 11 + i] == ptabuleiro[1 * 11 + i]
         && ptabuleiro[0 * 11 + i] == ptabuleiro[2 * 11 + i]
         && ptabuleiro[0 * 11 + i] != '_')
            return ptabuleiro[0 * 11 + i] == 'X' ? -1 : 1;
        i = i == UM ? DOIS : (i == DOIS ? TRES : TRES + 1);
    }
    return 0;
}

int VerificaDiagonal(char* ptabuleiro){
    if( ptabuleiro[0 * 11 + UM] == ptabuleiro[1 * 11 + DOIS]
     && ptabuleiro[0 * 11 + UM] == ptabuleiro[2 * 11 + TRES]
     && ptabuleiro[0 * 11 + UM] != '_')
        return ptabuleiro[0 * 11 + UM] == 'X' ? -1 : 1;
    if( ptabuleiro[0 * 11 + TRES] == ptabuleiro[1 * 11 + DOIS]
     && ptabuleiro[0 * 11 + TRES] == ptabuleiro[2 * 11 +   UM]
     && ptabuleiro[0 * 11 + TRES] != '_')
        return ptabuleiro[0 * 11 + UM] == 'X' ? -1 : 1;
    return 0;
}

int VerificaVitoria(char* ptabuleiro){
    int resultado = VerificaHorizontal(ptabuleiro)
                 || VerificaVertical(  ptabuleiro)
                 || VerificaDiagonal(  ptabuleiro);
    if(resultado){
        printf("Resultado: %d\n", resultado);//<------Está a retornar sempre 1, quando devia também retornar -1
        return resultado;
    }
    //procura espaços vazios
    for(int i = 0; i < 3; i++)
        for(int j = 0; j < 11; ){
            if(ptabuleiro[i * 11 + j] == '_')
                return -2;
            j = j == UM ? DOIS : (j == DOIS ? TRES : TRES + 1);
    }
    //empate
    return 0;
}

int Jogar2Jogadores(int* pcx, int* pcy, char* ptabuleiro){
    char psim = 'X';
    int jogador = 0, res, ok;
    printf("Jogador 1:\n");
    while(1){
        ok = VerificaVitoria(ptabuleiro);
        //printf("Verifica Vitória: %d\n", ok);
        switch(ok){
            //Não há vencedores e ainda há posições vazias
            case -2: PedeCoord(pcx, pcy);
                     res = ActualizaTabuleiro(pcx, pcy, ptabuleiro, psim);
                     //printf("Actualiza Tabuleiro: %d\n", res);
                     if(res){
                        jogador ^= 1;
                        //printf("Jogador: %d\n", !jogador);
                        psim = !jogador ? 'X' : '0';
                        //printf("Símbolo: %c\n", psim);
                        MostraTabuleiro(ptabuleiro);
                        printf("Vez: Jogador %d\n", jogador ? 2 : 1);
                     }
                     break;
            case -1: printf("Jodador 1 é o vencedor!\n");
                     return 0;
            case  0: printf("Jogo empatado!\n");
                     return 0;
            case  1: printf("Jogador 2 é o vencedor!\n");
                     return 0;
            default: printf("Erro desconhecido!\n");
                     free(ptabuleiro);
                     exit(-1);

        }
    }
}

int main(void){
    char* tabuleiro = NULL;
    int cx, cy;

    tabuleiro = AlocaMemoriaTabuleiro(tabuleiro);
    ResetTabuleiro(tabuleiro);
    Jogar2Jogadores(&cx,&cy, tabuleiro);
    free(tabuleiro);
    return 0;
}

 


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
HappyHippyHippo

é o que dá trabalhar com N linguagens .. começa a se misturar tudo

em C, os operadores lógicos resultam sempre em 0 ou 1, por isso para resolver a tua situação, basta trocar os operadores || que estão no função VerificaVitoria por somas e uns pós de perlim :D

no que toca a às vezes não conta, é porque não está a validar a última coluna

Edited by HappyHippyHippo

IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
PsySc0rpi0n
1 hour ago, HappyHippyHippo said:

é o que dá trabalhar com N linguagens .. começa a se misturar tudo

em C, os operadores lógicos resultam sempre em 0 ou 1, por isso para resolver a tua situação, basta trocar os operadores || que estão no função VerificaVitoria por somas e uns pós de perlim :D

no que toca a às vezes não conta, é porque não está a validar a última coluna

Não percebi o sublinhado!


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
HappyHippyHippo

compara bem a tua função de verificação vertical e a minha


IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
PsySc0rpi0n

Assim: ?? Ou seja, só pode haver ou uma vitória na vertical, ou uma na horizontal ou uma na diagonal, portanto aquela soma só pode dar ou -1 ou 1, certo???

0 + 0 + 0 = 0 <-- não entre no if

0 + 0 + 1 (ou -1) <-- entra no if porque é diferente de zero e resulta em -1 ou 1

0 + 1 (ou -1) + 0 <-- entra no if porque é diferente de zero e resulta em -1 ou 1

1  ou (-1) + 0 + 0 <-- entra no if porque é diferente de 0 e resulta em -1 ou 1

int VerificaVitoria(char* ptabuleiro){
	int resultado = VerificaHorizontal(ptabuleiro)
				  + VerificaVertical(  ptabuleiro)
				  + VerificaDiagonal(  ptabuleiro);
	if (!resultado)
		return resultado == -1 ? -1 : 1;
	//procura espaços vazios
	for(int i = 0; i < 3; i++)
		for(int j = 0; j < 11; ){
			if(ptabuleiro[i * 11 + j] == '_')
				return -2;
		j = j == UM ? DOIS : (j == DOIS ? TRES : TRES + 1);
	}
	//empate
	return 0;
}

A identação ficou toda lixada!


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.