//*******************************************************************
//
//  Projet 6 - Domino - Christophe Mortier - 1ère info - 1998
//
//  Programmé sous Visual C++ 5.0 , pour Borland 4.5 ajouter
//     la ligne --- #include <bool.h> ---
//
//*******************************************************************

#include <iostream.h>
#include <stdlib.h>
#include <time.h>

// La structure domino qui défini chaque domino

typedef struct
{
	// les 2 valeurs sur le domino
	int a,b;
	// s'il appartient à un joueur , lequel , sinon 0 ou encore 3 si
	// le domino est déja placé en jeu
	int joueur;
} domino;

// cette structure défini les 2 extremites de la file de domino
// value1 et value2 sont les valeurs et extx1 ... sont les coord
// sur le plateau.

typedef struct
{
	int value1;
	int extx1,exty1;
	int value2;
	int	extx2,exty2;
}extrem;

// Cette structure défini quel joueur est en train de jouer (enjeu)
// et quel est le nombre de piece de chaque joueur.

typedef struct
{
	int enjeu;
	int nbr_piece[2];
}joueur;

// Ici 2 nouvelles définition , une pour les 21 dominos et
// une pour le plateau.

typedef domino set_domino[21];
typedef int plateau[16][16];

// Fonction qui demande un entier , elle fait une boucle jusqu'a
// ce qu'il y en ai un correctement entré , ensuite elle le renvoie.

int getint()
{
	int i;
	// s'assure qu'on a bien un entier
	while(!(cin >> i) || cin.peek()!='\n')
	{
		cout << "Bad integer, Try again! : ";
		// efface les erreurs et le buffer.
		cin.clear();
		cin.ignore(1000,'\n');
	}
	return i;
}

// cette fonction initialise le plateau à 0

void init_plateau(plateau& pt)
{
	int i,j;
	for(i=0;i<16;i++)
	{
		for(j=0;j<16;j++)
		{
			pt[i][j]=0;
		}
	}
}

// Cette fonction affiche le plateau à l'écran

void affiche_plateau(plateau pt)
{
	int i,j;
	char c;
	cout << endl;
	cout << "\t    A B C D E F G H I J K L M N O P\n";
	cout << "\t    -------------------------------\n";
	//pour chaque ligne
	for (i=0;i<16;i++)
	{
		c=(char)i+97;
		cout << "\t" << c; 
		cout << " | ";
		
		
		for (j=0;j<16;j++)
		{
			if (pt[i][j]!=0)
			{
				cout << pt[i][j] << " ";
			}
			else
			{
				cout << "  ";
			}
		}
		cout << endl;
	}
	cout << endl;
}

// Cette fonction affiche les 2 sets de dominos des 2 joueurs
// dans l'ordre ainsi que le chiffre qui leurs correspondra

void affiche_domino(set_domino dm)
{
	int i;
	int count;
	// affiche les dominos du joueur 1
	cout << "Player 1 : ";
	count=1;
	for (i=0;i<=20;i++)
	{
		if(dm[i].joueur==1)
		{
			cout << "(" << count << ") " << dm[i].a;
			cout << " " << dm[i].b << " ";
			count++;
		}
	}
	cout << endl;
	// affiche les dominos du joueur 2
	cout << "Player 2 : ";
	count=1;
	for (i=0;i<=20;i++)
	{
		if(dm[i].joueur==2)
		{
			cout << "(" << count << ") " << dm[i].a;
			cout << " " << dm[i].b << " ";
			count++;
		}
	}
	cout << endl;
}

// Cette fonction crée les 21 dominos

void init_domino(set_domino& dm)
{
	int i,j,k;
	k=0;
	// k correspond au numero du domino.
	for (i=1;i<7;i++)
	{
		
		for (j=i;j<7;j++)
		{
			dm[k].a=i;
			dm[k].b=j;
			dm[k].joueur=0;
			k++;
		}
	}
}

// Cette fonction distibue 6 dominos au hazard à chaque joueur
// Elle tire un chiffre au hazard entre 0 et 20 ,ensuite elle
// verifie que le domino est encore dans la pile (dm[].joueur=0)
// (dm[].joueur=3) n'est pas à prendre en compte puisque aucun domino
// n'est encore sur le plateau.

