[C] CASSE-TETE : PUZZLE

/* Auteur : A.souini */

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#include <math.h>

#define tchar sizeof(char)

/* une structure pour sauvegarder la table et la dimension */
typedef struct donnee_jeu
{
	int l,c; /* L:ligne    C:colonne*/
	char *table; /* pointeur vers la table , j'ai choisie char parceque le max de la dim c'est 10*10 donc 99 et le nombre maximum a sauvgardé */
} donnee_j;


char *creer_table(int,int,char **); /* creer la table et la mix puis retourne un pointeur vers cette derniere */
int afficher_menu(void); /* affiche le menu et retourn le choix ou quite le programme */
char **mouv_possible(int,int); /* genere une table ou est stoké les mouvement possible pour chaque case */
void partie(char *,int,int); /* c'est la fonction qui gere le jeu  */
void afficher_table(char *,int,int); /* affiche la table */
donnee_j chargement(void); /* charge la table et la dimension a partir d'un fichier de sauvgarde */
void sauvegarder(char *,int,int); /* sauvgarde la table courrante  */
int en_ordre(char *,int,int); /* retourne 1 si la table et en ordre 0 -> l*c-1 , sinon un 0 */

int afficher_menu(void) /*terminé*/
{
	int choix_menu;
	do
	{
#ifdef _WIN32
system("cls");
#elif defined(_UNIX)
system("clear");
#else
#error "Système d'exploitation non pris en charge, l'écran ne sera pas effacé."
#endif
 /* efface l'ecran */

		/* un ptit art ascii :p */
		printf("ppppp   u    u    zzzzzz    zzzzzz     L        eeeeeee\n");
		printf("p   p   u    u         z         z     L        e\n");
		printf("ppppp   u    u        z         z      L        eeeeeee\n");
		printf("p       u    u       z         z       L        e\n");
		printf("p       uuuuuu     zzzzzz    zzzzzz    LLLLLL   eeeeeee\n\n\n\n");

		printf("\t\t\tFaite un choix :\n\n\t\t\t\t");
		printf("1 - Nouvelle partie.\n\t\t\t\t2 - Charger une partie.\n\t\t\t\t3 - Quiter.\n\n");
		printf("\t\t\t---> ");
		scanf("%d",&choix_menu);
	} while ((choix_menu < 1) || (choix_menu > 3)); /* seul 1 ,2  et 3 sont possible */

	if (choix_menu == 3) exit(0);  /* quite si le choix et 3 */
	return choix_menu;
}



