#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <ctype.h>
using namespace std;
//procedimento do GOTOXY(trabalhando com coordenadas)-Jogo da velha. 
void gotoxy(int x, int y) 
{ 
HANDLE hOut; 
int i; 
COORD Position; 

 

hOut = GetStdHandle(STD_OUTPUT_HANDLE); 

Position.X = x; 
Position.Y = y; 
SetConsoleCursorPosition(hOut,Position);
}
// Procedimento para imprimir a grade na tela e ler valores-Jogo da Velha.
bool grade(string simb[3][3],int px,int py,string psimb,string pnome)
{
     bool pganhou = false;
     system("cls");// Comando que limpa a Tela.
     int l,c;// Variaveis Contadoras.
     string J1;
     string J2;
     string velha;
    
     for (c=0;c<=2;c++) { // Percorrer as colunas da Matrix.         
        for (l=0;l<=2;l++) { // Percorrer as linhas da Matrix.           
            if (simb[l][c]!="X" && simb[l][c]!="O") { //Alimentando a Matrix.
                simb[l][c]="  ";
            } 
         }
     }
    
     simb[px][py] = psimb;// Inserção de valores.
     gotoxy(9,5);
     cout << "\n\t    C0  C1  C2";
     gotoxy(9,7);
     cout<<"L0"<<"  "<<simb[0][0]<<"|"<<"  "<<simb[0][1]<<"|"<<"  "<<simb[0][2]; // estrutura da Grade e escrita de valores. 
     gotoxy(9,8);
     cout<<"   ____________";
     gotoxy(9,10);
     cout<<"L1"<<"  "<<simb[1][0]<<"|"<<"  "<<simb[1][1]<<"|"<<"  "<<simb[1][2]; // estrutura da Grade e escrita de valores.
     gotoxy(9,11);
     cout<<"   ____________";
     gotoxy(9,13);
     cout<<"L2"<<"  "<<simb[2][0]<<"|"<<"  "<<simb[2][1]<<"|"<<"  "<<simb[2][2]<<endl; // estrutura da Grade e escrita de valores.
     cout<<"\n  ";
     // condições de ganho-Jogo da Velha.
//Percorre na vertical --> //Colunas primeiro que Linhas.
    if (simb[0][0]==psimb && simb[1][0]==psimb && simb[2][0]==psimb) { // Verifica a coluna 0.
        
        pganhou = true;
     } else if (simb[0][1]==psimb && simb[1][1]==psimb && simb[2][1]==psimb) { 
              
        pganhou = true;
    } else if (simb[0][2]==psimb && simb[1][2]==psimb && simb[2][2]==psimb) { 
                 
        pganhou = true;
    //Percorre na Horizontal --> //Colunas primeiro que Linhas. 
    } else if (simb[0][0]==psimb && simb[0][1]==psimb && simb[0][2]==psimb) { 
                  
        pganhou = true;
    } else if (simb[1][0]==psimb && simb[1][1]==psimb && simb[1][2]==psimb) {//??????
          
        pganhou = true;
    } else if (simb[2][0]==psimb && simb[2][1]==psimb && simb[2][2]==psimb) {//?????? 
      
        pganhou = true;
     // Verifica as diagonais --> // Colunas primeiro que linhas. 
     // Diagonal Esquerda.
    } else if (simb[0][0]==psimb && simb[1][1]==psimb && simb[2][2]==psimb) { 
             
        pganhou = true; 
     // Diagonal Direita.   
    } else if (simb[1][2]==psimb && simb[1][1]==psimb && simb[2][0]==psimb) { 
  
        pganhou = true;
    }
    
      
     return pganhou;               
     getch();
     
}
bool limpa_grade(string simb[3][3])
{
     bool pganhou = false;
     system("cls");// Comando que limpa a Tela.
     int l,c;// Variaveis Contadoras.
     string J1;
     string J2;
     string velha;
    
     for (c=0;c<=2;c++) { // Percorrer as colunas da Matrix.         
        for (l=0;l<=2;l++) { // Percorrer as linhas da Matrix.           
                simb[l][c]="  "; 
         }//Fim Para.
     }//Fim Para.
    
     gotoxy(9,8);
     cout << "\n\t  C0  C1  C2  ";
     gotoxy(9,10);
     cout<<"L0"<<"  "<<simb[0][0]<<"|"<<"  "<<simb[0][1]<<"|"<<"  "<<simb[0][2]; // estrutura da Grade e escrita de valores. 
     gotoxy(9,11);
     cout<<"  ____________";
     gotoxy(9,13);
     cout<<"L1"<<"  "<<simb[1][0]<<"|"<<"  "<<simb[1][1]<<"|"<<"  "<<simb[1][2]; // estrutura da Grade e escrita de valores.
     gotoxy(9,14);
     cout<<"  ____________";
     gotoxy(9,16);
     cout<<"L2"<<"  "<<simb[2][0]<<"|"<<"  "<<simb[2][1]<<"|"<<"  "<<simb[2][2]<<endl; // estrutura da Grade e escrita de valores.
}

