main.cpp

00001 
00002 #define MINLINHA 1
00003 #define MAXLINHA 8
00004 #define MINCOLUNA 1
00005 #define MAXCOLUNA 8
00006 #define PEDRA_NORMAL_JOGADOR1 '1'
00007 #define PEDRA_NORMAL_JOGADOR2 '2'
00008 #define PEDRA_DAMA_JOGADOR1 '3'
00009 #define PEDRA_DAMA_JOGADOR2 '4'
00010 #define VAZIO 'S'
00011 #define JOGADA 'J'
00012 #define CAPTURADA 'C'
00013 #define BORDA "                    "
00014 
00015 #define VITORIAS 0
00016 #define EMPATES  1
00017 #define DERROTAS 2
00018 
00019 #define HUMANO1  '1'
00020 #define HUMANO2  '2'
00021 #define MAQUINA1 '3'
00022 #define MAQUINA2 '4'
00023 
00024 #define NOME_HUMANO1  "HUMANO1"
00025 #define NOME_HUMANO2  "HUMANO2"
00026 #define NOME_MAQUINA1 "MAQUINA1"
00027 #define NOME_MAQUINA2 "MAQUINA2"
00028 #define TAM_NOME 30
00029 
00030 #define ASCII_PEDRA_NORMAL 'O'
00031 #define ASCII_PEDRA_DAMA   'D'
00032 
00033 #define ENTER 13
00034 
00035 //#define __PC__ 1
00036 #define __EMBARCADO__ 1
00037 
00038 #ifdef __PC__
00039 #define _CRT_SECURE_NO_WARNINGS
00040 #include <stdio.h>
00041 #include <memory.h>
00042 #include <stdlib.h>
00043 #include <windows.h>
00044 #include <conio.h>
00045 #include <string.h>
00046 #define PRINTF _cprintf
00047 #define SLEEP  sleep
00048 #define FIM_DE_LINHA "\n"
00049 #define GETCHE _getche
00050 
00051 #define ASCII_BLOCK     219
00052 #define ASCII_BORDER_H  205
00053 #define ASCII_BORDER_V  186
00054 #define ASCII_BORDER_TL 201
00055 #define ASCII_BORDER_TR 187
00056 #define ASCII_BORDER_BL 200
00057 #define ASCII_BORDER_BR 188
00058 
00059 HANDLE hConsoleHandle;
00060 CONSOLE_SCREEN_BUFFER_INFO *ConsoleInfo;
00061 
00062 #define BACKGROUND_WHITE (BACKGROUND_GREEN|BACKGROUND_RED|BACKGROUND_BLUE)
00063 #define FOREGROUND_WHITE (FOREGROUND_GREEN|FOREGROUND_RED|FOREGROUND_BLUE)
00064 #define BACKGROUND_BLACK 0
00065 #define FOREGROUND_BLACK 0
00066 
00067 #define COR_FUNDO_BORDA BACKGROUND_BLUE
00068 #define COR_TEXTO_BORDA FOREGROUND_WHITE
00069 
00070 #define COR_FUNDO_CASA_SEM_PEDRA BACKGROUND_WHITE
00071 #define COR_TEXTO_CASA_SEM_PEDRA FOREGROUND_WHITE
00072 
00073 #define COR_FUNDO_CASA_COM_PEDRA BACKGROUND_GREEN
00074 #define COR_TEXTO_CASA_COM_PEDRA_VAZIO FOREGROUND_GREEN
00075 #define COR_TEXTO_CASA_COM_PEDRA_JOGADOR1 FOREGROUND_WHITE
00076 #define COR_TEXTO_CASA_COM_PEDRA_JOGADOR2 FOREGROUND_RED
00077 
00078 #define COR_FUNDO_CASA_COM_PEDRA_CAPTURADA (BACKGROUND_GREEN|BACKGROUND_INTENSITY)
00079 #define COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_VAZIO (BACKGROUND_GREEN|BACKGROUND_INTENSITY)
00080 #define COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR1 (COR_TEXTO_CASA_COM_PEDRA_JOGADOR1|BACKGROUND_INTENSITY)
00081 #define COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR2 (COR_TEXTO_CASA_COM_PEDRA_JOGADOR2|BACKGROUND_INTENSITY)
00082 
00083 #define COR_FUNDO_CASA_COM_PEDRA_JOGADA BACKGROUND_BLACK
00084 #define COR_TEXTO_CASA_COM_PEDRA_JOGADA_VAZIO BACKGROUND_BLACK
00085 #define COR_TEXTO_CASA_COM_PEDRA_JOGADA_JOGADOR1 COR_TEXTO_CASA_COM_PEDRA_JOGADOR1
00086 #define COR_TEXTO_CASA_COM_PEDRA_JOGADA_JOGADOR2 COR_TEXTO_CASA_COM_PEDRA_JOGADOR2
00087 
00088 #define COR_FUNDO_MENSAGEM BACKGROUND_BLACK
00089 #define COR_TEXTO_MENSAGEM FOREGROUND_WHITE
00090 
00091 
00092 #else
00093 #include "mbed.h"
00094 #include "Terminal.h"
00095 
00096 //Serial pc( USBTX, USBRX);
00097 Terminal term(USBTX, USBRX); // tx, rx
00098 //#define PRINTF pc.printf
00099 #define PRINTF term.printf
00100 #define SLEEP  Thread::wait
00101 #define FIM_DE_LINHA "\r\n"
00102 #define GETCHE pega_tecla_echo
00103 
00104 #define ASCII_BLOCK     219
00105 #define ASCII_BORDER_H  205
00106 #define ASCII_BORDER_V  186
00107 #define ASCII_BORDER_TL 201
00108 #define ASCII_BORDER_TR 187
00109 #define ASCII_BORDER_BL 200
00110 #define ASCII_BORDER_BR 188
00111 
00112 #define WHITE 0xFFFFFF
00113 #define WHITE_DIFERENCIADO 0x888888
00114 #define BLACK 0x000000
00115 #define GREEN 0x00FF00
00116 #define GREEN_DIFERENCIADO 0x008800
00117 #define BLUE 0x0000FF
00118 #define BLUE_DIFERENCIADO 0x000088
00119 #define RED 0xFF0000
00120 #define RED_DIFERENCIADO 0x880000
00121 
00122 #define COR_FUNDO_BORDA BLUE
00123 #define COR_TEXTO_BORDA WHITE
00124 
00125 #define COR_FUNDO_CASA_SEM_PEDRA WHITE
00126 #define COR_TEXTO_CASA_SEM_PEDRA WHITE
00127 
00128 #define COR_FUNDO_CASA_COM_PEDRA GREEN
00129 #define COR_TEXTO_CASA_COM_PEDRA_VAZIO GREEN
00130 #define COR_TEXTO_CASA_COM_PEDRA_JOGADOR1 WHITE
00131 #define COR_TEXTO_CASA_COM_PEDRA_JOGADOR2 RED
00132 
00133 #define COR_FUNDO_CASA_COM_PEDRA_CAPTURADA GREEN_DIFERENCIADO
00134 #define COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_VAZIO GREEN_DIFERENCIADO
00135 #define COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR1 WHITE_DIFERENCIADO
00136 #define COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR2 RED_DIFERENCIADO
00137 
00138 #define COR_FUNDO_CASA_COM_PEDRA_JOGADA BLACK
00139 #define COR_TEXTO_CASA_COM_PEDRA_JOGADA_VAZIO BLACK
00140 #define COR_TEXTO_CASA_COM_PEDRA_JOGADA_JOGADOR1 COR_TEXTO_CASA_COM_PEDRA_JOGADOR1
00141 #define COR_TEXTO_CASA_COM_PEDRA_JOGADA_JOGADOR2 COR_TEXTO_CASA_COM_PEDRA_JOGADOR2
00142 
00143 #define COR_FUNDO_MENSAGEM BLACK
00144 #define COR_TEXTO_MENSAGEM WHITE
00145 
00146 
00147 #endif
00148 
00149 char tabuleiro_controle[MAXLINHA][MAXCOLUNA], tabuleiro_jogada[MAXLINHA][MAXCOLUNA];
00150 int jogadas = 0;
00151 int jogada_em_que_ultima_pedra_capturada = 0;
00152 int jogada_em_que_ultima_pedra_nomal_movimentada = 0;
00153 int jogada_empate_lances_especiais = 0;
00154 int placar[4][3];
00155 //int numero_pedras_para_capturar = -1;
00156 
00157 int numero_pedras_capturadas_jogador1 = 0;
00158 int numero_pedras_capturadas_jogador2 = 0;
00159 
00160 int numero_pedras_capturadas_antes_jogador1 = 0;
00161 int numero_pedras_capturadas_antes_jogador2 = 0;
00162 
00163 #ifdef __EMBARCADO__
00164 
00165 char pega_tecla_echo(void) {
00166     char retorno;
00167     
00168     //retorno = pc.getc();
00169     retorno = term.getc();
00170     //pc.putc(retorno);
00171     term.putc(retorno);
00172     return retorno;
00173 }
00174 
00175 #endif
00176 
00177 void SELECIONA_COR(int cor_fundo, int cor_texto) {
00178 
00179 #ifdef __PC__
00180     SetConsoleTextAttribute(hConsoleHandle, cor_fundo | cor_texto);
00181 #else
00182     term.foreground(cor_texto);
00183     term.background(cor_fundo);
00184 #endif
00185 
00186 }
00187 
00188 void LOCATE(int coluna, int linha) {
00189 
00190 #ifdef __PC__
00191     COORD coordScreen;
00192 
00193     coordScreen.X = coluna;
00194     coordScreen.Y = linha;
00195     SetConsoleCursorPosition(hConsoleHandle, coordScreen);
00196 #else
00197     term.locate(coluna, linha);
00198 #endif
00199 
00200 }
00201 
00202 
00203 int lerIteiro(void) {
00204     
00205     char buffer[100+1];
00206     int indice;
00207     char lido;
00208     
00209     memset(buffer, 0, sizeof(buffer));
00210     
00211     for(indice = 0; indice < sizeof(buffer) - 1; ++indice) {
00212         lido = GETCHE();
00213         
00214         if(lido == ENTER) {
00215             break;
00216         } else {
00217             buffer[indice] = lido;
00218         }
00219     }
00220     
00221     return(atoi(buffer));
00222 }
00223 
00224 #ifdef __PC__
00225 
00226 void cls(HANDLE hConsole)
00227 {
00228     COORD coordScreen = { 0, 0 };    /* here's where we'll home the
00229                                      cursor */
00230     BOOL bSuccess;
00231     DWORD cCharsWritten;
00232     CONSOLE_SCREEN_BUFFER_INFO csbi; /* to get buffer info */
00233     DWORD dwConSize;                 /* number of character cells in
00234                                      the current buffer */
00235 
00236                                      /* get the number of character cells in the current buffer */
00237 
00238     SetConsoleTextAttribute(hConsoleHandle, ConsoleInfo->wAttributes);
00239 
00240     bSuccess = GetConsoleScreenBufferInfo(hConsole, &csbi);
00241     dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
00242 
00243     /* fill the entire screen with blanks */
00244 
00245     bSuccess = FillConsoleOutputCharacter(hConsole, (TCHAR) ' ',
00246         dwConSize, coordScreen, &cCharsWritten);
00247 
00248     /* get the current text attribute */
00249 
00250     bSuccess = GetConsoleScreenBufferInfo(hConsole, &csbi);
00251 
00252     /* now set the buffer's attributes accordingly */
00253 
00254     bSuccess = FillConsoleOutputAttribute(hConsole, csbi.wAttributes,
00255         dwConSize, coordScreen, &cCharsWritten);
00256 
00257     /* put the cursor at (0, 0) */
00258 
00259     bSuccess = SetConsoleCursorPosition(hConsole, coordScreen);
00260     return;
00261 }
00262 
00263 void LimparTela(void) {
00264     //system("CLS");
00265     cls(hConsoleHandle);
00266 }
00267 
00268 #else
00269     
00270 void LimparTela(void) {
00271     //PRINTF("\033[2J\033[1;1H");
00272     //PRINTF("\e[1;1H\e[2J");
00273     term.cls();
00274 }
00275 
00276 #endif
00277 
00278 char * retorna_nome_jogador(char opcao1, char *nome) {
00279 
00280     switch (opcao1) {
00281         case HUMANO1:
00282             strcpy(nome, NOME_HUMANO1);
00283             break;
00284         case HUMANO2:
00285             strcpy(nome, NOME_HUMANO2);
00286             break;
00287         case MAQUINA1:
00288             strcpy(nome, NOME_MAQUINA1);
00289             break;
00290         case MAQUINA2:
00291             strcpy(nome, NOME_MAQUINA2);
00292             break;
00293     }
00294 
00295     return nome;
00296 }
00297 
00298 char * retorna_nome_jogador_tipo_jogo(int indice, char opcao1, char *nome) {
00299 
00300     switch(opcao1) {
00301         case '1':
00302             if(indice == 1) {
00303                 strcpy(nome, NOME_HUMANO1);
00304             } else {
00305                 strcpy(nome, NOME_HUMANO2);
00306             }
00307             break;
00308         case '2':
00309             if(indice == 1) {
00310                 strcpy(nome, NOME_HUMANO1);
00311             } else {
00312                 strcpy(nome, NOME_MAQUINA1);
00313             }
00314             break;
00315         case '3':
00316             if(indice == 1) {
00317                 strcpy(nome, NOME_MAQUINA1);
00318             } else {
00319                 strcpy(nome, NOME_MAQUINA2);
00320             }
00321             break;
00322     }
00323     
00324     return nome;
00325 }
00326 
00327 char retorna_jogador(int indice, char opcao1) {
00328     
00329     char jogador;
00330 
00331     switch(opcao1) {
00332         case '1':
00333             if(indice == 1) {
00334                 jogador = HUMANO1;
00335             } else {
00336                 jogador = HUMANO2;
00337             }
00338             break;
00339         case '2':
00340             if(indice == 1) {
00341                 jogador = HUMANO1;
00342             } else {
00343                 jogador = MAQUINA1;
00344             }
00345             break;
00346         case '3':
00347             if(indice == 1) {
00348                 jogador = MAQUINA1;
00349             } else {
00350                 jogador = MAQUINA2;
00351             }
00352             break;
00353     }
00354     
00355     return jogador;
00356 }
00357 
00358 void imprime_placar(void) {
00359     
00360     char nome[TAM_NOME + 1];
00361     int indice, tamanho;
00362 
00363     LimparTela();
00364 
00365     SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
00366     LOCATE(10, 1);
00367     PRINTF("PLACAR%s", FIM_DE_LINHA);
00368     PRINTF("%- *.*s|VITORIAS|EMPATES|DERROTAS%s", TAM_NOME, TAM_NOME, "JOGADOR", FIM_DE_LINHA);
00369     
00370     tamanho = TAM_NOME + 1 + strlen("VITORIAS") + 1 + strlen("EMPATES") + 1 + strlen("DERROTAS");
00371 
00372     for (indice = 0; indice < tamanho; ++indice) {
00373         PRINTF("%c", ASCII_BORDER_H);
00374     }
00375     PRINTF("%s", FIM_DE_LINHA);
00376 
00377 
00378 
00379     SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR1);
00380     PRINTF("%- *.*s|%0*d|%0*d|%0*d%s", 
00381         TAM_NOME, TAM_NOME, retorna_nome_jogador(HUMANO1, nome), 
00382         strlen("VITORIAS"), placar[HUMANO1 - '1'][VITORIAS],
00383         strlen("EMPATES"), placar[HUMANO1 - '1'][EMPATES],
00384         strlen("DERROTAS"), placar[HUMANO1 - '1'][DERROTAS], FIM_DE_LINHA);
00385     SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR2);
00386     PRINTF("%- *.*s|%0*d|%0*d|%0*d%s",
00387         TAM_NOME, TAM_NOME, retorna_nome_jogador(HUMANO2, nome),
00388         strlen("VITORIAS"), placar[HUMANO2 - '1'][VITORIAS],
00389         strlen("EMPATES"), placar[HUMANO2 - '1'][EMPATES],
00390         strlen("DERROTAS"), placar[HUMANO2 - '1'][DERROTAS], FIM_DE_LINHA);
00391 #if 0
00392     SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR1);
00393     PRINTF("%- *.*s|%0*d|%0*d|%0*d%s",
00394         TAM_NOME, TAM_NOME, retorna_nome_jogador(MAQUINA1, nome),
00395         strlen("VITORIAS"), placar[MAQUINA1 - '1'][VITORIAS],
00396         strlen("EMPATES"), placar[MAQUINA1 - '1'][EMPATES],
00397         strlen("DERROTAS"), placar[MAQUINA1 - '1'][DERROTAS], FIM_DE_LINHA);
00398     SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR2);
00399     PRINTF("%- *.*s|%0*d|%0*d|%0*d%s",
00400         TAM_NOME, TAM_NOME, retorna_nome_jogador(MAQUINA2, nome),
00401         strlen("VITORIAS"), placar[MAQUINA2 - '1'][VITORIAS],
00402         strlen("EMPATES"), placar[MAQUINA2 - '1'][EMPATES],
00403         strlen("DERROTAS"), placar[MAQUINA2 - '1'][DERROTAS], FIM_DE_LINHA);
00404 #endif
00405 
00406     SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
00407     PRINTF("%s", FIM_DE_LINHA);
00408     PRINTF("Pressione <Qualquer Tecla>");
00409     GETCHE();
00410 }
00411 
00412 
00413 void ImprimeMenu(char &jogador1, char &jogador2) {
00414     
00415     char opcao1, opcao2;
00416     int indice;
00417     char nome[TAM_NOME + 1];
00418     
00419     do {
00420         LimparTela();
00421         SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
00422         PRINTF("1 - %s  X %s%s", NOME_HUMANO1, NOME_HUMANO2, FIM_DE_LINHA);
00423 #if 0
00424         PRINTF("2 - %s  X %s%s", NOME_HUMANO1, NOME_MAQUINA1, FIM_DE_LINHA);
00425         PRINTF("3 - %s X %s%s",  NOME_MAQUINA1, NOME_MAQUINA2, FIM_DE_LINHA);
00426 #endif
00427         //PRINTF("4 - PLACAR%s", FIM_DE_LINHA);
00428         PRINTF("2 - PLACAR%s", FIM_DE_LINHA);
00429         
00430         opcao1 = GETCHE();
00431         
00432         //if(opcao1 == '4') {
00433         if (opcao1 == '2') {
00434             imprime_placar();
00435         }
00436         
00437     } while( opcao1 < '1'  || opcao1 > '1' );
00438     
00439     do {
00440         indice = 0;
00441         LimparTela();
00442         ++indice;
00443         SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
00444         PRINTF("%d - %s INICIA O JOGO%s", indice, retorna_nome_jogador_tipo_jogo(indice, opcao1, nome), FIM_DE_LINHA);
00445         ++indice;
00446         PRINTF("%d - %s INICIA O JOGO%s", indice, retorna_nome_jogador_tipo_jogo(indice, opcao1, nome), FIM_DE_LINHA);
00447         
00448         opcao2 = GETCHE();
00449     } while( opcao2 < '1'  || opcao2 > '2' );
00450     
00451     if(opcao2 == '1') {
00452         jogador1 = retorna_jogador(1, opcao1);
00453         jogador2 = retorna_jogador(2, opcao1);
00454     } else {
00455         jogador1 = retorna_jogador(2, opcao1);
00456         jogador2 = retorna_jogador(1, opcao1);
00457     }
00458 
00459     LimparTela();
00460     
00461 }
00462 
00463 void InicializarTabuleiro(char jogador_que_inicia, char segundo_jogador) {
00464     
00465     int indice1, indice2;
00466     
00467     memset(tabuleiro_jogada, VAZIO, sizeof(tabuleiro_controle));
00468     
00469     for(indice1 = 0; indice1 < MAXCOLUNA; ++indice1) {
00470         //for(indice2 = 0; indice2 < ((MAXLINHA/2)-1); ++indice2) {
00471         for (indice2 = 0; indice2 < 1; ++indice2) {
00472             if( (indice2 == 0) || (indice2 == 2) ){
00473                 if((indice1%2) == 1) {
00474                     tabuleiro_jogada[indice2][indice1] = segundo_jogador;
00475                 }
00476             } else {
00477                 if((indice1%2) == 0) {
00478                     tabuleiro_jogada[indice2][indice1] = segundo_jogador;
00479                 }
00480             }
00481         }
00482     }
00483     
00484     for(indice1 = 0; indice1 < MAXCOLUNA; ++indice1) {
00485         for(indice2 = (MAXLINHA - 1); indice2 > (MAXLINHA/2); --indice2) {
00486             if(indice2 == 6){
00487                 if((indice1%2) == 1) {
00488                     tabuleiro_jogada[indice2][indice1] = jogador_que_inicia;
00489                 }
00490             } else {
00491                 if((indice1%2) == 0) {
00492                     tabuleiro_jogada[indice2][indice1] = jogador_que_inicia;
00493                 }
00494             }
00495         }
00496     }
00497     
00498     memcpy(tabuleiro_controle, tabuleiro_jogada, sizeof(tabuleiro_jogada));
00499 }
00500 
00501 void ImprimirTabuleiro(char jogador1, char jogador2) {
00502     
00503     char nome1[TAM_NOME + 1];
00504     char nome2[TAM_NOME + 1];
00505     int linha, coluna;
00506 
00507     LimparTela();
00508     SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
00509 
00510     LOCATE(10, 1);
00511     PRINTF("PARTIDA DE DAMAS ");
00512     SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_CASA_COM_PEDRA_JOGADOR1);
00513     PRINTF("%s", retorna_nome_jogador(jogador1, nome1));
00514     SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
00515     PRINTF("(%d) VERSUS ", numero_pedras_capturadas_jogador1);
00516     SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_CASA_COM_PEDRA_JOGADOR2);
00517     PRINTF("%s", retorna_nome_jogador(jogador2, nome2));
00518     SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
00519     PRINTF("(%d) % s", numero_pedras_capturadas_jogador2, FIM_DE_LINHA);
00520 
00521     SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
00522     PRINTF("%s", BORDA);
00523 
00524     SELECIONA_COR(COR_FUNDO_BORDA, COR_TEXTO_BORDA);
00525     PRINTF("  12345678 %s", FIM_DE_LINHA);
00526 
00527     SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
00528     PRINTF("%s", BORDA);
00529 
00530     SELECIONA_COR(COR_FUNDO_BORDA, COR_TEXTO_BORDA);
00531     PRINTF(" %c", ASCII_BORDER_TL);
00532     for (coluna = 0; coluna < MAXCOLUNA; ++coluna) {
00533         PRINTF("%c", ASCII_BORDER_H);
00534     }
00535     PRINTF("%c%s", ASCII_BORDER_TR, FIM_DE_LINHA);
00536 
00537     for (linha = 0; linha < MAXLINHA; ++linha) {
00538 
00539         SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
00540         PRINTF("%s", BORDA);
00541 
00542         SELECIONA_COR(COR_FUNDO_BORDA, COR_TEXTO_BORDA);
00543         PRINTF("%d%c", linha + 1, ASCII_BORDER_V);
00544         if (linha % 2 == 0) {
00545             // Este tipo de linha comeca com um tipo de casa na qual 
00546             //  as pedras nao podem se movimentar
00547             for (coluna = 0; coluna < MAXCOLUNA; ++coluna) {
00548                 if (coluna % 2 == 0) {
00549                     SELECIONA_COR(COR_FUNDO_CASA_SEM_PEDRA, COR_TEXTO_CASA_SEM_PEDRA);
00550                     PRINTF(" ");
00551                 }
00552                 else {
00553                     switch (tabuleiro_jogada[linha][coluna]) {
00554                         case PEDRA_NORMAL_JOGADOR1:
00555                             SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR1);
00556                             PRINTF("%c", ASCII_PEDRA_NORMAL);
00557                             break;
00558                         case PEDRA_NORMAL_JOGADOR2:
00559                             SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR2);
00560                             PRINTF("%c", ASCII_PEDRA_NORMAL);
00561                             break;
00562                         case PEDRA_DAMA_JOGADOR1:
00563                             SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR1);
00564                             PRINTF("%c", ASCII_PEDRA_DAMA);
00565                             break;
00566                         case PEDRA_DAMA_JOGADOR2:
00567                             SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR2);
00568                             PRINTF("%c", ASCII_PEDRA_DAMA);
00569                             break;
00570                         case VAZIO:
00571                             SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_VAZIO);
00572                             PRINTF(" ");
00573                             break;
00574                         case JOGADA:
00575                             SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA_JOGADA, COR_TEXTO_CASA_COM_PEDRA_JOGADA_VAZIO);
00576                             PRINTF(" ");
00577                             break;
00578                         case CAPTURADA:
00579                             switch (tabuleiro_controle[linha][coluna]) {
00580                                 case PEDRA_NORMAL_JOGADOR1:
00581                                     SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA_CAPTURADA, COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR1);
00582                                     PRINTF("%c", ASCII_PEDRA_NORMAL);
00583                                     break;
00584                                 case PEDRA_DAMA_JOGADOR1:
00585                                     SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA_CAPTURADA, COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR1);
00586                                     PRINTF("%c", ASCII_PEDRA_DAMA);
00587                                     break;
00588                                 case PEDRA_NORMAL_JOGADOR2:
00589                                     SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA_CAPTURADA, COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR2);
00590                                     PRINTF("%c", ASCII_PEDRA_NORMAL);
00591                                     break;
00592                                 case PEDRA_DAMA_JOGADOR2:
00593                                     SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA_CAPTURADA, COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR2);
00594                                     PRINTF("%c", ASCII_PEDRA_DAMA);
00595                                     break;
00596                             }
00597                             break;
00598                     }
00599                 }
00600             }
00601             SELECIONA_COR(COR_FUNDO_BORDA, COR_TEXTO_BORDA);
00602             PRINTF("%c", ASCII_BORDER_V);
00603             PRINTF("%s", FIM_DE_LINHA);
00604         }
00605         else {
00606             // Este tipo de linha comeca com um tipo de casa na qual 
00607             //  as pedras podem se movimentar
00608             for (coluna = 0; coluna < MAXCOLUNA; ++coluna) {
00609                 if (coluna % 2 == 1) {
00610                     SELECIONA_COR(COR_FUNDO_CASA_SEM_PEDRA, COR_TEXTO_CASA_SEM_PEDRA);
00611                     PRINTF(" ");
00612                 }
00613                 else {
00614                     switch (tabuleiro_jogada[linha][coluna]) {
00615                     case PEDRA_NORMAL_JOGADOR1:
00616                         SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR1);
00617                         PRINTF("%c", ASCII_PEDRA_NORMAL);
00618                         break;
00619                     case PEDRA_NORMAL_JOGADOR2:
00620                         SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR2);
00621                         PRINTF("%c", ASCII_PEDRA_NORMAL);
00622                         break;
00623                     case PEDRA_DAMA_JOGADOR1:
00624                         SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR1);
00625                         PRINTF("%c", ASCII_PEDRA_DAMA);
00626                         break;
00627                     case PEDRA_DAMA_JOGADOR2:
00628                         SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_JOGADOR2);
00629                         PRINTF("%c", ASCII_PEDRA_DAMA);
00630                         break;
00631                     case VAZIO:
00632                         SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA, COR_TEXTO_CASA_COM_PEDRA_VAZIO);
00633                         PRINTF(" ");
00634                         break;
00635                     case JOGADA:
00636                         SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA_JOGADA, COR_TEXTO_CASA_COM_PEDRA_JOGADA_VAZIO);
00637                         PRINTF(" ");
00638                         break;
00639                     case CAPTURADA:
00640                         switch (tabuleiro_controle[linha][coluna]) {
00641                         case PEDRA_NORMAL_JOGADOR1:
00642                             SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA_CAPTURADA, COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR1);
00643                             PRINTF("%c", ASCII_PEDRA_NORMAL);
00644                             break;
00645                         case PEDRA_DAMA_JOGADOR1:
00646                             SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA_CAPTURADA, COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR1);
00647                             PRINTF("%c", ASCII_PEDRA_DAMA);
00648                             break;
00649                         case PEDRA_NORMAL_JOGADOR2:
00650                             SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA_CAPTURADA, COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR2);
00651                             PRINTF("%c", ASCII_PEDRA_NORMAL);
00652                             break;
00653                         case PEDRA_DAMA_JOGADOR2:
00654                             SELECIONA_COR(COR_FUNDO_CASA_COM_PEDRA_CAPTURADA, COR_TEXTO_CASA_COM_PEDRA_CAPTURADA_JOGADOR2);
00655                             PRINTF("%c", ASCII_PEDRA_DAMA);
00656                             break;
00657                         }
00658                         break;
00659                     }
00660                 }
00661             }
00662             SELECIONA_COR(COR_FUNDO_BORDA, COR_TEXTO_BORDA);
00663             PRINTF("%c", ASCII_BORDER_V);
00664             PRINTF("%s", FIM_DE_LINHA);
00665         }
00666     }
00667 
00668     SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
00669     PRINTF("%s", BORDA);
00670 
00671     SELECIONA_COR(COR_FUNDO_BORDA, COR_TEXTO_BORDA);
00672     PRINTF(" %c", ASCII_BORDER_BL);
00673     for (coluna = 0; coluna < MAXCOLUNA; ++coluna) {
00674         PRINTF("%c", ASCII_BORDER_H);
00675     }
00676     PRINTF("%c%s", ASCII_BORDER_BR, FIM_DE_LINHA);
00677 }
00678 
00679 // 0 - Movimento simples
00680 // 1 - Movimento com multiplas capturas
00681 int Movimento_Multiplo(void) {
00682 
00683     int linha, coluna;
00684 
00685     return 0;
00686 
00687     for (linha = 0; linha < MAXLINHA; ++linha) {
00688         for (coluna = 0; coluna < MAXCOLUNA; ++coluna) {
00689             if (tabuleiro_jogada[linha][coluna] == JOGADA) {
00690                 // nao pode jogar sem capturar em uma jogada com multiplas capturas
00691                 return 1;
00692             }
00693         }
00694     }
00695     return 0;
00696 }
00697 
00698 // 0 - Movimento de pedra simples nao eh para traz
00699 // 1 - Movimento de pedra simples eh para traz
00700 int Movimento_Para_Traz(int linha_origem, int linha_destino, char jogador1, char jogador_vez) {
00701 
00702     int retorno = 0;
00703 
00704     // O jogador 1 sempre começa o jogo e ele sempre inicia a partir da parte de baixo do tabuleiro
00705     if (jogador_vez == jogador1) {
00706         if ((linha_origem - linha_destino) <= 0) {
00707             retorno = 1;
00708         }
00709     }
00710     else {
00711         if ((linha_destino - linha_origem) <= 0) {
00712             retorno = 1;
00713         }
00714     }
00715 
00716     return retorno;
00717 }
00718 
00719 // retorna numero de pedras que faltam capturar
00720 int Existe_Pedra_Para_Capturar(void) {
00721 
00722     return 0;
00723 #if 0
00724     if ( (numero_pedras_para_capturar == -1) || (numero_pedras_para_capturar == 0) ) {
00725         return 0;
00726     }
00727     return numero_pedras_para_capturar;
00728 #endif
00729 }
00730 
00731 char Posiciona_Pedra(int linha_origem, int coluna_origem, int linha_destino, int coluna_destino, char jogador_vez, char jogador1) {
00732     char retorno;
00733 
00734     // O jogador 1 sempre começa o jogo e ele sempre inicia a partir da parte de baixo do tabuleiro
00735     if (jogador_vez == jogador1) {
00736         //if ( (linha_destino == (MINLINHA - 1)) && ( (numero_pedras_para_capturar == -1) || (numero_pedras_para_capturar == 0)) ) {
00737         if (linha_destino == (MINLINHA - 1)) {
00738             retorno = PEDRA_DAMA_JOGADOR1;
00739         }
00740         else {
00741             retorno = tabuleiro_jogada[linha_origem][coluna_origem];
00742         }
00743     }
00744     else {
00745         //if ((linha_destino == (MAXLINHA - 1)) && ((numero_pedras_para_capturar == -1) || (numero_pedras_para_capturar == 0))) {
00746         if (linha_destino == (MAXLINHA - 1)) {
00747             retorno = PEDRA_DAMA_JOGADOR2;
00748         }
00749         else {
00750             retorno = tabuleiro_jogada[linha_origem][coluna_origem];
00751         }
00752     }
00753 
00754     return retorno;
00755 }
00756 
00757 // 0 - Esta no caminho maximo de captura
00758 // 1 - Nao esta no caminho maximo de captura
00759 int Caminho_Maximo_Captura(int linha_origem, int coluna_origem, int linha_destino, int coluna_destino) {
00760     // @todo fazer funcao
00761     //int retorno = 1;
00762     int retorno = 0;
00763 
00764     return retorno;
00765 }
00766 
00767 void Calcula_Quantidade_Maxima_Capturas(char jogador_vez, char jogador1, char jogador2) {
00768 
00769     // @todo fazer funcao
00770 
00771     return;
00772 
00773     //if (numero_pedras_para_capturar > 0) {
00774     //    return;  // funcao ja foi executada
00775     //}
00776 
00777 }
00778 
00779 void contabiliza_pedra(char jogador_vez, char jogador1, char jogador2) {
00780 
00781     if (jogador_vez == jogador1) {
00782         ++numero_pedras_capturadas_jogador1;
00783     }
00784     else {
00785         ++numero_pedras_capturadas_jogador2;
00786     }
00787 }
00788 
00789 // 0 - Movimento Invalido
00790 // 1 - Movimento Valido
00791 int Movimento_Valido(int &linha_origem, int &coluna_origem, int &linha_destino, int &coluna_destino, char jogador_vez, char jogador1, char jogador2) {
00792 
00793     char pedra_normal = 1;
00794     char pedra_normal_oponente;
00795     char pedra_dama_oponente;
00796     char pedra_normal_jogador;
00797     char pedra_dama_jogador;
00798     int  unidade_linha, unidade_coluna, linha_aux, coluna_aux, pedras_capturadas;
00799     int  linha_pedra_capturada, coluna_pedra_capturada;
00800 
00801     // Valida se existe uma pedra deste jogador no tabuleiro de jogada na posicao de origem.
00802     // O tabuleiro de jogada server para guardar a memoria de uma jogada com multiplas capturas, 
00803     //  por isso que´eh utilizado para validar as jogadas.
00804     if (jogador_vez == jogador1) {
00805         pedra_normal_jogador = PEDRA_NORMAL_JOGADOR1;
00806         pedra_dama_jogador = PEDRA_DAMA_JOGADOR1;
00807         pedra_normal_oponente = PEDRA_NORMAL_JOGADOR2;
00808         pedra_dama_oponente = PEDRA_DAMA_JOGADOR2;
00809         if (tabuleiro_jogada[linha_origem][coluna_origem] == PEDRA_NORMAL_JOGADOR1) {
00810         } else if (tabuleiro_jogada[linha_origem][coluna_origem] == PEDRA_DAMA_JOGADOR1) {
00811             pedra_normal = 0;
00812         } else {
00813             return 0; // pedra nao pertence ao jogador
00814         }
00815     }
00816     else {
00817         pedra_normal_jogador = PEDRA_NORMAL_JOGADOR2;
00818         pedra_dama_jogador = PEDRA_DAMA_JOGADOR2;
00819         pedra_normal_oponente = PEDRA_NORMAL_JOGADOR1;
00820         pedra_dama_oponente = PEDRA_DAMA_JOGADOR1;
00821         if (tabuleiro_jogada[linha_origem][coluna_origem] == PEDRA_NORMAL_JOGADOR2) {
00822         } else if (tabuleiro_jogada[linha_origem][coluna_origem] == PEDRA_DAMA_JOGADOR2) {
00823             pedra_normal = 0;
00824         }
00825         else {
00826             return 0; // pedra nao pertence ao jogador
00827         }
00828     }
00829 
00830     Calcula_Quantidade_Maxima_Capturas(jogador_vez, jogador1, jogador2);
00831 
00832     if (pedra_normal) {
00833         // pedra jogada eh normal
00834         // valida se a coordenada de destino eh valida para uma captura
00835         if ((linha_origem - linha_destino) == 2) { 
00836             if ((coluna_origem - coluna_destino) == 2) {
00837                 if (Caminho_Maximo_Captura(linha_origem, coluna_origem, linha_destino, coluna_destino)) {
00838                     return 0; // Eh obrigatorio executar a jogada que 
00839                               //   captura o maximo de pedras do adversario
00840                 }
00841                 // diagonal para cima e para esquerda 
00842                 if ( (tabuleiro_jogada[linha_destino][coluna_destino] == VAZIO) || 
00843                      (tabuleiro_jogada[linha_destino][coluna_destino] == JOGADA) ) { // a posicao destino deve estar vazia ou foi uma jogada 
00844                     if (tabuleiro_jogada[linha_destino + 1][coluna_destino + 1] == pedra_normal_oponente) {
00845                         // pedra normal do oponente capturada
00846                         tabuleiro_jogada[linha_destino + 1][coluna_destino + 1] = CAPTURADA;
00847                         //--numero_pedras_para_capturar;
00848                         contabiliza_pedra(jogador_vez, jogador1, jogador2);
00849                         jogada_em_que_ultima_pedra_capturada = jogadas + 1;
00850                         tabuleiro_jogada[linha_destino][coluna_destino] = 
00851                             Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino, 
00852                                 jogador_vez, jogador1);
00853                         tabuleiro_jogada[linha_origem][coluna_origem] = JOGADA;
00854                     }
00855                     else if (tabuleiro_jogada[linha_destino + 1][coluna_destino + 1] == pedra_dama_oponente) {
00856                         // pedra dama do oponente capturada
00857                         tabuleiro_jogada[linha_destino + 1][coluna_destino + 1] = CAPTURADA;
00858                         //--numero_pedras_para_capturar;
00859                         contabiliza_pedra(jogador_vez, jogador1, jogador2);
00860                         jogada_em_que_ultima_pedra_capturada = jogadas + 1;
00861                         tabuleiro_jogada[linha_destino][coluna_destino] =
00862                             Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
00863                                 jogador_vez, jogador1);
00864                         tabuleiro_jogada[linha_origem][coluna_origem] = JOGADA;
00865                     }
00866                     else {
00867                         // pedra capturada invalida!!
00868                         return 0;
00869                     }
00870                 }
00871                 else {
00872                     return 0;  // casa destino ocupada!!
00873                 }
00874             }
00875             else if ((coluna_destino - coluna_origem) == 2) {
00876                 if (Caminho_Maximo_Captura(linha_origem, coluna_origem, linha_destino, coluna_destino)) {
00877                     return 0; // Eh obrigatorio executar a jogada que 
00878                               //   captura o maximo de pedras do adversario
00879                 }
00880                 // diagonal para cima e para direita
00881                 if ((tabuleiro_jogada[linha_destino][coluna_destino] == VAZIO) ||
00882                     (tabuleiro_jogada[linha_destino][coluna_destino] == JOGADA)) { // a posicao destino deve estar vazia ou foi uma jogada 
00883                     if (tabuleiro_jogada[linha_destino + 1][coluna_destino - 1] == pedra_normal_oponente) {
00884                         // pedra normal do oponente capturada
00885                         tabuleiro_jogada[linha_destino + 1][coluna_destino - 1] = CAPTURADA;
00886                         //--numero_pedras_para_capturar;
00887                         contabiliza_pedra(jogador_vez, jogador1, jogador2);
00888                         jogada_em_que_ultima_pedra_capturada = jogadas + 1;
00889                         tabuleiro_jogada[linha_destino][coluna_destino] =
00890                             Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
00891                                 jogador_vez, jogador1);
00892                         tabuleiro_jogada[linha_origem][coluna_origem] = JOGADA;
00893                     }
00894                     else if (tabuleiro_jogada[linha_destino + 1][coluna_destino - 1] == pedra_dama_oponente) {
00895                         // pedra dama do oponente capturada
00896                         tabuleiro_jogada[linha_destino + 1][coluna_destino - 1] = CAPTURADA;
00897                         //--numero_pedras_para_capturar;
00898                         contabiliza_pedra(jogador_vez, jogador1, jogador2);
00899                         jogada_em_que_ultima_pedra_capturada = jogadas + 1;
00900                         tabuleiro_jogada[linha_destino][coluna_destino] =
00901                             Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
00902                                 jogador_vez, jogador1);
00903                         tabuleiro_jogada[linha_origem][coluna_origem] = JOGADA;
00904                     }
00905                     else {
00906                         // pedra capturada invalida!!
00907                         return 0;
00908                     }
00909                 }
00910                 else {
00911                     // casa destino ocupada!!
00912                     return 0;
00913                 }
00914             }
00915             else {
00916                 // uma jogada de uma pedra normal apenas pode capturar uma pedra para esquerda ou para direita em diagonal
00917                 return 0;
00918             }
00919         } else if ((linha_destino - linha_origem) == 2) {
00920             if ((coluna_origem - coluna_destino) == 2) {
00921                 if (Caminho_Maximo_Captura(linha_origem, coluna_origem, linha_destino, coluna_destino)) {
00922                     return 0; // Eh obrigatorio executar a jogada que 
00923                               //   captura o maximo de pedras do adversario
00924                 }
00925                 // diagonal para baixo e para esquerda 
00926                 if ((tabuleiro_jogada[linha_destino][coluna_destino] == VAZIO) ||
00927                     (tabuleiro_jogada[linha_destino][coluna_destino] == JOGADA)) { // a posicao destino deve estar vazia ou foi uma jogada 
00928                     if (tabuleiro_jogada[linha_destino - 1][coluna_destino + 1] == pedra_normal_oponente) {
00929                         // pedra normal do oponente capturada
00930                         tabuleiro_jogada[linha_destino - 1][coluna_destino + 1] = CAPTURADA;
00931                         //--numero_pedras_para_capturar;
00932                         contabiliza_pedra(jogador_vez, jogador1, jogador2);
00933                         jogada_em_que_ultima_pedra_capturada = jogadas + 1;
00934                         tabuleiro_jogada[linha_destino][coluna_destino] =
00935                             Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
00936                                 jogador_vez, jogador1);
00937                         tabuleiro_jogada[linha_origem][coluna_origem] = JOGADA;
00938                     }
00939                     else if (tabuleiro_jogada[linha_destino - 1][coluna_destino + 1] == pedra_dama_oponente) {
00940                         // pedra dama do oponente capturada
00941                         tabuleiro_jogada[linha_destino - 1][coluna_destino + 1] = CAPTURADA;
00942                         //--numero_pedras_para_capturar;
00943                         contabiliza_pedra(jogador_vez, jogador1, jogador2);
00944                         jogada_em_que_ultima_pedra_capturada = jogadas + 1;
00945                         tabuleiro_jogada[linha_destino][coluna_destino] =
00946                             Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
00947                                 jogador_vez, jogador1);
00948                         tabuleiro_jogada[linha_origem][coluna_origem] = JOGADA;
00949                     }
00950                     else {
00951                         // pedra capturada invalida!!
00952                         return 0;
00953                     }
00954                 }
00955                 else {
00956                     // casa destino ocupada!!
00957                     return 0;
00958                 }
00959             }
00960             else if ((coluna_destino - coluna_origem) == 2) {
00961                 if (Caminho_Maximo_Captura(linha_origem, coluna_origem, linha_destino, coluna_destino)) {
00962                     return 0; // Eh obrigatorio executar a jogada que 
00963                               //   captura o maximo de pedras do adversario
00964                 }
00965                 // diagonal para baixo e para direita
00966                 if ((tabuleiro_jogada[linha_destino][coluna_destino] == VAZIO) ||
00967                     (tabuleiro_jogada[linha_destino][coluna_destino] == JOGADA)) { // a posicao destino deve estar vazia ou foi uma jogada 
00968                     if (tabuleiro_jogada[linha_destino - 1][coluna_destino - 1] == pedra_normal_oponente) {
00969                         // pedra normal do oponente capturada
00970                         tabuleiro_jogada[linha_destino - 1][coluna_destino - 1] = CAPTURADA;
00971                         //--numero_pedras_para_capturar;
00972                         contabiliza_pedra(jogador_vez, jogador1, jogador2);
00973                         jogada_em_que_ultima_pedra_capturada = jogadas + 1;
00974                         tabuleiro_jogada[linha_destino][coluna_destino] =
00975                             Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
00976                                 jogador_vez, jogador1);
00977                         tabuleiro_jogada[linha_origem][coluna_origem] = JOGADA;
00978                     }
00979                     else if (tabuleiro_jogada[linha_destino - 1][coluna_destino - 1] == pedra_dama_oponente) {
00980                         // pedra dama do oponente capturada
00981                         tabuleiro_jogada[linha_destino - 1][coluna_destino - 1] = CAPTURADA;
00982                         //--numero_pedras_para_capturar;
00983                         contabiliza_pedra(jogador_vez, jogador1, jogador2);
00984                         jogada_em_que_ultima_pedra_capturada = jogadas + 1;
00985                         tabuleiro_jogada[linha_destino][coluna_destino] =
00986                             Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
00987                                 jogador_vez, jogador1);
00988                         tabuleiro_jogada[linha_origem][coluna_origem] = JOGADA;
00989                     }
00990                     else {
00991                         // pedra capturada invalida!!
00992                         return 0;
00993                     }
00994                 }
00995                 else {
00996                     // casa destino ocupada!!
00997                     return 0;
00998                 }
00999             }
01000             else {
01001                 // uma jogada de uma pedra normal apenas pode capturar uma pedra para esquerda ou para direita em diagonal
01002                 return 0;
01003             }
01004         }
01005         else if ((linha_origem - linha_destino) == 1) {
01006             if (Movimento_Para_Traz(linha_origem, linha_destino, jogador1, jogador_vez)) {
01007                 return 0; // Uma pedra simples nao pode se movimentar para traz
01008             }
01009             else if (Existe_Pedra_Para_Capturar()) {
01010                 return 0; // Eh obrigatorio capturar uma pedra
01011             }
01012             else if (Movimento_Multiplo()) {
01013                 return 0; // Movimento de multiplas capturas, nao pode fazer um movimento simples apos a captura
01014             }
01015             // pedra fez um movimento, nao esta capturando uma pedra
01016             if ((coluna_origem - coluna_destino) == 1) {
01017                 // diagonal para cima e para esquerda 
01018                 if (tabuleiro_jogada[linha_destino][coluna_destino] == VAZIO) { // a posicao destino deve estar vazia
01019                     tabuleiro_jogada[linha_destino][coluna_destino] =
01020                         Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
01021                             jogador_vez, jogador1);;
01022                     jogada_em_que_ultima_pedra_nomal_movimentada = jogadas + 1;
01023                     tabuleiro_jogada[linha_origem][coluna_origem] = VAZIO;
01024                 }
01025                 else {
01026                     return 0;
01027                 }
01028             }
01029             else if ((coluna_destino - coluna_origem) == 1) {
01030                 // diagonal para cima e para direita
01031                 if (tabuleiro_jogada[linha_destino][coluna_destino] == VAZIO) { // a posicao destino deve estar vazia 
01032                     tabuleiro_jogada[linha_destino][coluna_destino] =
01033                         Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
01034                             jogador_vez, jogador1);
01035                     jogada_em_que_ultima_pedra_nomal_movimentada = jogadas + 1;
01036                     tabuleiro_jogada[linha_origem][coluna_origem] = VAZIO;
01037                 }
01038                 else {
01039                     // casa destino ocupada!!
01040                     return 0;
01041                 }
01042             }
01043             else {
01044                 // uma jogada de uma pedra normal apenas pode andar uma casa para esquerda ou para direita em diagonal
01045                 return 0;
01046             }
01047         }
01048         else if ((linha_destino - linha_origem) == 1) {
01049             if (Movimento_Para_Traz(linha_origem, linha_destino, jogador1, jogador_vez)) {
01050                 return 0; // Uma pedra simples nao pode se movimentar para traz
01051             }
01052             else if (Existe_Pedra_Para_Capturar()) {
01053                 return 0; // Eh obrigatorio capturar uma pedra
01054             }
01055             else if (Movimento_Multiplo()) {
01056                 return 0; // Movimento de multiplas capturas, nao pode fazer um movimento simples apos a captura
01057             }
01058             if ((coluna_origem - coluna_destino) == 1) {
01059                 // diagonal para baixo e para esquerda 
01060                 if (tabuleiro_jogada[linha_destino][coluna_destino] == VAZIO) { // a posicao destino deve estar vazia 
01061                     tabuleiro_jogada[linha_destino][coluna_destino] =
01062                         Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
01063                             jogador_vez, jogador1);
01064                     jogada_em_que_ultima_pedra_nomal_movimentada = jogadas + 1;
01065                     tabuleiro_jogada[linha_origem][coluna_origem] = VAZIO;
01066                 }
01067                 else {
01068                     // casa destino ocupada!!
01069                     return 0;
01070                 }
01071             }
01072             else if ((coluna_destino - coluna_origem) == 1) {
01073                 // diagonal para baixo e para direita
01074                 if (tabuleiro_jogada[linha_destino][coluna_destino] == VAZIO) { // a posicao destino deve estar vazia 
01075                     tabuleiro_jogada[linha_destino][coluna_destino] =
01076                         Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
01077                             jogador_vez, jogador1);
01078                     jogada_em_que_ultima_pedra_nomal_movimentada = jogadas + 1;
01079                     tabuleiro_jogada[linha_origem][coluna_origem] = VAZIO;
01080                 }
01081                 else {
01082                     // casa destino ocupada!!
01083                     return 0;
01084                 }
01085             }
01086             else {
01087                 // uma jogada de uma pedra normal apenas pode andar uma casa para esquerda ou para direita em diagonal
01088                 return 0;
01089             }
01090         }
01091         else {
01092             // pedra normal executou um movimento invalido!!
01093             return 0;
01094         }
01095     } else {
01096         
01097         if (tabuleiro_jogada[linha_destino][coluna_destino] != VAZIO) {
01098             return 0; // A dama nao pode movimentar-se para uma casa ocupada
01099         }
01100 
01101         linha_aux = linha_origem;
01102         coluna_aux = coluna_origem;
01103         if (coluna_origem > coluna_destino) {
01104             unidade_coluna = -1;
01105         }
01106         else {
01107             unidade_coluna = 1;
01108         }
01109 
01110         if (linha_origem > linha_destino) {
01111             unidade_linha = -1;
01112         }
01113         else {
01114             unidade_linha = 1;
01115         }
01116 
01117         pedras_capturadas = 0;
01118 
01119         do {
01120             linha_aux += unidade_linha;
01121             coluna_aux += unidade_coluna;
01122 
01123             if ((tabuleiro_jogada[linha_aux][coluna_aux] == pedra_normal_jogador) || 
01124                 (tabuleiro_jogada[linha_aux][coluna_aux] == pedra_dama_jogador)) {
01125                 return 0;  // Dama nao pode pular pedras do mesmo jogador
01126             } else if ((tabuleiro_jogada[linha_aux][coluna_aux] == pedra_normal_oponente) ||
01127                 (tabuleiro_jogada[linha_aux][coluna_aux] == pedra_dama_oponente)) {
01128                 ++pedras_capturadas;  // A dama capturou uma pedra do oponente
01129                 linha_pedra_capturada = linha_aux;
01130                 coluna_pedra_capturada = coluna_aux;
01131             }
01132 
01133             if (pedras_capturadas > 1) {
01134                 return 0; // A dama nao pode capturar mais de uma pedra em um unico movimento
01135             }
01136 
01137         } while (linha_aux != linha_destino);
01138 
01139         if ((pedras_capturadas == 0) && (Existe_Pedra_Para_Capturar() || Movimento_Multiplo())) {
01140             return 0; // Eh obrigatorio a captura
01141         } else if (Caminho_Maximo_Captura(linha_origem, coluna_origem, linha_destino, coluna_destino)) {
01142             return 0; // Eh obrigatorio executar a jogada que 
01143                       //   captura o maximo de pedras do adversario
01144         }
01145 
01146         if (pedras_capturadas == 1) {
01147             contabiliza_pedra(jogador_vez, jogador1, jogador2);
01148             jogada_em_que_ultima_pedra_capturada = jogadas + 1;
01149             tabuleiro_jogada[linha_destino][coluna_destino] =
01150                 Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
01151                     jogador_vez, jogador1);
01152             tabuleiro_jogada[linha_origem][coluna_origem] = JOGADA;
01153             tabuleiro_jogada[linha_pedra_capturada][coluna_pedra_capturada] = CAPTURADA;
01154         }
01155         else {
01156             tabuleiro_jogada[linha_destino][coluna_destino] =
01157                 Posiciona_Pedra(linha_origem, coluna_origem, linha_destino, coluna_destino,
01158                     jogador_vez, jogador1);
01159             jogada_em_que_ultima_pedra_nomal_movimentada = jogadas + 1;
01160             tabuleiro_jogada[linha_origem][coluna_origem] = VAZIO;
01161         }
01162     }
01163 
01164     return 1;
01165 }
01166 
01167 // 0 - Faixa invalida
01168 // 1 - Faixa valida
01169 int Faixa_Valida(int linha_origem, int coluna_origem, int linha_destino, int coluna_destino) {
01170     
01171     int retorno = 1;
01172 
01173     // Testa a faixa de valores
01174     if ( (linha_origem < 0) || (linha_origem > (MAXLINHA - 1)) ) {
01175         retorno = 0;
01176     }
01177     else if ((linha_destino < 0) || (linha_destino > (MAXLINHA - 1))) {
01178         retorno = 0;
01179     }
01180     else if ((coluna_origem < 0) || (coluna_origem > (MAXCOLUNA - 1))) {
01181         retorno = 0;
01182     }
01183     else if ((coluna_destino < 0) || (coluna_destino > (MAXCOLUNA - 1))) {
01184         retorno = 0;
01185     }
01186     // Testa se eh uma casa de movimentacao de pedra
01187     else if ( (linha_origem % 2 == 0) && (coluna_origem % 2 == 0) ) {
01188         retorno = 0;
01189     }
01190     else if ((linha_destino % 2 == 0) && (coluna_destino % 2 == 0)) {
01191         retorno = 0;
01192     }
01193     else if ((linha_origem % 2 == 1) && (coluna_origem % 2 == 1)) {
01194         retorno = 0;
01195     }
01196     else if ((linha_destino % 2 == 1) && (coluna_destino % 2 == 1)) {
01197         retorno = 0;
01198     }
01199 
01200     return retorno;
01201 }
01202 
01203 void Entrada(int &linha_origem, int &coluna_origem, int &linha_destino, int &coluna_destino, char jogador_vez, char jogador1, char jogador2){
01204 
01205     char nome[TAM_NOME + 1];
01206     
01207     do {
01208         //LimparTela();
01209         PRINTF("%s", FIM_DE_LINHA);
01210         SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
01211         PRINTF("Jogador %s entre com a coordenada de origem da pedra a ser movida.%s", retorna_nome_jogador(jogador_vez, nome), FIM_DE_LINHA);
01212         PRINTF("Entre com o valor da linha(1-8): ");
01213         linha_origem = lerIteiro() - 1;
01214         PRINTF("%s", FIM_DE_LINHA);
01215         PRINTF("Entre com o valor de coluna(1-8): ");
01216         coluna_origem = lerIteiro() - 1;
01217         PRINTF("%s", FIM_DE_LINHA);
01218 
01219         PRINTF("Jogador %s entre com a coordenada de destino da pedra a ser movida.%s", retorna_nome_jogador(jogador_vez, nome), FIM_DE_LINHA);
01220         PRINTF("Entre com o valor de linha(1-8): ");
01221         linha_destino = lerIteiro() - 1;
01222         PRINTF("%s", FIM_DE_LINHA);
01223         PRINTF("Entre com o valor de coluna(1-8): ");
01224         coluna_destino = lerIteiro() - 1;
01225         PRINTF("%s", FIM_DE_LINHA);
01226 
01227         if (Faixa_Valida(linha_origem, coluna_origem, linha_destino, coluna_destino) && 
01228             Movimento_Valido(linha_origem, coluna_origem, linha_destino, coluna_destino, jogador_vez, jogador1, jogador2)) {
01229             break;
01230         } else {
01231             PRINTF("%s", FIM_DE_LINHA);
01232             PRINTF("Movimento invalido!! Pressione <Qualquer Tecla>");
01233             GETCHE();
01234         }
01235     }   while (1);
01236 }
01237 
01238 void Numero_Oponentes(int &jogador1_pedra_normal, int &jogador1_pedra_dama, 
01239                       int &jogador2_pedra_normal, int &jogador2_pedra_dama) {
01240 
01241     int linha, coluna;
01242 
01243     for (linha = 0; linha < MAXLINHA; ++linha) {
01244         for (coluna = 0; coluna < MAXCOLUNA; ++coluna) {
01245             switch (tabuleiro_jogada[linha][coluna]) {
01246             case PEDRA_NORMAL_JOGADOR1:
01247                 ++jogador1_pedra_normal;
01248                 break;
01249             case PEDRA_DAMA_JOGADOR1:
01250                 ++jogador1_pedra_dama;
01251                 break;
01252             case PEDRA_NORMAL_JOGADOR2:
01253                 ++jogador2_pedra_normal;
01254                 break;
01255             case PEDRA_DAMA_JOGADOR2:
01256                 ++jogador2_pedra_dama;
01257                 break;
01258             }
01259         }
01260     }
01261 }
01262 
01263 // 0 - Existem oponentes
01264 // 1 - Sem oponentes
01265 int Sem_Oponentes(void) {
01266 
01267     int jogador1_pedra_normal = 0, jogador1_pedra_dama = 0, 
01268         jogador2_pedra_normal = 0, jogador2_pedra_dama = 0;
01269 
01270     Numero_Oponentes(jogador1_pedra_normal, jogador1_pedra_dama, 
01271                      jogador2_pedra_normal, jogador2_pedra_dama);
01272 
01273     if ( (jogador1_pedra_normal || jogador1_pedra_dama) && (jogador2_pedra_normal || jogador2_pedra_dama) ) {
01274         return 0;
01275     }
01276     return 1;
01277 }
01278 
01279 // 0 - Sem condicoes especiais
01280 // 1 - Com comdicoes especiais
01281 int Codicoes_Especiais(void) {
01282     // @todo falta terminar as codicoes especiais
01283 
01284     int retorno = 0;
01285 
01286     int jogador1_pedra_normal = 0, jogador1_pedra_dama = 0,
01287         jogador2_pedra_normal = 0, jogador2_pedra_dama = 0;
01288 
01289     Numero_Oponentes(jogador1_pedra_normal, jogador1_pedra_dama,
01290         jogador2_pedra_normal, jogador2_pedra_dama);
01291 
01292     if ((jogador1_pedra_normal == 0) &&
01293         (jogador2_pedra_normal == 0) &&
01294         (jogador1_pedra_dama == 2) &&
01295         (jogador2_pedra_dama == 2)) {
01296         // 2 damas contras 2 damas
01297     }
01298 
01299     return retorno;
01300 }
01301 
01302 // 0 - Sem empate
01303 // 1 - Emapate
01304 int Verifica_Empate(void) {
01305 
01306     // @todo Verificar como iniciar as condicoes especiais
01307 
01308     return 0;
01309 
01310     int retorno = 0;
01311 
01312     if( ((jogadas - jogada_em_que_ultima_pedra_capturada) == 20) ||
01313         ((jogadas - jogada_em_que_ultima_pedra_nomal_movimentada) == 20) ) {
01314         // Apos 20 lances sucessivos de damas, sem captura ou deslocamento de pedra, 
01315         //  a partida eh declarada empatada
01316         retorno = 1;
01317     }
01318     else if ( (jogada_empate_lances_especiais) && 
01319               ((jogadas - jogada_empate_lances_especiais) == 5) && 
01320               Codicoes_Especiais() ) {
01321             retorno = 1;
01322     }
01323 
01324     return retorno;
01325 }
01326 
01327 // 0 - Existe pedra a ser movimentada
01328 // 1 - Nao existe pedra a ser movimentada
01329 int Existe_Pedra_Movimento(int linha_destino, int coluna_destino, char jogador1, char jogador2, char jogador) {
01330 
01331     int retorno = 1;
01332 
01333     if (jogador == jogador1) {
01334         if ((linha_destino - 1 >= 0) &&
01335             (coluna_destino - 1 >= 0) &&
01336             (tabuleiro_jogada[linha_destino - 1][coluna_destino - 1] == VAZIO)) {
01337             retorno = 0;
01338         }
01339         else if ((linha_destino - 1 >= 0) &&
01340             (coluna_destino + 1 < MAXCOLUNA) &&
01341             (tabuleiro_jogada[linha_destino - 1][coluna_destino + 1] == VAZIO)) {
01342             retorno = 0;
01343         }
01344     }
01345     else {
01346         if ((linha_destino + 1 < MAXLINHA) &&
01347             (coluna_destino + 1 < MAXCOLUNA) &&
01348             (tabuleiro_jogada[linha_destino + 1][coluna_destino + 1] == VAZIO)) {
01349             retorno = 0;
01350         }
01351         else if ((linha_destino + 1 < MAXLINHA) &&
01352             (coluna_destino - 1 >= 0) &&
01353             (tabuleiro_jogada[linha_destino + 1][coluna_destino - 1] == VAZIO)) {
01354             retorno = 0;
01355         }
01356     }
01357     return retorno;
01358 }
01359 
01360 // 0 - Existe pedra a ser capturada
01361 // 1 - Nao existe pedra a ser capturada
01362 int Existe_Pedra_Capturar(int linha_destino, int coluna_destino, char jogador1, char jogador2, char jogador) {
01363     
01364     int retorno = 1;
01365     char pedra_nomal, pedra_dama;
01366 
01367     if (jogador == jogador1) {
01368         pedra_nomal = PEDRA_NORMAL_JOGADOR2;
01369         pedra_dama = PEDRA_DAMA_JOGADOR2;
01370     }
01371     else {
01372         pedra_nomal = PEDRA_NORMAL_JOGADOR1;
01373         pedra_dama = PEDRA_DAMA_JOGADOR1;
01374     }
01375 
01376     if ((linha_destino + 2 < MAXLINHA) &&
01377         (coluna_destino + 2 < MAXCOLUNA) &&
01378         ((tabuleiro_jogada[linha_destino + 1][coluna_destino + 1] == pedra_nomal) ||
01379          (tabuleiro_jogada[linha_destino + 1][coluna_destino + 1] == pedra_dama)) && 
01380         (tabuleiro_jogada[linha_destino + 2][coluna_destino + 2] == VAZIO)) {
01381         retorno = 0;
01382     }
01383     else if ((linha_destino + 2 < MAXLINHA) &&
01384                 (coluna_destino - 2 >= 0) &&
01385                 ((tabuleiro_jogada[linha_destino + 1][coluna_destino - 1] == pedra_nomal) ||
01386                  (tabuleiro_jogada[linha_destino + 1][coluna_destino - 1] == pedra_dama)) &&
01387                 (tabuleiro_jogada[linha_destino + 2][coluna_destino - 2] == VAZIO)) {
01388         retorno = 0;
01389     }
01390     else if ((linha_destino - 2 >= 0) &&
01391                 (coluna_destino - 2 >= 0) &&
01392                 ((tabuleiro_jogada[linha_destino - 1][coluna_destino - 1] == pedra_nomal) ||
01393                  (tabuleiro_jogada[linha_destino - 1][coluna_destino - 1] == pedra_dama)) &&
01394                 (tabuleiro_jogada[linha_destino - 2][coluna_destino - 2] == VAZIO)) {
01395         retorno = 0;
01396     }
01397     else if ((linha_destino - 2 >= 0) &&
01398                 (coluna_destino + 2 < MAXCOLUNA) &&
01399                 ((tabuleiro_jogada[linha_destino - 1][coluna_destino + 1] == pedra_nomal) ||
01400                  (tabuleiro_jogada[linha_destino - 1][coluna_destino + 1] == pedra_dama)) &&
01401                 (tabuleiro_jogada[linha_destino - 2][coluna_destino + 2] == VAZIO)) {
01402         retorno = 0;
01403     }
01404 
01405     return retorno;
01406 }
01407 
01408 // 0 - Nao existe jogada para o jogador selecionado
01409 // 1 - Existe jogada para o jogador selecionado
01410 int Existe_Jogada(char jogador1, char jogador2, char jogador) {
01411     int retorno = 0;
01412     int linha, coluna;
01413 
01414 
01415     if (jogador == jogador1) {
01416         for (linha = 0; linha < MAXLINHA; ++linha) {
01417             for (coluna = 0; coluna < MAXCOLUNA; ++coluna) {
01418                 if (tabuleiro_jogada[linha][coluna] == PEDRA_NORMAL_JOGADOR1) {
01419                     if (!Existe_Pedra_Movimento(linha, coluna, jogador1, jogador2, jogador)) {
01420                         return 1;
01421                     }
01422                     else if (!Existe_Pedra_Capturar(linha, coluna, jogador1, jogador2, jogador)) {
01423                         return 1;
01424                     }
01425                 }
01426             }
01427         }
01428     }
01429     else {
01430         for (linha = 0; linha < MAXLINHA; ++linha) {
01431             for (coluna = 0; coluna < MAXCOLUNA; ++coluna) {
01432                 if (tabuleiro_jogada[linha][coluna] == PEDRA_NORMAL_JOGADOR2) {
01433                     if (!Existe_Pedra_Movimento(linha, coluna, jogador1, jogador2, jogador)) {
01434                         return 1;
01435                     }
01436                     else if (!Existe_Pedra_Capturar(linha, coluna, jogador1, jogador2, jogador)) {
01437                         return 1;
01438                     }
01439                 }
01440             }
01441         }
01442     }
01443     return retorno;
01444 }
01445 
01446 int Analisar(int linha_origem, int coluna_origem, int linha_destino, int coluna_destino, 
01447              char &jogador_vez, char jogador1, char jogador2){
01448 
01449     int linha, coluna;
01450     char nome[TAM_NOME + 1];
01451     int retorno = 0;
01452 
01453     ++jogadas;
01454 
01455     // Verifica se existem oponentes
01456     if (Sem_Oponentes()) {
01457         if (jogador_vez == jogador1) {
01458             placar[jogador1 - '1'][VITORIAS] += 1;
01459             placar[jogador2 - '1'][DERROTAS] += 1;
01460         }
01461         else {
01462             placar[jogador2 - '1'][VITORIAS] += 1;
01463             placar[jogador1 - '1'][DERROTAS] += 1;
01464         }
01465         //LimparTela();
01466         PRINTF("%s", FIM_DE_LINHA);
01467         SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
01468         PRINTF("Jogador %s VENCEU!! com %d jogadas.%s", retorna_nome_jogador(jogador_vez, nome), jogadas, FIM_DE_LINHA);
01469         PRINTF("Pressione <Qualquer Tecla>");
01470         GETCHE();
01471         jogadas = 0;
01472         retorno = 1;
01473     }
01474     // Verifica empate
01475     else if (Verifica_Empate()) {
01476         placar[jogador1 - '1'][EMPATES] += 1;
01477         placar[jogador2 - '1'][EMPATES] += 1;
01478         //LimparTela();
01479         PRINTF("%s", FIM_DE_LINHA);
01480         SELECIONA_COR(COR_FUNDO_MENSAGEM, COR_TEXTO_MENSAGEM);
01481         PRINTF("Jogadores %s  e %s EMPATARAM!! apos %d jogadas.%s", retorna_nome_jogador(jogador1, nome),
01482             retorna_nome_jogador(jogador2, nome), jogadas, FIM_DE_LINHA);
01483         PRINTF("Pressione <Qualquer Tecla>");
01484         GETCHE();
01485         jogadas = 0;
01486         retorno = 1;
01487     }
01488     // Verifica mudanca de vez de jogador
01489     else {//if ( (numero_pedras_para_capturar == 0) || (numero_pedras_para_capturar == -1) ) {
01490 
01491         for (linha = 0; linha < MAXLINHA; ++linha) {
01492             for (coluna = 0; coluna < MAXCOLUNA; ++coluna) {
01493                 switch (tabuleiro_jogada[linha][coluna]) {
01494                 case PEDRA_NORMAL_JOGADOR1:
01495                 case PEDRA_DAMA_JOGADOR1:
01496                 case PEDRA_NORMAL_JOGADOR2:
01497                 case PEDRA_DAMA_JOGADOR2:
01498                     break;
01499                 default:
01500                     tabuleiro_jogada[linha][coluna] = VAZIO;
01501                     break;
01502                 }
01503             }
01504         }
01505         memcpy(tabuleiro_controle, tabuleiro_jogada, sizeof(tabuleiro_jogada));
01506 
01507         // @todo falta verificar o caso em que o jogador nao tem casa para jogar
01508         if (jogador_vez == jogador1) {
01509             if (numero_pedras_capturadas_jogador1 > numero_pedras_capturadas_antes_jogador1) {
01510                 if (Existe_Pedra_Capturar(linha_destino, coluna_destino, jogador1, jogador2, jogador1)) {
01511                     jogador_vez = jogador2;
01512                 }
01513             }
01514             else if (Existe_Jogada(jogador1, jogador2, jogador2)) {
01515                 jogador_vez = jogador2;
01516             }
01517         }
01518         else {
01519             if (numero_pedras_capturadas_jogador2 > numero_pedras_capturadas_antes_jogador2) {
01520                 if (Existe_Pedra_Capturar(linha_destino, coluna_destino, jogador1, jogador2, jogador2)) {
01521                     jogador_vez = jogador1;
01522                 }
01523             }
01524             else if (Existe_Jogada(jogador1, jogador2, jogador1)) {
01525                 jogador_vez = jogador1;
01526             }
01527         }
01528         //numero_pedras_para_capturar = -1;
01529 
01530         numero_pedras_capturadas_antes_jogador1 = numero_pedras_capturadas_jogador1;
01531         numero_pedras_capturadas_antes_jogador2 = numero_pedras_capturadas_jogador2;
01532 #if 0
01533         for (linha = 0; linha < MAXLINHA; ++linha) {
01534             for (coluna = 0; coluna < MAXCOLUNA; ++coluna) {
01535                 switch (tabuleiro_jogada[linha][coluna]) {
01536                     case PEDRA_NORMAL_JOGADOR1:
01537                     case PEDRA_DAMA_JOGADOR1:
01538                     case PEDRA_NORMAL_JOGADOR2:
01539                     case PEDRA_DAMA_JOGADOR2:
01540                         break;
01541                     default :
01542                         tabuleiro_jogada[linha][coluna] = VAZIO;
01543                         break;
01544                 }
01545             }
01546         }
01547         memcpy(tabuleiro_controle, tabuleiro_jogada, sizeof(tabuleiro_jogada));
01548 #endif
01549     }
01550     
01551     return(retorno);
01552 } 
01553 
01554 void Jogar(char jogador1, char jogador2) {
01555     
01556     char fim = '0';
01557     char jogador_vez;
01558     int linha_origem, coluna_origem, linha_destino, coluna_destino;
01559     
01560     InicializarTabuleiro(jogador1, jogador2);
01561     
01562     jogador_vez = jogador1;
01563     
01564     do {
01565         ImprimirTabuleiro(jogador1, jogador2);
01566         
01567         Entrada(linha_origem, coluna_origem, linha_destino, coluna_destino,jogador_vez, jogador1, jogador2);
01568         
01569         if(Analisar(linha_origem, coluna_origem, linha_destino, coluna_destino, jogador_vez, jogador1, jogador2)) {
01570             fim = '1';
01571         }
01572     } while(fim != '1');
01573 }
01574 
01575 int main() {
01576     
01577     char jogador1, jogador2;
01578     
01579 #ifdef __PC__
01580 
01581     hConsoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);
01582     ConsoleInfo = new CONSOLE_SCREEN_BUFFER_INFO();
01583     GetConsoleScreenBufferInfo(hConsoleHandle, ConsoleInfo);
01584 
01585 #else
01586 
01587     //pc.baud(115200);
01588     term.baud(115200);
01589     
01590 #endif
01591 
01592     // Zerando o placar
01593     memset(placar, 0, sizeof(placar));
01594     
01595     while(true) {
01596         
01597         ImprimeMenu(jogador1, jogador2);
01598         
01599         Jogar(jogador1, jogador2);
01600     }
01601 }