char **mouv_possible(int l,int c) /*terminé*/
{
	char **ptr_ptr=malloc(l*c*sizeof(char *)+1);
	/* on alloue un tableau de poiteurs vers char de la taille de la dimension L*C + 1 , le 1 c'est pour un
	tableau ou on metra le nombre de possiblitité pour chaque case */
	int i,j,k=l*c;

	ptr_ptr[k]=malloc(l*c*tchar); /* on creer le tableau qui contiendera le nombre de possibilité pour chaque case  */

	/*****************************shema de la table**********************************

	voila ce que j'ai trouvé quand j'ai analysé le probleme et depuis cette analyse j'ai creer
	cette fonction qui est comme la colonne vertebrale du jeu , vu que c'est la ou les possiblité
	de mouvement (les regles) sont calculé

	-----------------------------------------------------------------------
	| A11 | A12  | A13 ....                          .... | A1(c-1) | A1c  |
	| A21 | A22  | A23 ....                         ....  | A2(c-1) | A2c  |
	.                                                           .
	.														    .
	.														    .

	|A(l-1)1|A(l-1)2|A(l-1)3 ....             ....  | A(l-1)(c-1) | A(l-1)c |
	| Al1   | Al2   | Al3     ....                    ....  | Al(c-1) | Alc |
	------------------------------------------------------------------------

	 - pour A11,A1c,Al1,Alc  il ya deu possiblité de mouvement chaqune
		A11 : +1,+C
		A1c : -1,+C
		Al1 : +1,-C
		Alc : -1,-C

	 - pour les case de A12 a A1(c-1) , Al2 a Al(c-1) , A21 a A(l-1)1 et A2c a A(l-1)c on aura 3 possiblité
		A12 a A1(c-1) : -1,+1,+C
		Al2 a Al(c-1)   : -1,+1,-C
		A21 a A(l-1)1   : +1,-C,+C
		A2c a A(l-1)c  : -1,-C,+C

	 - pour tout le reste , donc la matrice du milieu on aura 4 possiblité de mouvement
		+1,-1,-C,+C


	**************************************************************************/

	/*   ptr_ptr[X]  : poiteur vers les possiblité de la case X
	     ptr_ptr[X][Y]  : la possibilité Y de la case X
	*/

	// les possibilité avec un cardinale 2 - les quatres coins

	/* on alloue l'espace requit pour contenir les deu possiblité pour les 4 case */
	ptr_ptr[0]=malloc(2*tchar);
	ptr_ptr[c-1]=malloc(2*tchar);
	ptr_ptr[(l-1)*c]=malloc(2*tchar);
	ptr_ptr[(l*c)-1]=malloc(2*tchar);

	/* on calcul les possibilité des 4 case */
	for (i=0;i<2;i++)
		{
			ptr_ptr[0][i]=(char) (0 + (i? 1:c));  /* +1,+C */
			ptr_ptr[k][0]=2; /* la case 0 a  2 possiblité de mouvement */
			ptr_ptr[c-1][i]=(char) ((c-1) + (i? (-1):c));  /* -1,+C */
			ptr_ptr[k][c-1]=2; /* la case c-1 a 2 possiblité ..*/
			ptr_ptr[(l-1)*c][i]=(char) ((l-1)*c + (i? 1:(-c))); /* +1,-C */
			ptr_ptr[k][(l-1)*c]=2;
			ptr_ptr[(l*c)-1][i]=(char) ((l*c)-1 + (i? (-1):(-c))); /* -1,-C */
			ptr_ptr[k][(l*c)-1]=2;
		}

    // les posibilités avec un cardinale 3 - les barres des cotés sans les coins
	for (i=1;i<(c-1);i++) /* coté haut --> A12 a A1(c-1)  */
		{
			ptr_ptr[i]=malloc(3*tchar); /* on alloue troi case */
			ptr_ptr[k][i]=3; /* la case i a 3 possiblité de mouvement */
			for (j=0;j<3;j++)
				ptr_ptr[i][j]= (char) (i + (((int)pow((-1),j)) * ((j==2)? c:1))); /* on rempli les possiblité  -1,+1,+C */
		}

	for (i=1+l*(c-1);i<l*c-1;i++) /* coté bas --> Al2 a Al(c-1)  */
		{
			ptr_ptr[i]=malloc(3*tchar);
			ptr_ptr[k][i]=3;
			for (j=0;j<3;j++)
				ptr_ptr[i][j]=(char) (i + (((int)pow((-1),j)) * ((j==2)? (-c):1))); /* -1,+1,-C  */
		}

	for (i=1;i<(l-1);i++) /* coté gauche --> A21 a A(l-1)1  */
		{
			ptr_ptr[i*l]=malloc(3*tchar);
			ptr_ptr[k][i*l]=3;
			for (j=0;j<3;j++)
				ptr_ptr[i*l][j]=(char) ((i*l)+ (((int)pow((-1),j)) * ((j==2)? 1:c))); /*  +1,-C,+C */
		}

	for (i=1;i<(l-1);i++) /* coté droite --> A2c a A(l-1)c  */
		{
			ptr_ptr[(c*(i+1))-1]=malloc(3*tchar);
			ptr_ptr[k][(c*(i+1))-1]=3;
			for (j=0;j<3;j++)
				ptr_ptr[(c*(i+1))-1][j]=(char) (((c*(i+1))-1)+ (((int)pow((-1),j)) * ((j==2)? (-1):(c)))); /* -1,-C,+C */
		}

	//les possibilité avec un cardinale eguale a 4 - la matrice du milieu sans les barre de coté et de haut

   	for (i=(c+1);i<((c*(l-1))-1);(!(i % c)||!((i+1) % c))? i+=2:i++)
		{
			ptr_ptr[i]=malloc(4*tchar);
			ptr_ptr[k][i]=4;
			for (j=0;j<4;j++)
				ptr_ptr[i][j]=(char) (i+ ((int)pow((-1),j)) * ((j>1)? c:1)); /* +1,-1,-C,+C */
		}

	return ptr_ptr; /* on retourne le pointeur vers les poiteur de mouvement possible */
}