bool verifica_posicao(int x, int y)
{
    bool res = false;    

      if (x <0 || x>2){
     	res = true;
     }// fim se. 
      if (y <0 || y>2){
     	res = true;
     }// fim se.   
     
     return res;	
}// fim do procedimento bool verifica_posicao

 // Mensagem de erro,Posição já ocupada.   
bool verifica_valor(int x, int y, string simb, string M[3][3])
{
    bool res;    
    res = false;
	 if (M[x][y]== "X" || M[x][y]== "O") {
         cout<<"Jogada Invalida,Posicao ja Ocupada";
         res = true;
     } //fim se.
     
     
     
     if (verifica_posicao(x,y)) {
        cout<<"Posicao inexistente";
        res = true;            
     }
     
     return res;
}// fim do procedimento bool verifica_valor


// Inicio da Programação-Jogo da Velha.
int main(){
    string J1,J2;                   // V   P
    string psimb;                   // A   R
    string Jogo_M[3][3];            // R   I
    int linha,coluna;               // I D N
    int partida;                    // A O C
    int placar[3];                  // V   I
    placar[1] = 0;                  // E   P
    placar[2] = 0;                  // I   A
    bool existe,pganhou;            // S   L
    string resp; // variavel do menu                             
 {  
	      HANDLE hConsole;

	  int k;

	  hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
	  for(k=0; k < 14; k=14)
	  {
		  SetConsoleTextAttribute(hConsole, k=14);
          cout << "\n \t\t __________________________________________    ";  
          cout << "\n                                                    "; 
          cout << "\n \t\t  JJJJJJJJJJJ OOOOOOOO GGGGGGG  OOOOOOOO       ";
          cout << "\n \t\t      JJJ     OO    OO GG       OO    OO       ";
          cout << "\n \t\t      JJJ     OO    OO GG  GGGG OO    OO       ";
          cout << "\n \t\t  JJ  JJJ     OO    OO GG    GG OO    OO       ";
          cout << "\n \t\t  JJJJJJJ     OOOOOOOO GGGGGGGG OOOOOOOO       ";
          cout << "\n                                                    ";
          cout << "\n \t\t             DDDDDDD   AAAAA   ";
          cout << "\n \t\t             DD    DD  AA  AA   ";
          cout << "\n \t\t             DD    DD  AAAAAA   ";
          cout << "\n \t\t             DDDDDDD   AA  AA   ";
          cout << "\n                                                    "; 
          cout << "\n \t\t VV       VV EEEEE LL    HH    HH AAAAAAA      ";
          cout << "\n \t\t  VV     VV  EE    LL    HH    HH AA    AA     ";
          cout << "\n \t\t   VV   VV   EEEE  LL    HHHHHHHH AAAAAAAA     ";
          cout << "\n \t\t    VV VV    EE    LL    HH    HH AA    AA     ";
          cout << "\n \t\t      VV     EEEEE LLLLL HH    HH AA    AA     ";
          cout << "\n \t\t __________________________________________\n\n\t\t";
          
	  SetConsoleTextAttribute(hConsole, 7);
	  system("pause");
	  system("cls");

      int resp=0; //inicio do menu
        while (resp != 4){
          cout<<"\n  __________________________________________________________________________\n";
          cout<<" |                                                                          |\n";       
          cout<<" |   ____________________________________________________________________   |\n";
          cout<<" |  |                                                                    |  |\n";
          cout<<" |  | IFSP - CAMPUS SALTO | PROJETO JOGO DA VELHA | AEP - CLAUDIO ROVERI |  |\n";
          cout<<" |  |____________________________________________________________________|  |\n";
          cout<<" |                                                                          |\n";
          cout<<" |                          ____________________                            |\n";
          cout<<" |                         |        MENU        |                           |\n";
          cout<<" |                         |____________________|                           |\n";
          cout<<" |                         | 1 - INICIAR JOGO!  |                           |\n";
          cout<<" |                         | 2 - COMO JOGAR     |                           |\n";
          cout<<" |                         | 3 - SOBRE          |                           |\n";
          cout<<" |                         | 4 - SAIR           |                           |\n";
          cout<<" |                         |____________________|                           |\n";
          cout<<" |                                                                          |\n";
          cout<<" |__________________________________________________________________________|\n";              
          
		  cout<<"\n                           Entre com sua opcao: ";
          cin>>resp;
		  if((resp > 4)||(resp < 1)){
                   cout<<"\n\t\t    >> OPCAO INVALIDA! TENTE OUTRA VEZ! \n\n\t\t  ";
		  system("pause");
               } //fim se
		  system("cls");
		  switch(resp){	
			  case 2:
                 cout << "\n\t\t--------------------------------------------------\n";
                 cout << "\t\t\t\t    COMO JOGAR\n"; 
                 cout << "\t\t--------------------------------------------------\n";
				 cout << "\n       O TABULEIRO DO JOGO DA VELHA E UMA MATRIZ DE TRES LINHAS POR TRES";
                 cout << "\n          COLUNAS. Os JOGADORES JOGAM ALTERNADAMENTE, UM DE CADA VEZ,";
                 cout << "\n                       NUMA POSICAO QUE ESTEJA VAZIA.\n";
                 cout << "\n\t\t\t        C0    C1    C2   ";
                 cout << "\n\t\t\t L0        |     |        ";  //matriz[0][0],matriz[0][1],matriz[0][2]);
                 cout << "\n\t\t\t      _____|_____|_____  ";
                 cout << "\n\t\t\t L1        |     |        ";  //matriz[1][0],matriz[1][1],matriz[1][2]);
                 cout << "\n\t\t\t      _____|_____|_____  ";
                 cout << "\n\t\t\t L2        |     |        ";  //matriz[2][0],matriz[2][1],matriz[2][2]);
                 cout << "\n\t\t\t           |     |        "; 
                 cout << "\n\n    A MATRIZ E COMPOSTA POR LINHAS L0, L1 E L2. E POR COLUNAS C0, C1, C2.";
                 cout << "\n        O OBJETIVO E CONSEGUIR MARCAR TRES X's OU TRES 0's NA HORIZONTAL";
                 cout << "\n           OU VERTICAL OU DIAGONAL, E AO MESMO TEMPO, QUANDO POSSIVEL,";
                 cout << "\n                        IMPEDIR O ADVERSARIO DE GANHAR.\n\n\t          ";
				 system("pause");
				 system("cls");
				 break;
			case 3:
				 cout << "\n\t\t--------------------------------------------------\n";
                 cout << "\t\t\t\t       SOBRE\n"; 
                 cout << "\t\t--------------------------------------------------\n";
				 cout << "\n\t\t\t       IFSP - CAMPUS SALTO";
				 cout << "\n\t INSTITUTO FEDERAL DE EDUCACAO, CIENCIA E TECNOLOGIA DE SAO PAULO\n";
				 cout << "\n\t\t     TECNICO EM INFORMATICA - MODULO I - 2015";
				 cout << "\n\t\t           AEP - ALGORITMO E PROGRAMACAO";
				 cout << "\n\t\t            Prof. MSc. CLAUDIO ROVERI\n";
				 cout << "\n\t\t              PROJETO JOGO DA VELHA";
				 cout << "\n\t\t                     EQUIPE:";
				 cout << "\n\t\t                JESSICA BARBIERI";
				 cout << "\n\t\t                  JONATAS BUZO";
				 cout << "\n\t\t                 MARIANA GUEDES";
				 cout << "\n\t\t                 MARINA BAPTISTA\n\n\n\t\t ";
				 system("pause");
				 system("cls");
				 break;
			
			case 4:
                 cout<<"\n\n\n\n";
                 cout<<"\n\n";
                 cout<<"\n\n"; 
                 cout<<"\n\n\t    >> VOCE FINALIZOU O JOGO! OBRIGADO PELA PARTICIPACAO!\n\t\t        >> PRESSIONE ENTER PARA SAIR!\n\n\n\n\n\n\n\n\n\n\n\n\n";
				 break;
			
			case 1:
			   	 //Conhecendo os Jogadores(Informando os nomes)-Jogo da Velha.
                 cout<<"\n Jogador 1 informe seu nome: \n ";
                 cin>> J1; // Recebendo o nome do jogador 1.
                 cout<<"\n Jogador 2 informe seu nome: \n ";
                 cin>> J2; // Recebendo o nome do jogador 2.
                 cout<<endl<< J1<<" = X" <<endl<<J2<<" = O ";
                 cout<<endl;
 
              partida = 0;
              // criar estrutura de repetição para iniciar um novo jogo até que placar=3 para J1 || J2.
              while (partida <3) {
                       // Lendo a jogada do jogador 1 e verificando posição disponivel.                
                    existe = true;
                    while (existe) {
                        
						cout<<" \n \n"<< J1 <<" Informe sua jogada.\n";
                        cout<<"\n LINHA: ";
						cin>>linha;
                        cout<<"\n COLUNA: ";
						cin>>coluna;       
                        existe = verifica_valor(linha, coluna, "X", Jogo_M);
                        } //fim enquanto
          
                  if (grade(Jogo_M,linha,coluna,"X",J1)) {
                  placar[1]++;
                       //Contando os pontos no placar.
                        cout << J1 <<" Voce Ganhou, Parabens!";
                        cout<<endl<<endl;
                       //Placar Jogador 1.
						cout<<" "<<" Placar"<<endl<<endl<<" "<<placar[1]<<" "<<"X"<<" "<<placar[2];
                        partida++;
                        getch();
                        limpa_grade(Jogo_M);			                                                  
                  } //fim se
           
		                         
              // Lendo a jogada do jogador 2 e verificando posição disponivel. 
                  
               existe = true;
               while (existe) {

                       cout<<"\n"<< J2 <<" Informe sua jogada.\n ";
                       cout<<"\n LINHA: ";
					   cin>>linha;
                       cout<<"\n COLUNA: ";
			      	   cin>>coluna; 
                       existe = verifica_valor(linha,coluna,"O", Jogo_M);
               }//fim enquanto.
           
               if (grade(Jogo_M,linha,coluna,"O",J2)) {
                      placar[2]++;//Contando os pontos no placar.
                      cout << J2 <<" Voce Ganhou, Parabens!";
                      cout<<endl<<endl;
                      //Placar Jogador 2.
                      cout<<" "<<" Placar"<<endl<<endl<<" "<<placar[1]<<" "<<"X"<<" "<<placar[2];
                      getch();
                      partida++;
                      limpa_grade(Jogo_M);		 			               
               }//fimse.            
              } //fim enquanto.	
	} //fim switch
	system("cls");//limpa a tela
		  } //fim enquanto
	} //fim para
}// fim procedimento muda de cor
} //fim algoritmo