Xadrez em C

Sibelly · 19 de fevereiro de 2013

Hey galera.... Tenho que fazer um programa que identifica se o rei Branco ou Preto estão em posição de xeque ou xeque-mate....

A entrada é um conjunto de peças posicionadas no tabuleiro....



Dh2 rh4 Ra4 Pd4 dd8  (Dama branca na casa h2 / rei preto na casa h4/ rei Branco na casa a4, etc)

Maiúsculas para as peças brancas, e minúsculas para as pretas.

Estou com problemas já na leitura....

Como não há um limite para a quantidade de peças na entrada... pensei em ler e já inserir na matriz.... mas estou com problemas na coluna.... pois como a entrada da coluna deve ser em char.... nao consigo transformá-la em um int... aí vai meu código...


# include <stdio.h>
# define MAX 8

int main (void){
  int linha, i, j;
  char tabuleiro[MAX][MAX] = {{0}}, coluna, peca;

  enum {a = 1, b, c, d, e, f, g, h};  

   do{

    scanf ("%c", &peca);
    scanf ("%c", &coluna);
    scanf ("%d", &linha);
    printf ("%c %c %d\n", peca, coluna, linha); // estava testando
    tabuleiro[linha][coluna] = peca;

  }while(getchar() != '\n');

  // Impressão para teste.... para saber se foi inserido corretamente
  for (i = 0; i < MAX; i++)
    for (j = 0; j < MAX; j++)
      printf ("%c ", tabuleiro[i][j]);
  printf ("\n");


    return 0;
  }

Eu usei o


enum{};

pois achei que resolveria... mas não está dando certo... dei uma pesquisada na net e nao consegui achar nada parecido... e não estou querendo usar um monte de if's.... gostaria de algo mais sofisticado.... se alguém tiver alguma ideia....

Agradeço desde já!

LNW · 19 de fevereiro de 2013

Olá Sibelly,

gostaria de algo mais sofisticado

Hmm, que chique.

Olha só, eu fiz algumas modificações para atender o que você precisa:

# include <stdio.h>
# define MAX 8

int main (void)
{
    int linha, i, j;
    char tabuleiro[MAX][MAX], coluna, peca;

    for (i = 0; i < MAX; i++)
        for (j = 0; j < MAX; j++)
            tabuleiro[i][j] = '-';


    do {

        scanf ("%c", &peca);
        scanf ("%c", &coluna);
        scanf ("%d", &linha);

        tabuleiro[MAX - linha][(coluna - 'a')] = peca;

    } while(getchar() != '\n');

    printf ("\n");

    for (i = 0; i < MAX; i++)
        for (j = 0; j < MAX; j++) {
            printf ("%c ", tabuleiro[i][j]);
            if (j == (MAX - 1)) printf ("\n");
        }

    printf ("\n");


    return 0;
}

As observações são as seguintes:

1) Você não obtém o resultado desejado com aquela inicialização feita daquela forma;

2) Estou considerando a visualização do tabuleiro com as peças brancas dispostas na parte inferior. Logo, o valor do índice para linha é calculado para atender esse critério. Se não desejar dessa forma, basta modificar o cálculo.

Veja aí se era isso mesmo..

PS: Quando eu li o título inicialmente, achei que você estava querendo implementar uma engine de xadrez.. Quem sabe, né, Sibelly

Abs.

LNW

Sibelly · 19 de fevereiro de 2013