void distrib_domino(set_domino& dm)
{
	int j;
	int haz;
	int i;
	// met 6 dominos au hazard chez chaque joueur.
	// pour chaque joueur , on veut 6 dominos
	for (j=1;j<=2;j++)
	{
		i=0;
		// cherche un domino non assigné à un joueur
		while (i<6)
		{
			// on veux un chiffre de 0 a 20
			haz=int(double(rand())/RAND_MAX*21);
			if (dm[haz].joueur!=1 && dm[haz].joueur!=2)
			{
				dm[haz].joueur=j;
				i++;
			}
		}
	}
}

// cette fonction sert à définir les extremités de la file de domino.
// elle renvoie la structue ainsi assignée.

extrem definir_extremite(int v1,int v2,int x1,int y1,int x2,int y2)
{
	extrem ex;
	ex.value1=v1;
	ex.value2=v2;
	ex.extx1=x1;
	ex.exty1=y1;
	ex.extx2=x2;
	ex.exty2=y2;
	return ex;
}

// Cette fonction tire un domino au hazard non encore assignée à
// un joueur et le place au centre du plateau.

void premier_domino(plateau& pt,set_domino& dm,extrem& ex)
{
	int haz;
	bool found=false;
	//trouver un domino encore non utilisé
	do
	{
		// on veux un chiffre de 0 a 20
		haz=int(double(rand())/RAND_MAX*21);
		if (dm[haz].joueur!=1 && dm[haz].joueur!=2)
		{
			dm[haz].joueur=3;
			found=true;
		}
	}while(!found);
	//definir les 2 extremiters de la file de dominos.
	ex=definir_extremite(dm[haz].a,dm[haz].b,7,7,7,8);
	//modifier le plateau
	pt[7][7]=dm[haz].a;
	pt[7][8]=dm[haz].b;
}

// cette fonction demande au joueur actuel quel numero de piece 
// (le numero qui est affiché) il 
// compte placer , continue jusqu'a ce qu'il donne un numero 
// de domino possible
// cette fonction renvoit le numero du domino selectionnné (du 
// domino lui même et pas le numero qui est affiché)

int demande_piece(joueur pl,plateau pt,set_domino dm,extrem ext)
{
	int i,count=0;
	bool ok=false;
	int lapiece;
	int bonne_piece;
	// tant que le domino n'est pas valable , faire la boucle
	while(!ok)
	{
		cout << "Which piece Player " << pl.enjeu << " ? : ";
		// demande un entier
		lapiece=getint();
		// verifie que c'est bien une piece que possède le joueur
		if (lapiece>0 && lapiece<=pl.nbr_piece[(pl.enjeu)-1])
		{
			i=0;
			count=0;
			bonne_piece=0;
			// cherche le numero du domino correspondant à la piece
			while(count<lapiece)
			{
				if(dm[i].joueur==pl.enjeu)
				{
				
					bonne_piece=i;
					count++;
				}
				i++;
			}
			// cherche si le domino selectionner à bien une des valeurs possibles
			// cad la valeur d'une des extremités 
			if(ext.value1==dm[bonne_piece].a || ext.value1==dm[bonne_piece].b ||
				ext.value2==dm[bonne_piece].a || ext.value2==dm[bonne_piece].b)
			{
				ok=true;
			}
			else
			{
				// sinon reafficher et envoyer un message d'erreur
				affiche_plateau(pt);
				affiche_domino(dm);
				cout<<endl;
				cout<<"This piece isn't good , player ";
				cout<< pl.enjeu<< ", try again."<< endl;	
			}
			
		}
		else
		{
			// sinon reafficher et envoyer un message d'erreur
			affiche_plateau(pt);
			affiche_domino(dm);
			cout<<endl;
			cout<<"this piece isn't good , player ";
			cout<< pl.enjeu<< ", try again"<< endl;			
		}
		
	}
	// renvoie le numéro du domino
	return bonne_piece;
}

// cette fonction verifie que 2 coord sont bien adjacentes
// elle renvoie true si oui , sinon false