char *creer_table(int l,int c,char **mouv_poss) /* terminé */
{
	int i,k,j;
	char *ptr=malloc(l*c*tchar+1); /* j'alloue L*C+1 case , la case de plus c'est pour contenir l'indice du zero (la marke XX aka la case vide) */

	for(i=0;i<l*c;ptr[i]=i++); /* je rempli la table de 0 a (L*C)-1 */
    ptr[l*c]=0; /* c'est la case d'indice 0 qui contient le 0 */

	srand(time(NULL)); /* on initialise le seed par l'heur courrante */
	for(j=0,i=ptr[l*c];j<l*c*10;j++)  /* l'ordinateur vas joué 10 foi la taille de la table comme ca elle sera bien mixé et y'aura au moin une solution :D */
		{
			k=(rand() % mouv_poss[l*c][i]); /* k contient un nombre entre dans l'intervale [0,mouv_poss[l*c][i]] */
			ptr[i]=ptr[mouv_poss[i][k]];/* on efectue l'echange */
			ptr[mouv_poss[i][k]]=0; /* .. */
			ptr[l*c]=mouv_poss[i][k]; /* ..*/
			i=ptr[l*c]; /* i contient la nouvelle position du zero */

		}

	return ptr; /* on retourne le poiteur de la table cree et mixé */
}



void affiche_table(char *ptr,int l,int c) /* terminé*/
{
	int i,j;
	char temp[4]="XX"; /* texte a afficher dans la case vide */
#ifdef _WIN32
system("cls");
#elif defined(_UNIX)
system("clear");
#else
#error "Système d'exploitation non pris en charge, l'écran ne sera pas effacé."
#endif
 /* effacer l'ecran */
	for (i=0;i<l;i++)
		{
			for (j=0;j<c;j++)
				if (i*c+j!=ptr[l*c]) /*si c'est pas la position du zero alor affichier le nombre */
					printf("%6d",ptr[i*c+j]);
				else
					printf("%6s",temp); /* sinon afichier le XX */
			printf("\n");
		}
}



void partie(char *table,int l,int c) /*terminé*/
{
	int choix,temp,temp1,i;
	char **mouv_poss;

	mouv_poss=mouv_possible(l,c);

	if (!table) /* si c'est pas un chargement de sauvgarde , on creer une table */
		{
			table = creer_table(l,c,mouv_poss);
		}

	do {
		affiche_table(table,l,c);
		printf("\n\n - (-1) : menu .\n - (-2) : Sauvgarder .\n - le nombre a deplacer .\n");
		do {
			printf("----> ");
			scanf("%d",&choix);/*je voulé prendre des char et puis testé mais j'ai eu kelke probleme
								donc j'ai abondoné et c'est avec un -1 et un -2 que j'ai continué */
		} while  ((choix >((l*c) - 1)) || ((choix < 1) && (choix != -2) && (choix != -1)));

		switch (choix)
		{
			case (-1): /* menu */
				temp=3;
				do {
				printf(" - Voulez-vous sauvegarder ? (1:oui 0:non) --> ");
				scanf("%d",&temp);
				}while ((temp!=1) && (temp!=0));
				if (temp) sauvegarder(table,l,c);
				free(table); /* un seul free :p les autre vienderon plus tard pas le temps ^^*/
				choix=0;
				break;
			case (-2): /* sauvegarder */
				sauvegarder(table,l,c);
				break;
			default : /* faire le mouvement si c'est possible */
				temp=mouv_poss[l*c][table[l*c]];
				for (i=0;i<l*c;i++)
					if (choix==table[i]) break; /* cherche l'indice de l'element choisi par l'utilisateur */
				temp1=i;
				for (i=0;i<temp;i++)
					if (temp1==mouv_poss[table[l*c]][i]) break; /* cherche l'indice de l'element dans la liste des element
																possible de la case du 0 */
				if (i>=temp) /*si indice non trouvé donc pas possible de faire le mouvement */
					{
						printf("Err : Mouvement impossible !!");
						getch();
					}
				else /* sinon on swap les valeurs */
					{
						table[table[l*c]]=table[temp1];
						table[l*c]=temp1;
						table[temp1]=0;
					}
				break;
		}

	if (!choix) break; /* si on choisi menu on quite vers le menu  */

	}  while (!en_ordre(table,l,c)); /* boule tand que c'est pas en ordre ( casse tete non resolue ) */

	if (choix) /* si choi est differante de zero et qu'on a quité la boucle c'est que c'est en ordre */
	   {
#ifdef _WIN32
system("cls");
#elif defined(_UNIX)
system("clear");
#else
#error "Système d'exploitation non pris en charge, l'écran ne sera pas effacé."
#endif

		  printf("Vous Avez Gagner :D felicitation !"); /* je v bientot ajouté une fonction qui creer un high score liste dans un fichier crypté
														ou le gagnan aura son nom et le nombre de mouvement avec les quelle il a resolut le casse
														tete de dimention LxL  */
		  getch();
		}


}