Olá LNW....Ainda falta muito pra isso ein... Tenho muita dificuldade em lógica.... =(

Seu eu reprovar de novo em prog provavelmente desisto do curso... '-'

Mas enfim....

Era exatamente assim que eu queria mesmo... ficou ótimo....

Então... não tem como usar o enum{}; para fazer isso??

porque eu já o usei para atribuir valor a letras e depois somar... e deu certo... não entendi porque não funcionou como queria nesse caso...

E gostaria de perguntar uma coisa....

Como eu apenas tenho que ver se o rei está em xeque... estava pensando em fazer o movimento das peças a partir do rei sabe...

Aí não precisaria percorrer toda a matriz atras de todas as peças.... e fazer os movimentos...

A princípio não encontro nenhum empecilho desse jeito.... o que você's acham?

Estou trabalhando nas funções dos movimentos de cada peça... Quando terminar posto aquii...

Valeuu!

LNW · 19 de fevereiro de 2013

Oi Sibelly!

Olá LNW....Ainda falta muito pra isso ein... Tenho muita dificuldade em lógica.... =(
Seu eu reprovar de novo em prog provavelmente desisto do curso... '-'

Ah.. não.. Sibelly.. não desista assim tão precocemente. Você tem evoluído bastante em programação, Sibelly.

Então... não tem como usar o enum{}; para fazer isso??
porque eu já o usei para atribuir valor a letras e depois somar... e deu certo... não entendi porque não funcionou como queria nesse caso...

Realmente, eu entendi o que você quis fazer, mas não seria possível (pelo menos eu não saberia como...) ler uma variável e transformar o conteúdo lido num identificador. Só mesmo fazendo algum mapeamento mesmo, que foi o que você evitou de fazer para não alongar muito o código.

E gostaria de perguntar uma coisa....
Como eu apenas tenho que ver se o rei está em xeque... estava pensando em fazer o movimento das peças a partir do rei sabe...

Aí não precisaria percorrer toda a matriz atras de todas as peças.... e fazer os movimentos...

A princípio não encontro nenhum empecilho desse jeito.... o que você's acham?

Sim, é uma saída, Sibelly.. verifique as peças presentes em todas as direções do rei. Identifique a peça e veja se ela pode colocar o rei em xeque. Se estiver em xeque, verifique se o rei tem mais alguma alternativa para sair do xeque.

Um abraço,

LNW

Sibelly · 2 de março de 2013

Olá galera... voltei aquii.... com muitos problemas... hasugUASHA

É o seguinte... as minhas funções dos movimentos das peças não estão considerando caso exista alguma peça no meio do caminho.... por exemplo...


rh6 Dh1 ph4

Tem um peão preto no meio caminho... logo o rei preto não está em xeque....

Maas... meu código imprime que ele está em xeque... Já tentei de tudo quanto é jeito...

Tentei até usar uma variavel achou... mas... não está dando certo...

E o meu professor pede que na saída.... caso algum dos reis estejam em xeque... imprima também os indices do rei... e... da peça que está atacando.... como está na função do peão e do cavalo.... que são as únicas que não é necessário verificar se há peça no caminho né...

O primeiro jeito que tinha feito estava imprimindo certinho... ai fui testa com aquela entrada... e bugo tudo.... '-'

# include <stdio.h>
# include <stdlib.h>
# define zero 48
# define MAX 8
# define TRUE 1
# define FALSE 0

//Funcao com os movimentos do peao
int peaobranco (char tabuleiro[MAX][MAX], int i, int j){
int indicei = i;
int indicej = j;

if ((tabuleiro[i + 1][j - 1] == 'P') || (tabuleiro[i + 1][j + 1] == 'P')){
printf ("Rei Preto (%c,%d) - Peao Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (j + 'a'), (MAX - i));
return 1;
}
else
return 0;
}// fim funcao peao branco

//Funcao com os movimentos do peao
int peaopreto (char tabuleiro[MAX][MAX], int i, int j){
int indicei = i;
int indicej = j;

if ((tabuleiro[i - 1][j + 1] == 'p') || (tabuleiro[i - 1][j - 1] == 'p')){
printf ("Rei Branco (%c,%d) - Peao Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (j + 'a'), (MAX - i));
return 1;
}
else
return 0;
}// fim funcao peao preto

//Funcao com os movimentos da Torre
int torrebranca (char tabuleiro[MAX][MAX], int i, int j){
int k, achou;

for (k = i; k >= 0; k--){
if ((tabuleiro[k][j] == 'T') && (tabuleiro[k][j] == 'p' || tabuleiro[k][j] == 't' || tabuleiro[k][j] == 'c' || tabuleiro[k][j] == 'b' || tabuleiro[k][j] == 'd')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento inferior

for (k = i; k < MAX; k++){
if ((tabuleiro[k][j] == 'T') && (tabuleiro[k][j] != 'p' || tabuleiro[k][j] != 't' || tabuleiro[k][j] != 'c' || tabuleiro[k][j] != 'b' || tabuleiro[k][j] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento superior

for (k = i; k >= 0; k--){
if ((tabuleiro[i][k] == 'T') && (tabuleiro[i][k] != 'p' || tabuleiro[i][k] != 't' || tabuleiro[i][k] != 'c' || tabuleiro[i][k] != 'b' || tabuleiro[i][k] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento para a esquerda

for (k = i; k < MAX; k++){
if ((tabuleiro[i][k] == 'T') && (tabuleiro[i][k] != 'p' || tabuleiro[i][k] != 't' || tabuleiro[i][k] != 'c' || tabuleiro[i][k] != 'b' || tabuleiro[i][k] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento para a direita

if (achou)
return 1;
else
return 0;
return 0;
}// fim funcao torre branca

//Funcao com os movimentos da Torre
int torrepreta (char tabuleiro[MAX][MAX], int i, int j){
int k, achou;

for (k = i; k >= 0; k--){
if ((tabuleiro[k][j] == 't') && (tabuleiro[k][j] != 'P' || tabuleiro[k][j] != 'T' || tabuleiro[k][j] != 'C' || tabuleiro[k][j] != 'B' || tabuleiro[k][j] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento inferior

for (k = i; k < MAX; k++){
if ((tabuleiro[k][j] == 't') && (tabuleiro[k][j] != 'P' || tabuleiro[k][j] != 'T' || tabuleiro[k][j] != 'C' || tabuleiro[k][j] != 'B' || tabuleiro[k][j] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento superior

for (k = i; k >= 0; k--){
if ((tabuleiro[i][k] == 't') && (tabuleiro[i][k] != 'P' || tabuleiro[i][k] != 'T' || tabuleiro[i][k] != 'C' || tabuleiro[i][k] != 'B' || tabuleiro[i][k] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento para a esquerda

for (k = i; k < MAX; k++){
if ((tabuleiro[i][k] == 't') && (tabuleiro[i][k] != 'P' || tabuleiro[i][k] != 'T' || tabuleiro[i][k] != 'C' || tabuleiro[i][k] != 'B' || tabuleiro[i][k] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento para a direita

if (achou)
return 1;
else
return 0;
return 0;
}// fim funcao torre preta

//Funcao com os movimentos do Cavalo
int cavalobranco (char tabuleiro[MAX][MAX], int i, int j){
int indicei = i;
int indicej = j;

if ((tabuleiro[i + 2][j + 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 1) + 'a'), (MAX - (i + 2)));
return 1;
}
else if ((tabuleiro[i + 2][j - 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 1) + 'a'), (MAX - (i + 2)));
return 1;
}
else if ((tabuleiro[i - 2][j + 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 1) + 'a'), (MAX - (i - 2)));
return 1;
}
else if ((tabuleiro[i - 2][j - 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 1) + 'a'), (MAX - (i - 2)));
return 1;
}
else if ((tabuleiro[i + 1][j + 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 2) + 'a'), (MAX - (i + 1)));
return 1;
}
else if ((tabuleiro[i - 1][j + 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 2) + 'a'), (MAX - (i - 1)));
return 1;
}
else if ((tabuleiro[i + 1][j - 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 2) + 'a'), (MAX - (i + 1)));
return 1;
}
else if ((tabuleiro[i - 1][j - 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 2) + 'a'), (MAX - (i - 1)));
return 1;
}
else
return 0;
}//fim funcao cavalo branco

//Funcao com os movimentos do Cavalo
int cavalopreto (char tabuleiro[MAX][MAX], int i, int j){
int indicei = i;
int indicej = j;

if ((tabuleiro[i + 2][j + 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 1) + 'a'), (MAX - (i + 2)));
return 1;
}
else if ((tabuleiro[i + 2][j - 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 1) + 'a'), (MAX - (i + 2)));
return 1;
}
else if ((tabuleiro[i - 2][j + 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 1) + 'a'), (MAX - (i - 2)));
return 1;
}
else if ((tabuleiro[i - 2][j - 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 1) + 'a'), (MAX - (i - 2)));
return 1;
}
else if ((tabuleiro[i + 1][j + 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 2) + 'a'), (MAX - (i + 1)));
return 1;
}
else if ((tabuleiro[i - 1][j + 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 2) + 'a'), (MAX - (i - 1)));
return 1;
}
else if ((tabuleiro[i + 1][j - 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 2) + 'a'), (MAX - (i + 1)));
return 1;
}
else if ((tabuleiro[i - 1][j - 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 2) + 'a'), (MAX - (i - 1)));
return 1;
}
else
return 0;
}//fim funcao cavalo preto

//Funcao com os movimentos do Bispo
int bispobranco (char tabuleiro[MAX][MAX], int i, int j){
int k, l, achou;

for (k = i, l = j; k < MAX && l < MAX; k++, l++){
if ((tabuleiro[k][l] == 'B') && (tabuleiro[k][l] != 'p' || tabuleiro[k][l] != 't' || tabuleiro[k][l] != 'c' || tabuleiro[k][l] != 'b' || tabuleiro[k][l] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal superior direita

for (k = i, l = j; k < MAX && l >= 0; k++, l--){
if ((tabuleiro[k][l] == 'B') && (tabuleiro[k][l] != 'p' || tabuleiro[k][l] != 't' || tabuleiro[k][l] != 'c' || tabuleiro[k][l] != 'b' || tabuleiro[k][l] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal superior esquerda

for (k = i, l = j; k >= 0 && l < MAX; k--, l++){
if ((tabuleiro[k][l] == 'B') && (tabuleiro[k][l] != 'p' || tabuleiro[k][l] != 't' || tabuleiro[k][l] != 'c' || tabuleiro[k][l] != 'b' || tabuleiro[k][l] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal inferior direita

for (k = i, l = j; k >= 0 && l >= 0; k--, l--){
if ((tabuleiro[k][l] == 'B') && (tabuleiro[k][l] != 'p' || tabuleiro[k][l] != 't' || tabuleiro[k][l] != 'c' || tabuleiro[k][l] != 'b' || tabuleiro[k][l] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal inferior esquerda

if (achou)
return 1;
else
return 0;
return 0;
}// fim funcao bispo branco

//Funcao com os movimentos do Bispo
int bispopreto (char tabuleiro[MAX][MAX], int i, int j){
int k, l, achou;

for (k = i, l = j; k < MAX && l < MAX; k++, l++){
if ((tabuleiro[k][l] == 'b') && (tabuleiro[k][l] != 'P' || tabuleiro[k][l] != 'T' || tabuleiro[k][l] != 'C' || tabuleiro[k][l] != 'B' || tabuleiro[k][l] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal superior direita

for (k = i, l = j; k < MAX && l >= 0; k++, l--){
if ((tabuleiro[k][l] == 'b') && (tabuleiro[k][l] != 'P' || tabuleiro[k][l] != 'T' || tabuleiro[k][l] != 'C' || tabuleiro[k][l] != 'B' || tabuleiro[k][l] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal superior esquerda

for (k = i, l = j; k >= 0 && l < MAX; k--, l++){
if ((tabuleiro[k][l] == 'b') && (tabuleiro[k][l] != 'P' || tabuleiro[k][l] != 'T' || tabuleiro[k][l] != 'C' || tabuleiro[k][l] != 'B' || tabuleiro[k][l] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal inferior direita

for (k = i, l = j; k >= 0 && l >= 0; k--, l--){
if ((tabuleiro[k][l] == 'b') && (tabuleiro[k][l] != 'P' || tabuleiro[k][l] != 'T' || tabuleiro[k][l] != 'C' || tabuleiro[k][l] != 'B' || tabuleiro[k][l] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal inferior esquerda

if (achou)
return 1;
else
return 0;
return 0;
}// fim funcao bispo preto

//Funcao com os movimentos da Dama
int damabranca (char tabuleiro[MAX][MAX], int i, int j){
int k, l, achou;

for (k = i, l = j; k < MAX && l < MAX; k++, l++){
if ((tabuleiro[k][l] == 'D') && (tabuleiro[k][l] != 'p' && tabuleiro[k][l] != 't' && tabuleiro[k][l] != 'c' && tabuleiro[k][l] != 'b' && tabuleiro[k][l] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal superior direita

for (k = i, l = j; k < MAX && l >= 0; k++, l--){
if ((tabuleiro[k][l] == 'D') && (tabuleiro[k][l] != 'p' && tabuleiro[k][l] != 't' && tabuleiro[k][l] != 'c' && tabuleiro[k][l] != 'b' && tabuleiro[k][l] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal superior esquerda

for (k = i, l = j; k >= 0 && l < MAX; k--, l++){
if ((tabuleiro[k][l] == 'D') && (tabuleiro[k][l] != 'p' && tabuleiro[k][l] != 't' && tabuleiro[k][l] != 'c' && tabuleiro[k][l] != 'b' && tabuleiro[k][l] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal inferior direita

for (k = i, l = j; k >= 0 && l >= 0; k--, l--){
if ((tabuleiro[k][l] == 'D') && (tabuleiro[k][l] != 'p' && tabuleiro[k][l] != 't' && tabuleiro[k][l] != 'c' && tabuleiro[k][l] != 'b' && tabuleiro[k][l] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal inferior esquerda

for (k = i; k >= 0; k--){
if ((tabuleiro[k][j] == 'D') && (tabuleiro[k][j] != 'p' && tabuleiro[k][j] != 't' && tabuleiro[k][j] != 'c' && tabuleiro[k][j] != 'b' && tabuleiro[k][j] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento inferior

for (k = i; k < MAX; k++){
if ((tabuleiro[k][j] == 'D') && (tabuleiro[k][j] != 'p' && tabuleiro[k][j] != 't' && tabuleiro[k][j] != 'c' && tabuleiro[k][j] != 'b' && tabuleiro[k][j] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento superior

for (k = i; k >= 0; k--){
if ((tabuleiro[i][k] == 'D') && (tabuleiro[i][k] != 'p' && tabuleiro[i][k] != 't' && tabuleiro[i][k] != 'c' && tabuleiro[i][k] != 'b' && tabuleiro[i][k] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento para a esquerda

for (k = i; k < MAX; k++){
if ((tabuleiro[i][k] == 'D') && (tabuleiro[i][k] != 'p' && tabuleiro[i][k] != 't' && tabuleiro[i][k] != 'c' && tabuleiro[i][k] != 'b' && tabuleiro[i][k] != 'd')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento para a direita

if (achou)
return 1;
else
return 0;
return 0;
}// fim funcao dama branca

//Funcao com os movimentos da Dama
int damapreta (char tabuleiro[MAX][MAX], int i, int j){
int k, l, achou;

for (k = i, l = j; k < MAX && l < MAX; k++, l++){
if ((tabuleiro[k][l] == 'd') && (tabuleiro[k][l] != 'P' && tabuleiro[k][l] != 'T' && tabuleiro[k][l] != 'C' && tabuleiro[k][l] != 'B' && tabuleiro[k][l] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal superior direita

for (k = i, l = j; k < MAX && l >= 0; k++, l--){
if ((tabuleiro[k][l] == 'd') && (tabuleiro[k][l] != 'P' && tabuleiro[k][l] != 'T' && tabuleiro[k][l] != 'C' && tabuleiro[k][l] != 'B' && tabuleiro[k][l] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal superior esquerda

for (k = i, l = j; k >= 0 && l < MAX; k--, l++){
if ((tabuleiro[k][l] == 'd') && (tabuleiro[k][l] != 'P' && tabuleiro[k][l] != 'T' && tabuleiro[k][l] != 'C' && tabuleiro[k][l] != 'B' && tabuleiro[k][l] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal inferior direita

for (k = i, l = j; k >= 0 && l >= 0; k--, l--){
if ((tabuleiro[k][l] == 'd') && (tabuleiro[k][l] != 'P' && tabuleiro[k][l] != 'T' && tabuleiro[k][l] != 'C' && tabuleiro[k][l] != 'B' && tabuleiro[k][l] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}//movimento diagonal inferior esquerda

for (k = i; k >= 0; k--){
if ((tabuleiro[k][j] == 'd') && (tabuleiro[k][j] != 'P' && tabuleiro[k][j] != 'T' && tabuleiro[k][j] != 'C' && tabuleiro[k][j] != 'B' && tabuleiro[k][j] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento inferior

for (k = i; k < MAX; k++){
if ((tabuleiro[k][j] == 'd') && (tabuleiro[k][j] != 'P' && tabuleiro[k][j] != 'T' && tabuleiro[k][j] != 'C' && tabuleiro[k][j] != 'B' && tabuleiro[k][j] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento superior

for (k = i; k >= 0; k--){
if ((tabuleiro[i][k] == 'd') && (tabuleiro[i][k] != 'P' && tabuleiro[i][k] != 'T' && tabuleiro[i][k] != 'C' && tabuleiro[i][k] != 'B' && tabuleiro[i][k] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento para a esquerda

for (k = i; k < MAX; k++){
if ((tabuleiro[i][k] == 'd') && (tabuleiro[i][k] != 'P' && tabuleiro[i][k] != 'T' && tabuleiro[i][k] != 'C' && tabuleiro[i][k] != 'B' && tabuleiro[i][k] != 'D')){
achou = TRUE;
}
else
achou = FALSE;
}// movimento para a direita

if (achou)
return 1;
else
return 0;
return 0;
}// fim funcao dama preta

int main (void){
int linha, i, j, Rsemxeque, rsemxeque;
char tabuleiro[MAX][MAX] = {{0}}, coluna, peca;

do{

do{
scanf ("%c", &peca);

if (peca == zero){
return 0;
}

scanf ("%c%d", &coluna, &linha);
tabuleiro[MAX - linha][(coluna - 'a')] = peca;

} while (getchar() != '\n');

printf ("\nImprimindo tabuleiro\n");
for (i = 0; i < MAX; i++){
for (j = 0; j < MAX; j++){
printf ("%3d", tabuleiro[i][j]);
}
printf ("\n");
}

Rsemxeque = FALSE;
rsemxeque = FALSE;
for (i = 0; i < MAX; i++){
for (j = 0; j < MAX; j++){
if (tabuleiro[i][j] == 'R'){
if (peaopreto (tabuleiro, i, j))
;
else if (torrepreta (tabuleiro, i, j))
printf ("Rei branco Xeque\n");
else if (cavalopreto (tabuleiro, i, j))
;
else if (bispopreto (tabuleiro, i, j))
printf ("Rei branco Xeque\n");
else if (damapreta (tabuleiro, i, j))
printf ("Rei branco Xeque\n");
else
Rsemxeque = TRUE;
}// fim if

else if (tabuleiro[i][j] == 'r'){
if (peaobranco (tabuleiro, i, j))
;
else if (torrebranca (tabuleiro, i, j))
printf ("Rei PRETO Xeque\n");
else if (cavalobranco (tabuleiro, i, j))
;
else if (bispobranco (tabuleiro, i, j))
printf ("Rei PRETO Xeque\n");
else if (damabranca (tabuleiro, i, j))
printf ("Rei PRETO Xeque\n");
else
rsemxeque = TRUE;
}// fim else if

}// fim for j
}//fim for i

if (Rsemxeque && rsemxeque)
printf ("sem xeque\n");

//inicializando tabuleiro para a proxima jogada
for (i = 0; i < MAX; i++){
for (j = 0; j < MAX; j++){
tabuleiro[i][j] = 0;
}//fim for j
}//fim for i

}while (TRUE); // fim do while

return 0;
}

Modifiquei algumas coisas.... pois o professor não tinha decidido uma condição de parada ainda... ai... ficou sendo o zero....

Valeu pela ajuda!

Sibelly · 7 de março de 2013

Hey galeraa.... consegui arrumar tudo certinho... estou postando minha solução... Obrigada pela ajuda!

# include <stdio.h>
# define zero 48
# define MAX 8
# define TRUE 1
# define FALSE 0

//Funcao com os movimentos do peao
int peaobranco (char tabuleiro[MAX][MAX], int i, int j){
int indicei = i;
int indicej = j;

if (tabuleiro[i + 1][j - 1] == 'P'){
printf ("Rei Preto (%c,%d) - Peao Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 1) + 'a'), (MAX - (i + 1)));
return TRUE;
}
else if (tabuleiro[i + 1][j + 1] == 'P'){
printf ("Rei Preto (%c,%d) - Peao Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 1) + 'a'), (MAX - (i + 1)));
return TRUE;
}
else
return FALSE;
}// fim funcao peao branco

//Funcao com os movimentos do peao
int peaopreto (char tabuleiro[MAX][MAX], int i, int j){
int indicei = i;
int indicej = j;

if (tabuleiro[i - 1][j + 1] == 'p'){
printf ("Rei Branco (%c,%d) - Peao Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 1) + 'a'), (MAX - (i - 1)));
return TRUE;
}
else if (tabuleiro[i - 1][j - 1] == 'p'){
printf ("Rei Branco (%c,%d) - Peao Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 1) + 'a'), (MAX - (i - 1)));
return TRUE;
}
else
return FALSE;
}// fim funcao peao preto

//Funcao com os movimentos da Torre
int torre (char tabuleiro[MAX][MAX], int i, int j, char t){
int k;
int indicei = i;
int indicej = j;

for (k = i+1; k < MAX; k++) {
if (tabuleiro[k][j] != '0' && tabuleiro[k][j] != t) {
break;
}
else if (tabuleiro[k][j] == t) {
if (tabuleiro[k][j] == 't'){
printf ("Rei Branco (%c,%d) - Torre Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (j + 'a'), (MAX - k));
}
else if (tabuleiro[k][j] == 'T'){
printf ("Rei Preto (%c,%d) - Torre Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (j + 'a'), (MAX - k));
}
return TRUE;
}
}//movimento inferior

for (k = i-1; k >= 0; k--){
if (tabuleiro[k][j] != '0' && tabuleiro[k][j] != t) {
break;
}
else if (tabuleiro[k][j] == t) {
if (tabuleiro[k][j] == 't'){
printf ("Rei Branco (%c,%d) - Torre Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (j + 'a'), (MAX - k));
}
else if (tabuleiro[k][j] == 'T'){
printf ("Rei Preto (%c,%d) - Torre Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (j + 'a'), (MAX - k));
}
return TRUE;
}
}// movimento superior

for (k = j-1; k >= 0; k--){
if (tabuleiro[i][k] != '0' && tabuleiro[i][k] != t) {
break;
}
else if (tabuleiro[i][k] == t) {
if (tabuleiro[i][k] == 't'){
printf ("Rei Branco (%c,%d) - Torre Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (k + 'a'), (MAX - i));
}
else if (tabuleiro[i][k] == 'T'){
printf ("Rei Preto (%c,%d) - Torre Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (k + 'a'), (MAX - i));
}
return TRUE;
}
}// movimento para a esquerda

for (k = j+1; k < MAX; k++){
if (tabuleiro[i][k] != '0' && tabuleiro[i][k] != t) {
break;
}
else if (tabuleiro[i][k] == t) {
if (tabuleiro[i][k] == 't'){
printf ("Rei Branco (%c,%d) - Torre Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (k + 'a'), (MAX - i));
}
else if (tabuleiro[i][k] == 'T'){
printf ("Rei Preto (%c,%d) - Torre Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (k + 'a'), (MAX - i));
}
return TRUE;
}
}// /movimento para a direita

return FALSE;
}// fim funcao torre

//Funcao com os movimentos do Cavalo
int cavalobranco (char tabuleiro[MAX][MAX], int i, int j){
int indicei = i;
int indicej = j;

if ((tabuleiro[i + 2][j + 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 1) + 'a'), (MAX - (i + 2)));
return 1;
}
else if ((tabuleiro[i + 2][j - 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 1) + 'a'), (MAX - (i + 2)));
return 1;
}
else if ((tabuleiro[i - 2][j + 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 1) + 'a'), (MAX - (i - 2)));
return 1;
}
else if ((tabuleiro[i - 2][j - 1] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 1) + 'a'), (MAX - (i - 2)));
return 1;
}
else if ((tabuleiro[i + 1][j + 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 2) + 'a'), (MAX - (i + 1)));
return 1;
}
else if ((tabuleiro[i - 1][j + 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 2) + 'a'), (MAX - (i - 1)));
return 1;
}
else if ((tabuleiro[i + 1][j - 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 2) + 'a'), (MAX - (i + 1)));
return 1;
}
else if ((tabuleiro[i - 1][j - 2] == 'C') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Preto (%c,%d) - Cavalo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 2) + 'a'), (MAX - (i - 1)));
return 1;
}
else
return 0;
}//fim funcao cavalo branco

//Funcao com os movimentos do Cavalo
int cavalopreto (char tabuleiro[MAX][MAX], int i, int j){
int indicei = i;
int indicej = j;

if ((tabuleiro[i + 2][j + 1] == 'c') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 1) + 'a'), (MAX - (i + 2)));
return 1;
}
else if ((tabuleiro[i + 2][j - 1] == 'c') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 1) + 'a'), (MAX - (i + 2)));
return 1;
}
else if ((tabuleiro[i - 2][j + 1] == 'c') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 1) + 'a'), (MAX - (i - 2)));
return 1;
}
else if ((tabuleiro[i - 2][j - 1] == 'c') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 1) + 'a'), (MAX - (i - 2)));
return 1;
}
else if ((tabuleiro[i + 1][j + 2] == 'c') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 2) + 'a'), (MAX - (i + 1)));
return 1;
}
else if ((tabuleiro[i - 1][j + 2] == 'c') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j + 2) + 'a'), (MAX - (i - 1)));
return 1;
}
else if ((tabuleiro[i + 1][j - 2] == 'c') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 2) + 'a'), (MAX - (i + 1)));
return 1;
}
else if ((tabuleiro[i - 1][j - 2] == 'c') && ((i < MAX) && (j < MAX) && (i >= 0) && (j >= 0))){
printf ("Rei Branco (%c,%d) - Cavalo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), ((j - 2) + 'a'), (MAX - (i - 1)));
return 1;
}
else
return 0;
}//fim funcao cavalo preto

//Funcao com os movimentos do Bispo
int bispo (char tabuleiro[MAX][MAX], int i, int j, char {
int k, l;
int indicei = i;
int indicej = j;

for (k = i-1, l = j+1; k >= 0 && l < MAX; k--, l++){
if (tabuleiro[k][l] != '0' && tabuleiro[k][l] != {
break;
}
else if (tabuleiro[k][l] == {
if (tabuleiro[k][l] == 'b'){
printf ("Rei Branco (%c,%d) - Bispo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
else if (tabuleiro[k][l] == 'B'){
printf ("Rei Preto (%c,%d) - Bispo Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
return TRUE;
}
}//movimento diagonal superior direita

for (k = i-1, l = j-1; k >= 0 && l >= 0; k--, l--){
if (tabuleiro[k][l] != '0' && tabuleiro[k][l] != {
break;
}
else if (tabuleiro[k][l] == {
if (tabuleiro[k][l] == 'b'){
printf ("Rei Branco (%c,%d) - Bispo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
else if (tabuleiro[k][l] == 'B'){
printf ("Rei Preto (%c,%d) - Bispo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
return TRUE;
}
}//movimento diagonal superior esquerda

for (k = i+1, l = j+1; k < MAX && l < MAX; k++, l++){
if (tabuleiro[k][l] != '0' && tabuleiro[k][l] != {
break;
}
else if (tabuleiro[k][l] == {
if (tabuleiro[k][l] == 'b'){
printf ("Rei Branco (%c,%d) - Bispo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
else if (tabuleiro[k][l] == 'B'){
printf ("Rei Preto (%c,%d) - Bispo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
return TRUE;
}
}//movimento diagonal inferior direita

for (k = i+1, l = j-1; k < MAX && l >= 0; k++, l--){
if (tabuleiro[k][l] != '0' && tabuleiro[k][l] != {
break;
}
else if (tabuleiro[k][l] == {
if (tabuleiro[k][l] == 'b'){
printf ("Rei Branco (%c,%d) - Bispo Preto (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
else if (tabuleiro[k][l] == 'B'){
printf ("Rei Preto (%c,%d) - Bispo Branco (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
return TRUE;
}
}//movimento diagonal inferior esquerda

return FALSE;
}// fim funcao bispo

int dama (char tabuleiro[MAX][MAX], int i, int j, char d){
int k, l;
int indicei = i;
int indicej = j;

for (k = i-1, l = j+1; k >= 0 && l < MAX; k--, l++){
if (tabuleiro[k][l] != '0' && tabuleiro[k][l] != d) {
break;
}
else if (tabuleiro[k][l] == d) {
if (tabuleiro[k][l] == 'd'){
printf ("Rei Branco (%c,%d) - Dama Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
else if (tabuleiro[k][l] == 'D'){
printf ("Rei Preto (%c,%d) - Dama Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
return TRUE;
}
}//movimento diagonal superior direita

for (k = i-1, l = j-1; k >= 0 && l >= 0; k--, l--){
if (tabuleiro[k][l] != '0' && tabuleiro[k][l] != d) {
break;
}
else if (tabuleiro[k][l] == d) {
if (tabuleiro[k][l] == 'd'){
printf ("Rei Branco (%c,%d) - Dama Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
else if (tabuleiro[k][l] == 'D'){
printf ("Rei Preto (%c,%d) - Dama Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
return TRUE;
}
}//movimento diagonal superior esquerda

for (k = i+1, l = j+1; k < MAX && l < MAX; k++, l++){
if (tabuleiro[k][l] != '0' && tabuleiro[k][l] != d) {
break;
}
else if (tabuleiro[k][l] == d) {
if (tabuleiro[k][l] == 'd'){
printf ("Rei Branco (%c,%d) - Dama Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
else if (tabuleiro[k][l] == 'D'){
printf ("Rei Preto (%c,%d) - Dama Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
return TRUE;
}
}//movimento diagonal inferior direita

for (k = i+1, l = j-1; k < MAX && l >= 0; k++, l--){
if (tabuleiro[k][l] != '0' && tabuleiro[k][l] != d) {
break;
}
else if (tabuleiro[k][l] == d) {
if (tabuleiro[k][l] == 'd'){
printf ("Rei Branco (%c,%d) - Dama Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
else if (tabuleiro[k][l] == 'D'){
printf ("Rei Preto (%c,%d) - Dama Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (l + 'a'), (MAX - k));
}
return TRUE;
}
}//movimento diagonal inferior esquerda

for (k = i+1; k < MAX; k++) {
if (tabuleiro[k][j] != '0' && tabuleiro[k][j] != d) {
break;
}
else if (tabuleiro[k][j] == d) {
if (tabuleiro[k][j] == 'd'){
printf ("Rei Branco (%c,%d) - Dama Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (j + 'a'), (MAX - k));
}
else if (tabuleiro[k][j] == 'D'){
printf ("Rei Preto (%c,%d) - Dama Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (j + 'a'), (MAX - k));
}
return TRUE;
}
}//movimento inferior

for (k = i-1; k >= 0; k--){
if (tabuleiro[k][j] != '0' && tabuleiro[k][j] != d) {
break;
}
else if (tabuleiro[k][j] == d) {
if (tabuleiro[k][j] == 'd'){
printf ("Rei Branco (%c,%d) - Dama Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (j + 'a'), (MAX - k));
}
else if (tabuleiro[k][j] == 'D'){
printf ("Rei Preto (%c,%d) - Dama Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (j + 'a'), (MAX - k));
}
return TRUE;
}
}// movimento superior

for (k = j-1; k >= 0; k--){
if (tabuleiro[i][k] != '0' && tabuleiro[i][k] != d) {
break;
}
else if (tabuleiro[i][k] == d) {
if (tabuleiro[i][k] == 'd'){
printf ("Rei Branco (%c,%d) - Dama Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (k + 'a'), (MAX - i));
}
else if (tabuleiro[i][k] == 'D'){
printf ("Rei Preto (%c,%d) - Dama Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (k + 'a'), (MAX - i));
}
return TRUE;
}
}// movimento para a esquerda

for (k = j+1; k < MAX; k++){
if (tabuleiro[i][k] != '0' && tabuleiro[i][k] != d) {
break;
}
else if (tabuleiro[i][k] == d) {
if (tabuleiro[i][k] == 'd'){
printf ("Rei Branco (%c,%d) - Dama Preta (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (k + 'a'), (MAX - i));
}
else if (tabuleiro[i][k] == 'D'){
printf ("Rei Preto (%c,%d) - Dama Branca (%c,%d)\n", (indicej + 'a'), (MAX - indicei), (k + 'a'), (MAX - i));
}
return TRUE;
}
}// movimento para a direita

return FALSE;
}// fim funcao dama

int main (void){
int linha, i, j, Rsemxeque, rsemxeque;
char tabuleiro[MAX][MAX], coluna, peca;

do{

// inicializando o tabuleiro
for (i = 0; i < MAX; i++){
for (j = 0; j < MAX; j++){
tabuleiro[i][j] = '0';
}//fim for j
}//fim for i

do{
scanf ("%c", &peca);

if (peca == zero){
return 0;
}

scanf ("%c%d", &coluna, &linha);
tabuleiro[MAX - linha][(coluna - 'a')] = peca;

} while (getchar() != '\n');

Rsemxeque = FALSE;
rsemxeque = FALSE;
for (i = 0; i < MAX; i++){
for (j = 0; j < MAX; j++){
if (tabuleiro[i][j] == 'R'){
if (peaopreto (tabuleiro, i, j))
;
else if (torre (tabuleiro, i, j, 't'))
;
else if (cavalopreto (tabuleiro, i, j))
;
else if (bispo (tabuleiro, i, j, 'b'))
;
else if (dama (tabuleiro, i, j, 'd'))
;
else
Rsemxeque = TRUE;
}// fim if

else if (tabuleiro[i][j] == 'r'){
if (peaobranco (tabuleiro, i, j))
;
else if (torre (tabuleiro, i, j, 'T'))
;
else if (cavalobranco (tabuleiro, i, j))
;
else if (bispo (tabuleiro, i, j, 'B'))
;
else if (dama (tabuleiro, i, j, 'D'))
;
else
rsemxeque = TRUE;
}// fim else if

}// fim for j
}//fim for i

if (Rsemxeque && rsemxeque)
printf ("sem xeque\n");

}while (TRUE); // fim do while

return 0;
}// fim main