bool check_autour(int x1,int y1,int x2,int y2)
{
	bool correct=false;
	// si les 2 morceaux ont la meme ligne
	if(x1==x2)
	{
		// les 2 morceaux doivent avoir une colonne differente
		// separée de 1 case.
		if (y1==y2-1 || y1==y2+1)
		{
			correct=true;
		}
	}
	//si les 2 morceaux ont la meme colonne
	if(y1==y2)
	{
		// les 2 morceaux doivent avoir une ligne differente
		// séparée de 1 case
		if(x1==x2-1 || x1==x2+1)
		{
			correct=true;
		}
	}
	return correct;
}

// cette fonction verifie qu'aucun morceau de domino ne soit déja
// placer autour d'une certaine coordonée

bool check_autour_plateau(plateau pt,int x,int y)
{
	bool ok=false;
	int x1=15,x2=0,y1=15,y2=0;
	//verifie que l'on ne se trouve pas sur un des bords , si
	// oui , alors il ne faut pas verifier la (on remplace la 
	//verification pas la coordonée elle même , mais cela ne change
	// pas le but de cette opération.
	if(x!=15)
		x1=x+1;
	if(x!=0)
		x2=x-1;
	if(y!=15)
		y1=y+1;
	if(y!=0)
		y2=y-1;
	// verifie que l'on n'a pas de morceau de domino autour
	// de la coord x et y
	if(pt[x1][y]==0 && pt[x2][y]==0 && pt[x][y1]==0 
		&& pt[x][y2]==0 && pt[x][y]==0)
	{
		ok=true;
	}
	
	return ok;
}

// cette fonction demande les coords sur lesquels il faut placer 
// le domino , elle verifie que les données ont le bon format et
// si le domino peut être placer à cet endroit , si oui, elle
// fait les modification , si non , elle renvoie en message
// d'erreur et demande de réessayer.

