Certa vez, um amigo meu, que faz curso de Engenharia Civil, pediu para eu lhe ajudar com exercícios de programação. Nossa, não entendo porque Engenharia Civil possui isto, assim como outros cursos por aí, mas acho que esta discussão foge ao escopo. Bom, escrevi isto porque não podia usar de um código muito complexo, mas também não queria fazer um lixo, final de contas, ficou bem interessante o código e ele está documentado. Dou todos os direitos de cópia. Espero ajudar alguém. =]

• Download Teste.cpp
• Enviar nova versão

Esconder código-fonte

#include <stdio.h>

int   tabuleiro[3][3];
// Variável que mantém as posições das jogadas
int   njogada;
// Mantém qual é o numero da jogada
float vitorias[2];
// Mantém o placar das partidas
int   gamePC=0;
// Variável usada para saber se o computador joga ou não

void opcaoInvalida(int option){
  // imprime a opção inválida e uma ajuda de como escolher uma opção válida
  printf("*********************************************");     
  printf("\n\t\tOpcao invalida");
  printf("\n*********************************************");
  printf("\n");
  printf("\nA opcao %d nao consta na lista",option);        
  printf("\nPor favor tente uma opcao valida");
  printf("\n");
  printf("\nExemplo: 1");
  printf("\n");
  printf("\nO exemplo acima acessa o jogo no modo ");
  printf("\nJogador X Jogador");
  printf("\n");
  printf("\n*********************************************");     
  printf("\n\t\tOpcao invalida");
  printf("\n*********************************************");    
}

void empate(){
  // Imprime a resolução da partida como empate e depois imprime o placar
  printf("*********************************************");     
  printf("\n\tA partida empatou (Placar)");
  printf("\n*********************************************\n");
  printf("\n Jogador 1 vitorias: %f",vitorias[0]);
  printf("\n Jogador 1 derrotas: %f",vitorias[1]);
  printf("\n");
  printf("\n Jogador 2 vitorias: %f",vitorias[1]);
  printf("\n Jogador 2 derrotas: %f",vitorias[0]);
  printf("\n");  
  printf("\n Total de partidas : %f\n",(vitorias[0]+vitorias[1]));
  printf("\n*********************************************");     
  printf("\n\tA partida empatou (Placar)");
  printf("\n*********************************************");     
}

void imagemVitoria(int jogador){
  // Exibi uma "imagem" de vitória apos o termino de cada partida
  printf("*********************************************");  
  printf("\n\t    PARABENS JOGADOR %d",jogador);
  printf("\n");    
  printf("\n            AGRADECEMOS A PREFERÊNCIA      ");
  printf("\n*********************************************");  
  printf("\n");
  printf("\nWW     WW     WW IIIIIIIIIIIII NNN         NNN ");
  printf("\n WW   WWWW   WW      IIIII     NNN NNN     NNN ");
  printf("\n  WW WW  WW WW       IIIII     NNN     NNN NNN ");
  printf("\n   WW     WW     IIIIIIIIIIIII NNN         NNN "); 
  printf("\n*********************************************"); 
}

void placar(){
  // Imprime os dados do placar da partida
  printf("\n*********************************************");     
  printf("\n\t\tPlacar");
  printf("\n*********************************************\n");
  printf("\n Jogador 1 vitorias: %f",vitorias[0]);
  printf("\n Jogador 1 derrotas: %f",vitorias[1]);
  printf("\n");  
  printf("\n Jogador 2 vitorias: %f",vitorias[1]);
  printf("\n Jogador 2 derrotas: %f",vitorias[0]);
  printf("\n");  
  printf("\n Total de partidas : %f\n",(vitorias[0]+vitorias[1]));
  printf("\n*********************************************");     
  printf("\n\t\tPlacar");
  printf("\n*********************************************");
}  

void zeraPlacar(){
  // Zera as variáveis que mantém os dados de vitória logo zerando o placar    
  vitorias[0]=0;
  vitorias[1]=0;
  printf("\n*********************************************");     
  printf("\n\t\tPlacar Zerado!");
  printf("\n*********************************************\n");
  printf("\n Jogador 1 vitorias: %f",vitorias[0]);
  printf("\n Jogador 1 derrotas: %f",vitorias[1]);
  printf("\n");    
  printf("\n Jogador 2 vitorias: %f",vitorias[1]);
  printf("\n Jogador 2 derrotas: %f",vitorias[0]);
  printf("\n");    
  printf("\n Total de partidas : %f\n",(vitorias[0]+vitorias[1]));    
  printf("\n*********************************************");     
  printf("\n\t\tPlacar Zerado!");
  printf("\n*********************************************");    
}