donnee_j chargement(void) /* terminé*/
{
	FILE *fichier;
	char nom_f[30],test[4],*ptr;
	donnee_j temp; /*le structure que retournera la fonction*/
	int i;


#ifdef _WIN32
system("cls");
#elif defined(_UNIX)
system("clear");
#else
#error "Système d'exploitation non pris en charge, l'écran ne sera pas effacé."
#endif

	printf(" - donner le nom du fichier de sauvegarde ( sans l'extention .DAT) : \n---> ");
	scanf("%s",nom_f);
	strcat(nom_f,".dat");

	if (fichier=fopen(nom_f,"r"))
		{
			fscanf(fichier,"%s ",test); /*teste si le fichier commence par la chaine PZL*/
			if (!strcmp("PZL",test)) /* si oui alor il comment l'extraction des donnee */
				{
					fscanf(fichier,"%d %d ",&temp.l,&temp.c);
					temp.table=malloc((temp.l*temp.c*tchar)+1);
					fread(temp.table,tchar,(temp.l*temp.c)+1,fichier);
					fclose(fichier);
					return temp;
				}
			else
				{
					temp.table=NULL; /* c'est pour le test de la fonction main */
					printf("ERR : ce fichier n\'est pas un fichier de sauvegarde PUZZLE !!");
					getch();
				}
		}
	else
		{
			temp.table=NULL;
			printf("ERR : erreur lors de l\'ouverture du fichier sauvegarde !!");
			getch();
		}

	return temp;
}

void sauvegarder(char *table,int l,int c) /* terminé*/
{
	FILE *fichier;
	char nom_f[30];

#ifdef _WIN32
system("cls");
#elif defined(_UNIX)
system("clear");
#else
#error "Système d'exploitation non pris en charge, l'écran ne sera pas effacé."
#endif

	printf(" - donner le nom du fichier ou vas etre sauvegarde la partie ( sans l\'extention .dat )\n---> ");
	scanf("%s",nom_f);
	strcat(nom_f,".dat");

	if (fichier=fopen(nom_f,"w"))
		{
			fprintf(fichier,"%s %d %d ","PZL",l,c);
			fwrite(table,tchar,(l*c)+1,fichier);
			fclose(fichier);
		}
	else
		{
			printf("ERR : erreur lors de la creation de la sauvegarde !!");
			getch();
		}
}

int en_ordre(char *table,int l,int c) /*terminé*/
{
	int i;
	for (i=0;i<l*c;i++)
		if (table[i]!=i) return 0;

	return 1;
}


int main(void)
{
	int l,c;
	donnee_j dcharge;

	while (1) {
		if (!(afficher_menu()-1))
			{
				do {
#ifdef _WIN32
system("cls");
#elif defined(_UNIX)
system("clear");
#else
#error "Système d'exploitation non pris en charge, l'écran ne sera pas effacé."
#endif

					printf(" - Donner la dimension du puZZle  L [ 1<L<12 ] : ");
					scanf("%d",&l); /* c'est sensé travailé avec n'importe kel dimension LxC mais vu que ca beug :/
									j'ai pri alor que des matrice Carré inferieure a 12 parceque sinon ca plante et je suis pas
									sur de la raison */
				} while ( l<2 || l>11 );

				partie(NULL,l,l);
			}
		else
			{
				dcharge = chargement();
				if (dcharge.table)
				  partie(dcharge.table,dcharge.l,dcharge.c);
			}

	}

	return 0;
}