void demande_pos(joueur& pl,plateau& pt,set_domino& dm,
				 extrem& ext,int wpiece)
{
	int i,count=0;
	char ligne[5];
	bool ok=false;
	bool next[4];
	int place[4];
	int which;
	int partie_qui_touche,partie_qui_touche_pas,ext_qui_touche;
	bool bout_touche_pas=false;
	int valeurext;
	
	while (!ok)
	{
		cout << "Which coordinates (lineRow ex: eC eD) Player " ;
		cout << pl.enjeu << " ? : "<<endl;
		//lit caractère par caractère en prend 4.
		//initialise i à 0
		i=0;
		// passe les blancs au début s'il y en a
		cin >> ws;
		// tant que on n'a pas 4 caractères 
		while (i < 4)
		{
			// on prend 1 caractère non blanc
			cin >> ligne[i];
			// on increment le conteur
			i++;
		}
		// le dernier doit être un caractère nul
		ligne[i]='\0';
		// passe tout le reste jusqu'a un enter.
		cin.ignore(1000,'\n');
		cout <<endl<< "You just enter : " << ligne <<endl;
		//ici on verifier les coords.
		// a-t-on bien lignecolonnelignecolonne cad aAaA
		// de plus , on verifie que c'est bien une piece
		// du plateau a->p et A->P
		if(ligne[0]>=97 && ligne[0]<=112 && ligne[2]>=97
			&& ligne[2]<=112 && ligne[1]>=65 && ligne[1]<=80
			&& ligne[3]>=65 && ligne[3]<=80)
		{
			//on test maintenant si les coord forme bien
			// un domino et pas 2 morceaux éparpiller
			// avant on crée un nouveau vecteur d'entier à partir
			//des lettres initiales
			place[0]=(int)ligne[0]-97;
			place[1]=(int)ligne[1]-65;
			place[2]=(int)ligne[2]-97;
			place[3]=(int)ligne[3]-65; 
			if(check_autour(place[0],place[1],place[2],place[3]))
			{
				
				//on test maintenant qu'une des 2 coord est bien a une
				// extremité
				// avant on test les 4 cases autours de chaque extremité
				// et de chaque bout du domino
				next[0]=check_autour(place[0],place[1],ext.extx1,ext.exty1);
				next[1]=check_autour(place[0],place[1],ext.extx2,ext.exty2);
				next[2]=check_autour(place[2],place[3],ext.extx1,ext.exty1);
				next[3]=check_autour(place[2],place[3],ext.extx2,ext.exty2);
				if(next[0] || next[1] || next[2] || next[3])
				{
					
					// on test maintenant si le domino ne touche pas un
					// autre déja placer (si le 2eme bout ne le touche pas).
					count=0;
					for(i=0;i<4;i++)
					{
						count+=(int)next[i];
						if(next[i]) which=i;
					}
					
					// = 1 si 1er morceau 2 l'autre
					partie_qui_touche=((int)which/2)+1;
					// =1 si la 1ere extrémite , sinon l'autre
					ext_qui_touche=(which % 2);
					// inverse de partiequitouche
					partie_qui_touche_pas=(partie_qui_touche % 2);
					partie_qui_touche--;
					bout_touche_pas=check_autour_plateau(pt,
						place[partie_qui_touche_pas*2],
						place[(partie_qui_touche_pas*2)+1]);
					// si on a un seul des bouts du domino qui touche une
					// des extrémité et que l'autre ne touche aucun autre
					//domino déja placé sur le plateau
					if(count==1 && bout_touche_pas==true)
					{
						//on test maintenant s'il est possible , cad si l'extre
						//ité a bien une valeur d'un des 2 membre du domino.
						if(ext_qui_touche==0)
						{
							valeurext=ext.value1;
						}
						else
						{
							valeurext=ext.value2;
						}

						if(dm[wpiece].a==valeurext || dm[wpiece].b==valeurext)
						{

							//on place le donimo sur le plateau et on change 
							//l'extremite
							if(dm[wpiece].a==valeurext)
							{
								pt[place[partie_qui_touche*2]]
									[place[(partie_qui_touche*2)+1]]=
									dm[wpiece].a;
								pt[place[partie_qui_touche_pas*2]]
									[place[(partie_qui_touche_pas*2)+1]]
									=dm[wpiece].b;
								if(ext_qui_touche==0)
								{
									ext.value1=dm[wpiece].b;
									ext.extx1=place[partie_qui_touche_pas*2];
									ext.exty1=place[(partie_qui_touche_pas*2)+1];
								}
								else
								{
									ext.value2=dm[wpiece].b;
									ext.extx2=place[partie_qui_touche_pas*2];
									ext.exty2=place[(partie_qui_touche_pas*2)+1];
								}
							}
							else
							{
								pt[place[partie_qui_touche*2]]
									[place[(partie_qui_touche*2)+1]]
									=dm[wpiece].b;
								pt[place[partie_qui_touche_pas*2]]
									[place[(partie_qui_touche_pas*2)+1]]
									=dm[wpiece].a;
								if(ext_qui_touche==0)
								{
									ext.value1=dm[wpiece].a;
									ext.extx1=place[partie_qui_touche_pas*2];
									ext.exty1=place[(partie_qui_touche_pas*2)+1];
								}
								else
								{
									ext.value2=dm[wpiece].a;
									ext.extx2=place[partie_qui_touche_pas*2];
									ext.exty2=place[(partie_qui_touche_pas*2)+1];
								}
							}
							// on change le domino lui-meme
							dm[wpiece].joueur=3;
							pl.nbr_piece[pl.enjeu-1]--;
							// tout est fait comme il faut , on peut
							// alors quitter la boucle
							ok=true;
						}
						else
						{
							// tous les messages d'erreurs qui suivent
							// correspondent au type de test non conforme
							
							affiche_plateau(pt);
							affiche_domino(dm);
							cout << "This is not a valide domino";
							cout << count;
							cout << endl;
						}
					}
					else
					{
						affiche_plateau(pt);
						affiche_domino(dm);
						cout << "This domino is next more than one on the board";
						cout << count;
						cout << endl;
					}
				}
				else
				{
					affiche_plateau(pt);
					affiche_domino(dm);
					cout << "This domino must be on extremities";
					cout << endl;
				}
			}
			else
			{
				affiche_plateau(pt);
				affiche_domino(dm);
				cout << "The 2 parts of the domino must be adjoining";
				cout << endl;
			}
			
		}
		else
		{
			affiche_plateau(pt);
			affiche_domino(dm);
			cout << "You must enter valid coordinates (aBaB)";
			cout << endl;
		}
		
	}
}

// cette fonction verifie s'il est possible au joueur de jouer un 
// domino qu'il possède