void regras(){
  // Imprime as regras para se efetuar jogadas no jogo. 
  printf("\n*********************************************");
  printf("\n\t\tRegras!");
  printf("\n*********************************************\n");       
  printf("\nPara efetuar uma jogada se informa a posicao ");
  printf("\nda jogada ao modelo linha.coluna\n");
  printf("\nExemplo: 1.3 \n");
  printf("\nEsta jogada acima, vai marcar de acordo com o");
  printf("\no dono da jogada, o lance na linha 1 coluna 3\n");
  printf("\n*********************************************");
  printf("\n\t\tRegras!");
  printf("\n*********************************************");         
}

void abertura(){
  // Imprime informações sobre o programa
  printf("*********************************************");
  printf("\n\t\tJogo da Velha");
  printf("\n*********************************************");
  printf("\n");
  printf("\n\tJogo da velha PKY");
  printf("\n\tCriado em 2006");
  printf("\n\tPor Demon Cyber");
  printf("\n\tLinguagem: C");
  printf("\n\tTelefone:989898989");
  printf("\n\tContato: demoncyber@gmail.com");
  printf("\n\tA Faculdade qualquer");    
  printf("\n");
  printf("\n*********************************************");     
  printf("\n\t\tJogo da Velha");
  printf("\n*********************************************");  
}

int inicio(){
  // Imprime as opções de jogo e ápos isso lê a opção selecionada
  int result;
  printf("\n*********************************************");
  printf("\n\tPrograma de jogo da velha opcoes");
  printf("\n*********************************************\n");
  printf("\tJogador X Jogador  (1)\n");
  printf("\tJogador X PC       (2)\n");  
  printf("\tPlacar             (3)\n");
  printf("\tZera Placar        (4)\n");
  printf("\tRegras             (5)\n");  
  printf("\tSair               (6)\n");
  printf("\n\tOpcao:              ");
  scanf("%d",&result);
  return result;
}

void fimCasa(){
  // Imprime o corpo do fim de uma casa     
  printf(" ----- ");   
}

void inicioCasa(){
  // Imprime o corpo do ínicio de uma casa
  printf(" ----- ");
}

void casaVazia(){
  // Imprime o corpo de uma casa vazia
  printf("|     |");
}

void casaX(int line){
  // Imprime o corpo de uma casa que possuirá X     
  switch(line){
    case 0:
      printf("|X   X|");
    break;
    case 1:
      printf("| X X |");         
    break;      
    case 2:
      printf("|  X  |");         
    break;      
    case 3:
      printf("| X X |");         
    break;      
    case 4:
      printf("|X   X|");         
    break;      
  }  
}

void casa0(int line){
  // Imprime o corpo de uma casa que possuirá bolinha
  switch(line){
    case 0:
      printf("| *** |");
    break;
    case 1:
      printf("|*   *|"); 
    break;      
    case 2:
      printf("|*   *|");    
    break;      
    case 3:
      printf("|*   *|");         
    break;      
    case 4:
      printf("| *** |");      
    break;      
  }      
}

void zeraTabuleiro(){
  // Zera as variáveis que contém as posições das casas preenchidas
  int i,j;
  for(i=0; i <=2; i++){
    for(j=0; j <=2; j++){
        tabuleiro[i][j]=0;
    }
  }
}

void desenhaTabuleiro(){
  // Desenha o tabuleiro e as casas preenchidas com suas respctivas jogadas
  int i=0;
  int j=0;
  int z=0;
  printf("\n");
  for( z=0; z <= 2; z++){
  
    printf("\t    ");
    for( i=0; i <= 2; i++ )
      inicioCasa();     
    printf("\n");
      
    for( j=0; j < 5; j++ ){
      printf("\t    ");
      for( i=0; i <= 2; i++ ){
            
        if(tabuleiro[z][i] == 0)
          casaVazia();
        if(tabuleiro[z][i] == 1)
          casaX(j);
        if(tabuleiro[z][i] == -1)
          casa0(j);         
      }
      printf("\n");
    }
     
    printf("\t    ");
    for( i=0; i <= 2; i++ )
      fimCasa();         
    printf("\n");     
   }     
}

