1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

Duvida em Xadrez C

Discussão em 'Programação' iniciada por Ruben_Barbosa, 11 de Maio de 2009. (Respostas: 0; Visualizações: 641)

  1. Ruben_Barbosa

    Ruben_Barbosa Power Member

    Código:
    #include <stdio.h>
    #include <stdlib.h>
    #include <locale.h>
    #include <conio2.h>
    char da_lincol[2],para_lincol[2];
    void Tabuleiro(char tab[8][8],int mat_tabuleiro[8][8]);
    int tamanho_errado();
    int coluna_errada();
    int linha_errada();
    int sem_peca_erro();
    int peca_adversario();
    int sem_movimento();
    int mov_peao(int mat_tabuleiro[8][8],int l,int l1, int c, int c1);
    int mov_torre(int l,int l1, int c, int c1);
    int mov_rainha(int l,int l1, int c, int c1);
    int mov_rei(int mat_tabuleiro[8][8],int l,int l1, int c, int c1);
    int mov_cavalo(int l,int l1, int c, int c1);
    int mov_bispo(int l,int l1, int c, int c1);
    int Principal();
    void back_menu();
    void nome_jogador();
    void Menu_principal();
    void desenhar_op();
    
    int main(int argc, char *argv[])
    {
        setlocale(LC_ALL,"");
        Menu_principal();
    }
    
    
    /**
    * Função para Criar MEnu Principal
    */
    
    void Menu_principal()
    {
    
        char opcao;
        textbackground(BLUE);
        textcolor(WHITE);
        clrscr();
        desenhar_op();
        opcao = getch();
        switch(opcao)
        {
            case 'J':
            case 'j':
            nome_jogador();
            Principal();
    
    
    
            case 'O':
            case 'o':
                    break;
    
            case 'S':
            case 's':
                exit;
                break;
    
            default :
                printf("\n\n Opção Invalida.\n\n Deseja Voltar ao menu Inicial (S/N)");
                back_menu();
                break;
        }
    
    }
    
    /**
    * Função de Voltar ao menu inicial
    */
    
    void back_menu()
    {
        char op;
        op = getch();
        switch(op)
        {
            case 'S':
            case 's':
                clrscr();
                system("PAUSE");
                Menu_principal();
                break;
    
            case 'N':
            case 'n':
                exit;
                break;
    
                default:
                    printf("\n Opção invalida. O Programa vai encerrar!\n\n");
                    system("PAUSE");
                    break;
        }
    }
    
    
    /**
    * Função que Desenha opções de jogo
    */
    
    void desenhar_op()
    {
        gotoxy(28,5);
        printf("Bem Vindo ao Jogo de Xadrez\n\n\n\n\n");
        textcolor(WHITE);
        gotoxy(26,10);
        printf("- - -   Opcoes de Jogo    - - -");
        gotoxy(32,14);
        printf("[J]- player vs player");
        gotoxy(32,16);
        printf("[O]- opcoes do jogo");
        gotoxy(32,18);
        printf("[S]- Sair do jogo ");
    }
    
    /**
    * Função de Criar o Nome dos Jogadores
    */
    
    void nome_jogador()
    {
        char P1[25];
        char P2[25];
        clrscr();
        printf("\n Introduza o Nome do Primeiro jogador.\n");
        gotoxy(2,4);
        gets(P1);
        printf("\n Introduza o Nome do Segundo jogador.\n");
        gotoxy(2,8);
        gets(P2);
        clrscr();
    }
    /*_______________________________________________________________________________________________*/
    
    int Principal()
    {
    
     /*         formatar matriz com as peças */
    /*             BRANCAS        : 1-rei, 2-rainha, 3-bispo, 4-cavalo, 5-torre, 6-peao*/
    /*             PRETAS      : 7-rei, 8-rainha, 9-bispo, 10-cavalo, 11-torre, 12-peao*/
    
    
    /* segurança do tabuleiro
    int mat_tabuleiro [8][8]={{5,4,3,2,1,3,4,5},{6,6,6,6,6,6,6,6},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{12,12,12,12,12,12,12,12},{11,10,9,7,8,9,10,11}};   */
    char* nome_peca[] = {" ","Peao","Torre","Cavalo","Bispo","Rainha","Rei"};
    
    int teste; /* Variavel para testes de verdade */
    int z,l,c,l1,c1; /* variaveis provisorias de Valor x para linha e coluna */
    
    int i,i1;
    
    int mat_tabuleiro [8][8]={{5,4,3,2,1,3,4,5},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,3,0,2,0,9,0,9},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{12,12,12,12,12,12,12,12},{11,10,9,7,8,9,10,11}};
     char tab[8][8]={{'T','C','B','D','R','B','C','T'},{'P','P','P','P','P','P','P','P'}};
    /* armazena nome da peca */
    int brc_prt; /*valores lógicos para pedra branca (1) ou preta(0)*/
    /* Fazer jogada DE */
    
    for(z=0;z<10000;z++)
    {
    teste=1;
    do
    {
            /*                      JOGAR DE                              */
            system("CLS");
            Tabuleiro(tab,mat_tabuleiro);
            printf("Linha e Coluna para escolher a Peça que pretende mover :");
            scanf("%s",da_lincol);
            if(strlen(da_lincol)!=2)/* testa o comprimento da variavel*/
            teste= tamanho_errado;     /*Chama função de tamanho errado  */
            else teste=0;
            /* converte letras em numeros e testa validade das colunas*/
            if (teste==0)
            {
                switch(da_lincol[1])
                {
                      case 'a':da_lincol[1]='1';break;
                      case 'A':da_lincol[1]='1';break;
                      case 'b':da_lincol[1]='2';break;
                      case 'B':da_lincol[1]='2';break;
                      case 'c':da_lincol[1]='3';break;
                      case 'C':da_lincol[1]='3';break;
                      case 'd':da_lincol[1]='4';break;
                      case 'D':da_lincol[1]='4';break;
                      case 'e':da_lincol[1]='5';break;
                      case 'E':da_lincol[1]='5';break;
                      case 'f':da_lincol[1]='6';break;
                      case 'F':da_lincol[1]='6';break;
                      case 'g':da_lincol[1]='7';break;
                      case 'G':da_lincol[1]='7';break;
                      case 'h':da_lincol[1]='8';break;
                      case 'H':da_lincol[1]='8';break;
                      default:
                       teste = coluna_errada;     /*Chama função de coluna errada */
                      }
                      }
                      /* Teste ás linhas, tem de ser entre 1 e 8 */
            if (teste==0)
                      {
                            /* if (da_lincol[0]!='1'&&da_lincol[0]!='2'&&da_lincol[0]!='3'&&da_lincol[0]!='4'&&da_lincol[0]!='5'&&da_lincol[0]!='6'&&da_lincol[0]!='7'&&da_lincol[0]!='8') */
                        if(da_lincol[0]<'1'||da_lincol[0]>'8')
                                {
                                        teste=linha_errada; /* Chama função de coordenada errada pois a linha não tem um valor valido*/
                                }
                                    }
    
                            /*testa se existe peca na casa pretendida */
                                    if (teste==0)
                                                {
                                                 l=da_lincol[0]-49;c=da_lincol[1]-49;  /* Coloca a matriz da jogada nas variaveis lc */
                                                 if (mat_tabuleiro[l][c]==0)        /* Nao existe pedra na casa selecionada */
                                                 teste=sem_peca_erro;
                                                  }
    
                                                /* variavel brc_prt=1 peca branca brc_prt=0 peca preta */
                                                 if (teste==0)
                                                        {
                                                         if (mat_tabuleiro[l][c]<7)
                                                         brc_prt=1;
                                                         else
                                                         brc_prt=0;
                                                        /*testa se a peca é do jogador*/
                                                                if (brc_prt==0)
                                                                    teste=peca_adversario;
                                                                       }
                                                                            }
                                                                              while (teste==1);
                                                                              system("PAUSE");
    
    /*_______________________________________________________________________________________*/
    
    /*  Fazer jogada PARA */
    
    teste=1;
    do
    {
            /*                      JOGAR DE                              */
    
            printf("Posição Para onde quer que a Peça Escolhida Vá :");
            scanf("%s",para_lincol);
            if(strlen(para_lincol)!=2)            /* testa o comprimento da variavel*/
            teste=tamanho_errado;             /*Chama função de tamanho errado  */
            else teste=0;
            /* converte letras em numeros e testa validade das colunas*/
            if (teste==0)
            {
                      switch(para_lincol[1])
                      {
                                            case 'a':para_lincol[1]='1';
                                                    break;
                                            case 'A':para_lincol[1]='1';
                                                    break;
                                            case 'b':para_lincol[1]='2';
                                                    break;
                                            case 'B':para_lincol[1]='2';
                                                    break;
                                            case 'c':para_lincol[1]='3';
                                                    break;
                                            case 'C':para_lincol[1]='3';
                                                    break;
                                            case 'd':para_lincol[1]='4';
                                                    break;
                                            case 'D':para_lincol[1]='4';
                                                    break;
                                            case 'e':para_lincol[1]='5';
                                                    break;
                                            case 'E':para_lincol[1]='5';
                                                    break;
                                            case 'f':para_lincol[1]='6';
                                                    break;
                                            case 'F':para_lincol[1]='6';
                                                    break;
                                            case 'g':para_lincol[1]='7';
                                                    break;
                                            case 'G':para_lincol[1]='7';
                                                    break;
                                            case 'h':para_lincol[1]='8';
                                                    break;
                                            case 'H':para_lincol[1]='8';
                                                    break;
                                            default:
                                                teste=coluna_errada;     /*Chama função de coluna errada */
                                            }
                                            }
                                            /* Teste ás linhas, tem de ser entre 1 e 8 */
                                            if (teste==0)
                                            {
                                                         if (para_lincol[0]!='1'&&para_lincol[0]!='2'&&para_lincol[0]!='3'&&para_lincol[0]!='4'&&para_lincol[0]!='5'&&para_lincol[0]!='6'&&para_lincol[0]!='7'&&para_lincol[0]!='8')
                                                         teste=linha_errada; /* Chama função de coordenada errada pois a linha não tem um valor valido*/
                                                         }
                                                         l1=para_lincol[0]-49;c1=para_lincol[1]-49;  /* Coloca a matriz da jogada nas variaveis lc */
                                                         if (l==l1&&c==c1)
                                                         teste=sem_movimento; /* Chama função de erro pois não houve um movimento da peca*/
                                                         /*testa se a jogada e valida para o rei */
                                                         if (teste==0)
                                                         {
    
                                                                      switch (mat_tabuleiro[l][c])
                                                                      {
                                                                             case 1:teste=mov_rei(mat_tabuleiro,l,l1,c,c1);
                                                                                    break;
                                                                             case 2:teste=mov_rainha(l,l1,c,c1);
                                                                                    break;
                                                                             case 3:teste=mov_bispo(l,l1,c,c1);
                                                                                    break;
                                                                             case 4:teste=mov_cavalo(l,l1,c,c1);
                                                                                    break;
                                                                             case 5:teste=mov_torre(l,l1,c,c1);
                                                                                    break;
                                                                             case 6:teste=mov_peao(mat_tabuleiro,l,l1,c,c1);
                                                                                    break;
                                                                             }
                                                                             }
                                                                             }
                                                                             while (teste==1);
    
    
    
    
    
                                                                             mat_tabuleiro[l1][c1]=mat_tabuleiro[l][c];
                                                                             mat_tabuleiro[l][c]=0;
    
    
    clrscr();
    Tabuleiro(tab,mat_tabuleiro);
    }
    
                                                                              } /*  FIM DA MAIN()*/
    
    
    /**
    Funcao que devolve um aviso de erro de tamanho */
    int tamanho_errado()
    {
                    int i;
                    system("CLS");
                    printf("So pode introduzir DOIS CARACTERES!!!\a\n\n");
                    system("PAUSE");
                    return 1;
                    }
    /**
    Funcao que devolve um aviso de erro de coluna*/
    
    int coluna_errada()
    {
                   int i;
                   system("CLS");
                   printf("A COLUNA tem de estar entre A-H !!!\a\n\n");
                   system("PAUSE");
                   return 1;
                   }
    /**
    Funcao que devolve um aviso de erro de linha*/
    
    int linha_errada()
    {
                  int i;
                  system("CLS");
                  printf("A LINHA tem de estar entre 1-8 !!!\a\n\n");
                  system("PAUSE");
                  return 1;
    }
    
    
    
    /**
    Funcao que devolve um aviso de erro de peca vazia */
    
    int sem_peca_erro()
    {
                   int i;
                   system("CLS");
                   printf("Nessa posicao nao existe peca para jogar !!!\a\n\n");
                   system("PAUSE");
                   return 1;
                   }
    
    /**
    Funcao que nega jogo com pecas do adversario
    */
    int peca_adversario()
    {
                     int i;
                     system("CLS");
                     printf("So pode jogar com as suas pecas !!!\a\n\n");
                     system("PAUSE");
                     return 1;
                     }
    
    /*              Funcao que nega jogo para a propria casa*/
    int sem_movimento()
    {
                   int i;
                   system("CLS");
                   printf("Nao movimentou a peca !!!\a\n\n");
                   system("PAUSE");
                   return 1;
                   }
    
    
    /**
    Funcao de teste ao movimeto do rei */
    
    int mov_rei(int mat_tabuleiro[8][8],int l,int l1, int c, int c1)
    {
    
                      /* testa se o movimento e valido e se e para casa vazia*/
                      if(l1==l+1&&c==c1&&mat_tabuleiro[l1][c1]==0||l1==l+1&&c1==c-1&&mat_tabuleiro[l1][c1]==0||l1==l&&c1==c-1&&mat_tabuleiro[l1][c1]==0||l1==l-1&&c1==c-1&&mat_tabuleiro[l1][c1]==0||l1==l-1&&c1==c&&mat_tabuleiro[l1][c1]==0||l1==l-1&&c1==c+1&&mat_tabuleiro[l1][c1]==0||l1==l&&c1==c+1&&mat_tabuleiro[l1][c1]==0||l1==l+1&&c1==c+1&&mat_tabuleiro[l1][c1]==0)
                      return 0;
                      /*testa se o movimento e valido e se captura peca */
                            if(l1==l+1&&c==c1&&mat_tabuleiro[l1][c1]>6)
                                {
                                return 0;
                                }
    
                            if(l1==l+1&&c1==c-1&&mat_tabuleiro[l1][c1]>6)
                                {
                                return 0;
                                }
    
                            if(l1==l&&c1==c-1&&mat_tabuleiro[l1][c1]>6)
                                {
                                return 0;
                                }
                            if(l1==l-1&&c1==c-1&&mat_tabuleiro[l1][c1]>6)
                                {
                               return 0;
                                }
                            if(l1==l-1&&c1==c&&mat_tabuleiro[l1][c1]>6)
                                {
                                return 0;
                                }
                            if(l1==l-1&&c1==c+1&&mat_tabuleiro[l1][c1]>6)
                                {
                                return 0;
                                }
                            if(l1==l&&c1==c+1&&mat_tabuleiro[l1][c1]>6)
                                {
                                return 0;
                                }
                            if(l1==l+1&&c1==c+1&&mat_tabuleiro[l1][c1]>6)
                            {
                                return 0;
                                }
                                    system("CLS");
                                    printf("Essa jogada nao e valida para o rei !!!\a\n\n");
                                    system("PAUSE");
                                    return 1;
    }
    
    /**
    Funcao de teste ao movimeto da rainha */
    
    int mov_rainha(int l,int l1, int c, int c1)
    {
                         int i,i1;
                         /* testa na horizontal */
                         for (i=0;i<8;i++)
                         {
                             if (l1==l&&c1==i)
                             return 0;
                             }
                             /* testa na vertical */
                             for (i=0;i<8;i++)
                             {
                                 if (l1==i && c1==c)
                                 return 0;
                                 }
                                 /*teste na diagona para a direita + */
                                 i1=c+1;
                                 for(i=l+1;i<8;i++)
                                 {
                                                   if(i1==8)
                                                   break;
                                                   if(l1==i&&c1==i1)
                                                   return 0;
                                                   i1=i1+1;
                                                   }
                                                   /*teste na diagonal para a direita - */
                                                   i1=c-1;
                                                   for(i=l-1;i>-1;i=i-1)
                                                   {
                                                                        if(i1==-1)
                                                                        break;
                                                                        if(l1==i &&c1==i1)
                                                                        return 0;
                                                                        i1=i1-1;
                                                                        }
                                                                        /*teste na diagona para a esquerda + */
                                                                        i1=c-1;
                                                                        for(i=l+1;i<8;i++)
                                                                        {
                                                                                          if(i1==-1)
                                                                                          break;
                                                                                          if(l1==i&&c1==i1)
                                                                                          return 0;
                                                                                          i1=i1-1;
                                                                                          }
                                                                                          /*teste na diagonaL para a esquerda - */
                                                                                          i1=c+1;
                                                                                          for(i=l-1;i>-1;i=i-1)
                                                                                          {
                                                                                                               if(i1==8)
                                                                                                               break;
                                                                                                               if(l1==i&&c1==i1)
                                                                                                               return 0;
                                                                                                               i1=i1+1;
                                                                                                               }
                                                                                                               /* jogada inválida */
                                                                                                               system("CLS");
                                                                                                               printf("Esse movimento nao e válido para a rainha !!!\a\n\n");
                                                                                                               system("PAUSE");
                                                                                                               return 1;
                                                                                                               }
    /**
    Funcao de teste ao movimeto do bispo */
    
    int mov_bispo(int l,int l1, int c, int c1)
    {
                        int i,i1;
                        /*teste na diagona para a direita + */
                        i1=c+1;
                        for(i=l+1;i<8;i++)
                        {
                                          if(i1==8)
                                          break;
                                          if(l1==i&&c1==i1)
                                          return 0;
                                          i1=i1+1;
                                          }
                                          /*teste na diagona para a direita - */
                                          i1=c-1;
                                          for(i=l-1;i>-1;i=i-1)
                                          {
                                                               if(i1==-1)
                                                               break;
                                                               if(l1==i &&c1==i1)
                                                               return 0;
                                                               i1=i1-1;
                                                               }
                                                               /*teste na diagona para a esquerda + */
                                                               i1=c-1;
                                                               for(i=l+1;i<8;i++)
                                                               {
                                                                                 if(i1==-1)
                                                                                 break;
                                                                                 if(l1==i&&c1==i1)
                                                                                 return 0;
                                                                                 i1=i1-1;
                                                                                 }
                                                                                 /*teste na diagona para a esquerda - */
                                                                                 i1=c+1;
                                                                                 for(i=l-1;i>-1;i=i-1)
                                                                                 {
                                                                                                      if(i1==8)
                                                                                                      break;
                                                                                                      if(l1==i&&c1==i1)
                                                                                                      return 0;
                                                                                                      i1=i1+1;
                                                                                                      }
                                                                                                      /* jogada inválida */
                                                                                                      system("CLS");
                                                                                                      return 1;
                                                                                                      }
    /**
    Funcao de teste ao movimeto do cavalo */
    
    int mov_cavalo(int l,int l1, int c, int c1)
    {
                         if(c1==c+2&&l1==l+1||c1==c+2&&l1==l-1||c1==c-2&&l1==l+1||c1==c-2&&l1==l-1||l1==l+2&&c1==c+1||l1==l+2&&c1==c-1||l1==l-2&&c1==c+1||l1==l-2&&c1==c-1)
                         return 0;  /* Faz o teste e retorna 0=valido*/
                         else
                         {
                             system("CLS");
                             printf("Essa jogada nao e valida para o Cavalo !!!\a\n\n");
                             system("PAUSE");
                             return 1;
                             }
    }
    /**
    Funcao de teste ao movimeto da torre */
    
    int mov_torre(int l,int l1, int c, int c1)
    {
                         int i,i1;
        /* testa na horizontal */
                          for (i=0;i<8;i++)
                          {
                              if (l1==l&&c1==i)
                              return 0;
                              }
       /* testa na vertical */
                          for (i=0;i<8;i++)
                          {
                              if (l1==i && c1==c)
                              return 0;
                              }
                                 /* jogada inválida */
    
               system("CLS");
    printf("Esse movimento nao e válido para a torre !!!\a\n\n");
    system("PAUSE");
    return 1;
                          }
    
    /**
    Funcao de teste ao movimeto do peao */
    
    int mov_peao(int mat_tabuleiro[8][8],int l,int l1, int c, int c1)
    {
                       int i,i1;
                       /* testa na vertical */
                       if(mat_tabuleiro[l+1][c+1]>6&&l1==l+1&&c1==c+1) /*capturou na diagonal direita*/
                            {
                           return 0;
                                }
                       if(mat_tabuleiro[l+1][c-1]>6&&l1==l+1&&c1==c-1) /*capturou na diagonal esquerda*/
                            {
                            return 0;
                                }
                        if(mat_tabuleiro[l+1][c+1]<7&&mat_tabuleiro[l+1][c-1]<7&&l1==l+1&&c==c1&&mat_tabuleiro[l1][c1]==0) /* jogou validamente uma casa para a frente*/
                            {
                            return 0;
                                }
                        if(l=1&&mat_tabuleiro[l+1][c+1]<7&&mat_tabuleiro[l+1][c-1]<7&&l1==l+2&&c==c1&&mat_tabuleiro[l1][c1]==0) /* jogou validamente duas casas para a frente*/
                            {
                            return 0;
                                }
                                    {
                                        }
                        /* jogada inválida */
                        system("CLS");
                        printf("Esse movimento nao e valido para o Peao !!!\a\n\n");
                        system("PAUSE");
                        return 1;
        }
    
    /**
     Funcao de impressao do tabuleiro*/
    
    void Tabuleiro(char tab[8][8],int mat_tabuleiro[8][8])
    {
     int lin,col;
     int s=1;
     int s1=8;
    
     printf("      a   b   c   d   e   f   g   h");
     printf("\n\n");
     for(lin=0;lin<8;lin++)
     {
                    printf(" %d  ",s++);
                          for (col=0;col<8;col++)
                          {
    
                              if( mat_tabuleiro[lin][col]==1)
                              tab[lin][col]='R';
    
    
                              if( mat_tabuleiro[lin][col]==2)
                              tab[lin][col]='D';
    
    
                              if( mat_tabuleiro[lin][col]==3)
                              tab[lin][col]='B';
    
                              if( mat_tabuleiro[lin][col]==4)
                              tab[lin][col]='C';
    
                              if( mat_tabuleiro[lin][col]==5)
                              tab[lin][col]='T';
    
                              if( mat_tabuleiro[lin][col]==6)
                              tab[lin][col]='p';
    
                              if( mat_tabuleiro[lin][col]==0)
                              tab[lin][col]=' ';
    
                             // tab[1][col]='p';
    
    
    
                          printf("|_%c_",tab[lin][col]);
    
    
    
                          }
                          printf("|");
                          printf(" %d  ",s1--);
                          printf("\n\n");
    
     }
       printf("      a   b   c   d   e   f   g   h");
       printf("\n\n");
    
    
    
    
      system("PAUSE");
      return 0;
    }
    
    
    Este é o meu codigo de Xadrez e que por sinal já Funca :) mas tou com um problema :S.
    Todas as peças mexem menos os peoes e não me aparecem no tabuleiro :S.

    Tou farto de andar as voltas se alguem poder ajudar agradecia :S.
     
    Última edição: 11 de Maio de 2009

Partilhar esta Página