bool verifie_possible(joueur pl,set_domino dm,extrem ext)
{
	bool possible=false;
	int i;
	// on passe sur tout les domino
	for (i=0;i<21;i++)
	{
		// il faut que le domino soit bien au joueur actuel.
		if(dm[i].joueur==pl.enjeu)
		{
			// on verfie qu'il peut en placer un.
			if(dm[i].a==ext.value1 || dm[i].a==ext.value2 ||
				dm[i].b==ext.value1 || dm[i].b==ext.value2)
			{
				possible=true;
			}
		}
	}
	return possible;
}

// cette fonction tire un domino de la pile et la donne au joueur actuel

int tire_une_piece(joueur& pl,set_domino& dm)
{
	int haz;
	bool ok=false;
	// tant qu'un domino non assigné n'est pas tiré
	while(!ok)
	{
		// tire un chiffre au hazard de 0 à 20
		haz=int(double(rand())/RAND_MAX*21);
		if (dm[haz].joueur==0)
		{
			dm[haz].joueur=pl.enjeu;
			pl.nbr_piece[pl.enjeu-1]++;
			ok=true;
		}
	}
	return haz;
}

// Cette fonction calcule le score de chaque joueur en faisant la
// somme les chiffres figurant sur les domino qu'il lui reste

int calcule_score(int pl,set_domino dm)
{
	int i;
	int score=0;
	for(i=0;i<21;i++)
	{
		if(dm[i].joueur==pl)
		{
			score+=dm[i].a+dm[i].b;
		}
	}
	return score;
}


int main ()
{
	int score1,score2;
	plateau grille;
	int game_over=0;
	int wpiece=0;
	int newpiece;
	// nombre de pièce restant dans la pile
	int nbr_piece=21-6-1;
	joueur player={1,{6,6}};
	set_domino piece;
	extrem extremite={0,0,0,0,0,0};
	// diverse initialisations
	srand(time(0));
	// met le plateau à 0
	init_plateau(grille);
	// crée les 21 dominos
	init_domino(piece);
	// distribue 6 dominos au hazard
	distrib_domino(piece);
	// en met un au centre.
	premier_domino(grille,piece,extremite);
	// tant que le jeu continue
	while (game_over<2)
	{
		wpiece=0;
		// affiche le plateau et les dominos de chaque joueur
		affiche_plateau(grille);
		affiche_domino(piece);
		//ici on verifie si il y a une piece possible.
		if(verifie_possible(player,piece,extremite))
		{
			// demande la piece que le joueur veut jouer
			wpiece=demande_piece(player,grille,piece,extremite);
			// demande l'emplacement où le joueur veut jouer cette pièce
			demande_pos(player,grille,piece,extremite,wpiece);
			// teste s'il ne reste plus de pièces dans la
			// main du joueur actuel
			if(player.nbr_piece[player.enjeu-1]==0)
			{
				game_over=2;
			}
			else
			{
				// si oui , remet à 0 le conteur
				// Rappel :si le joueur passe son tour , cette boucle
				// n'est pas executée
				game_over=0;
			}
		}
		else
		{
			cout << "Sorry , you haven't playable domino.";
			// s'il reste des pièce dans la pile
			if (nbr_piece!=0)
			{
				// en tire une nouvelle
				newpiece=tire_une_piece(player,piece);
				nbr_piece--;
				cout << endl << "Your new domino : " ;
				cout << piece[newpiece].a << " " << piece[newpiece].b;
			}
			else
			{
				// sinon ajouter 1 a game_over (2=fin du jeu)
				game_over++;
				cout << endl << "The pile is empty";
			}
			cout << "..." << "Press enter.";
			cin.peek();
			cin.ignore();
			cout << endl;
		}
		//change de joueur
		player.enjeu=(player.enjeu % 2) + 1;
		
	}
	// calule les scores
	score1=calcule_score(1,piece);
	score2=calcule_score(2,piece);
	// détermine le joueur gagnant.
	if(score1-score2>0)
	{
		cout << "The player 2 wins.";
	}
	else
	{
		if(score1-score2<0)
		{
			cout << "The player 1 wins.";
		}
		else
		{
			cout << "Draw. No loser.";
		}
	}
	cout << endl << endl;
	cout << "Domino Christophe Mortier 1998" << endl;
	return 0;
}