int verificaVitoria(){
  /*
    Verifica se algum jogador conseguiu condição de vitória
        
    Condições:
    
    *se a soma de toda uma linha, coluna ou diagonal resultar em 3 o jogador 1 
  venceu.
   
    *se resultar em -3 o jogador 2 venceu.
    
    *caso contrario ninguém venceu ainda
    
    *se todas as casas tiverem ocupadas ( 9 jogadas ) e nenhuma soma igualar os 
    casos acima patida empatou
    
  */
  int i,j;
  int somaA,somaB;
  somaA = 0;
  somaB = 0;
  
  for(j=0; j<3; j++){
    somaA = 0;
    somaB = 0;
    for(i=0; i<3; i++){
      somaA = somaA + tabuleiro[i][j];
      somaB = somaB + tabuleiro[j][i];
    }
    if (somaA == 3  || somaB == 3 )
      return 1;    
    if (somaA == -3 || somaB == -3)
      return 2;
  }

  somaA = tabuleiro[0][0] + tabuleiro[1][1] + tabuleiro [2][2];
  somaB = tabuleiro[0][2] + tabuleiro[1][1] + tabuleiro [2][0];
  if (somaA == 3  || somaB == 3 )
    return 1;    
  if (somaA == -3 || somaB == -3)
    return 2;
  if (njogada == 9)  
    return 3;
  return 0;
}

int verificaJogada(float jogada, int donoJogada){
  /*
    Verifica se a jogada é válida
    Caso sim:
      Verifica se a casa está vazia e então a preenche com o dono da Jogada
    Caso não:
      1 - Desenha de novo o tabuleiro com as posições sem a jogada inválida 
      2 - Informa uma mensagem de jogada Inválida com possivel erro a casa ja ter 
    sido preenchida    
  */
  if ((jogada == float(1.1)) && (tabuleiro[0][0] == 0)){
    tabuleiro[0][0] = donoJogada;
    return 1;
  }
  if ((jogada == float(1.2)) && (tabuleiro[0][1] == 0)){
    tabuleiro[0][1] = donoJogada;
    return 1;
  }     
  if ((jogada == float(1.3)) && (tabuleiro[0][2] == 0)){
    tabuleiro[0][2] = donoJogada;
    return 1;
  }     
  if ((jogada == float(2.1)) && (tabuleiro[1][0] == 0)){
    tabuleiro[1][0] = donoJogada;
    return 1;
  }     
  if ((jogada == float(2.2)) && (tabuleiro[1][1] == 0)){
    tabuleiro[1][1] = donoJogada;
    return 1;
  }     
  if ((jogada == float(2.3)) && (tabuleiro[1][2] == 0)){
    tabuleiro[1][2] = donoJogada;
    return 1;
  }     
  if ((jogada == float(3.1)) && (tabuleiro[2][0] == 0)){
    tabuleiro[2][0] = donoJogada;
    return 1;
  }     
  if ((jogada == float(3.2)) && (tabuleiro[2][1] == 0)){
    tabuleiro[2][1] = donoJogada;
    return 1;
  }     
  if ((jogada == float(3.3)) && (tabuleiro[2][2] == 0)){
    tabuleiro[2][2] = donoJogada;
    return 1;
  }
  desenhaTabuleiro();     
  printf("\n**Jogada Invalida \n(Nota: A jogada ja pode ter sido feita)");
  return 0;
}

int jogadaPCAutomatizada(int soma){
  /* 
    Ele verifica se a soma de uma linha ou coluna equivale a 2 ou -2
  caso sim, lá é a posição para a proxima jogada pois o computador vai
  vencer caso seja 2, ou poderá perder se não jogar naquela casa caso 
  seja -2.
  */
  int i,j,z;
  int somaA,somaB;
  float jogada;
  for(j=0; j<3; j++){
    somaA= 0;
    somaB= 0;
    for(i=0; i<3; i++){
      somaA = somaA + tabuleiro[i][j];
      somaB = somaB + tabuleiro[j][i];
    }
    
    if(somaA == soma){
      for( z=0; z < 3; z++){
        if(tabuleiro[z][j] == 0)
          i = z;
      }                                                         
      jogada = (i+1) + ((j+1)*.10);                              
      verificaJogada(jogada,1);      
      return 1;
      }
    if(somaB == soma){             
      for( z=0; z < 3; z++){
        if(tabuleiro[j][z] == 0)
          i = z;
      }                             
      jogada = (j+1) + ((i+1)*.10);            
      verificaJogada(jogada,1);
      return 1;
      }      
  }
  
  somaA = tabuleiro[0][0] + tabuleiro[1][1] + tabuleiro [2][2];
  if(somaA == soma){
    
    for( z=0; z < 2; z++){
      if(tabuleiro[z][z] == 0)
        jogada = float(z + float((z+1)*0.10)+1);
    }
                  
    verificaJogada(jogada,1);
    return 1;    
  }  
  
  somaB = tabuleiro[0][2] + tabuleiro[1][1] + tabuleiro [2][0];   
  if(somaB == soma){
           
    if(tabuleiro[0][2] == 0)
      jogada = 1.3;
    if(tabuleiro[1][1] == 0)
      jogada = 2.2;
    if(tabuleiro[2][0] == 0)
      jogada = 3.1;
              
    verificaJogada(jogada,1);
    return 1;    
  }
  
  return 0;
}

void PCJoga(){
  /*
    Ele chama duas vezes o jogadaPCAutomatizada uma verificando se o pc
  está auma jogada da vitória ou se ele está a uma jogada da derrota, caso
  mão se encaixe nestas duas jogadas, ele procura uma jogada preparada, caso 
  não encontre informa erro de IA.
  */
  if( jogadaPCAutomatizada(2) != 0 ) 
    return;
  if( jogadaPCAutomatizada(-2) != 0 )
    return;
    
  switch(njogada){
    case 0:
      verificaJogada(1.1,1);
    break;
    case 2:
      if(tabuleiro[2][2] == 0)   
        verificaJogada(3.3,1);
      else
        verificaJogada(1.3,1);
    break;
    case 4:
      verificaJogada(3.1,1);   
    break;
    default:
      printf("Erro de IA por favor feche o programa CTRL+C e informe o erro");
    break;
  }
  printf("\nA jogada abaixo foi do pc");
}

int verificaDonoJogada(){
  /*
    método que verifica o dono da jogada baseado no lance da jogada
    Condições
      1 = jogador 1 (X)
      -1 = jogador 2 (O)
  */
  if((njogada % 2) == 0 )
    return 1;    
  else
    return -1;
}

void leJogada(){     
  /*
    Verifica o dono da jogada, lê a jogada , caso jogada válida aumenta contador
    de jogadas e desenha o tabuleiro, caso não continua a ler jogadas até a 
    existêncai de uma válida.
  */
  float jogada;
  int continuar=0;
  int donoJogada;
  int jogadaCorreta=0;
       
  donoJogada= verificaDonoJogada();     
  if((donoJogada == 1) && (gamePC == 1))
    PCJoga();
  else
    while( continuar == 0){
      printf("\nInforme a jogada:\n");
      scanf("%f",&jogada);
      continuar = verificaJogada(jogada,donoJogada);
    }

  njogada= njogada + 1;
       
  desenhaTabuleiro();
}

void jogar(){
  /*
    Fica verificando a condição de vitória, caso não tenha acontecido, continua 
  a ler as jogadas.Apos condição de vitória ter sido resolvida imprime resultado
  da partida.
  */
  int vitoria=0;
  while( verificaVitoria() == 0)
    {
      leJogada();  
    }
    
  vitoria = verificaVitoria();
  if(vitoria == 1){
    imagemVitoria(1);
    if(gamePC != 1)
      vitorias[0] = vitorias[0] + 1;
  }
  if(vitoria == 2){
    imagemVitoria(2);
    if(gamePC != 1)    
      vitorias[1] = vitorias[1] + 1;    
  }
  if(vitoria == 3){
    empate();             
    if(gamePC != 1){
      vitorias[0] = vitorias[0] + 0.5;
      vitorias[1] = vitorias[1] + 0.5;
    }
  }
}

void montaTabuleiro(){
   /*
     Zera as posições das jogadas do tabuleiro
     Zera o numero de jogadas feitas
     Desenha o tabuleiro
     Começa o jogo
   */
   zeraTabuleiro();
   njogada = 0;
   desenhaTabuleiro();
   jogar();
}

void preparePC(){
  gamePC = 1;
  montaTabuleiro();
  gamePC = 0;     
}

main(){
  int continuar = 1;
  int option;
  
  abertura();
    
  while(continuar ==1){
    option = inicio();
    switch (option){
      case 1:
        montaTabuleiro();
        break;
      case 2:
        preparePC();
        printf("");
        break;         
      case 3:
        placar();
        break;
      case 4:
        zeraPlacar();
        break;
      case 5:
        regras();
        break;
      case 6:
        continuar = 0;
        break;
      default:
        opcaoInvalida(option);
      break;
    }
  }     
}

Jogo do Labirinto

Jogo da cobrinha (Snake II) refeito em C e C++

Pipeling

HaiDownlodManager - simples programa para baixar arquivos

ponteiros utilizando &