예제 #1
0
void* threadPiece(void*)
{
	int choixPiece,i,j,tour,Lmin,Cmin,trouve;
	srand(time(NULL));
	trouve=1;
	while(1)
	{
		if(trouve==1)
		{
			/****************************************************/
			memcpy(&pieceEnCours,&pieces[/*rand()%7*/6],sizeof(PIECE));
			tour=(rand()%4);
			tour=1;
			for(i=0;i<tour;i++)
			{
				RotationPiece(&pieceEnCours);	//Rotation de la piece entre 0 et 3 fois
			}
			for(i=3;i<=6;i++)
			{
				for(j=15;j<=18;j++)
				{
					EffaceCarre(i,j);
				}
			}
			for(i=0;i<NB_CASES;i++)	
			{
				DessineSprite(pieceEnCours.cases[i].ligne+3,pieceEnCours.cases[i].colonne+15,pieceEnCours.professeur);
			}
		}
		pthread_mutex_lock(&mutexCasesInserees);
		while(nbCasesInserees<pieceEnCours.nbCases)
			pthread_cond_wait(&condCasesInserees,&mutexCasesInserees);
		pthread_mutex_unlock(&mutexCasesInserees);
		//verification piece
		Lmin=15;Cmin=11;
		for(i=0;i<pieceEnCours.nbCases;i++)
		{
			if(casesInserees[i].ligne<Lmin)
				Lmin=casesInserees[i].ligne;
			if(casesInserees[i].colonne<Cmin)
				Cmin=casesInserees[i].colonne;
		}
		//comparer pieces
		trouve=1;
		for(j=0;j<pieceEnCours.nbCases && trouve !=0;j++)
		{
			trouve=0;
			for(i=0;i<pieceEnCours.nbCases && trouve!=1;i++)
			{
				if(casesInserees[j].ligne-Lmin==pieceEnCours.cases[i].ligne &&	casesInserees[j].colonne-Cmin==pieceEnCours.cases[i].colonne)
					trouve=1;
			}
		}
		if(trouve==1) //trouvé
		{
			for(i=0;i<pieceEnCours.nbCases;i++)
			{
				DessineSprite(casesInserees[i].ligne,casesInserees[i].colonne,BRIQUE);
				tab[casesInserees[i].ligne][casesInserees[i].colonne]=BRIQUE;
				pthread_kill(tabThreadCases[casesInserees[i].ligne][casesInserees[i].colonne],SIGUSR1);
			}
			pthread_mutex_lock(&mutexCasesInserees);
			nbCasesInserees=0;
			pthread_mutex_unlock(&mutexCasesInserees);
			pthread_mutex_lock(&mutexScore);
				score+=1;
				MAJScore=1;
			pthread_mutex_unlock(&mutexScore);
			pthread_cond_signal(&condScore);
		}
		else	//non trouvé
		{
			for(i=0;i<pieceEnCours.nbCases;i++)
			{
				EffaceCarre(casesInserees[i].ligne,casesInserees[i].colonne);
				tab[casesInserees[i].ligne][casesInserees[i].colonne]=0;
			}
			pthread_mutex_lock(&mutexCasesInserees);
			nbCasesInserees=0;
			pthread_mutex_unlock(&mutexCasesInserees);
		}
	}
}
예제 #2
0
void * threadPiece(void *p)
{
	int rot, i, j, col_min, ligne_min, pieceValidee;
	CASE casesVerif[NB_CASES];

	pthread_mutex_lock(&mutexPieceEnCours); // petit lock pour pouvoir unlock juste en dessous :D

	while (1)
	{
		pieceEnCours = pieces[rand() % 7];
		// pieceEnCours = pieces[0];
		rot = rand() % 4;
		
		for (i = 0 ; i < rot ; ++i)
			RotationPiece(&pieceEnCours);

		TranslationCases(pieceEnCours.cases, pieceEnCours.nbCases);

		// Tri sur ligne/colonne
		qsort(pieceEnCours.cases, pieceEnCours.nbCases , sizeof(CASE), compare_case);

		// On autorise le thread fin à vérifier si on peut insérer la nouvelle pièce
		pthread_mutex_unlock(&mutexPieceEnCours);

		// Effacement de la zone "pièce en cours"
		for (i = 0 ; i < 4 ; ++i)
		{
			for (j = 0 ; j < 4 ; ++j)
			{
				EffaceCarre(3 + i , 15 + j );
			}
		}

		// Affichage de la pièce en cours:
		for (i = 0 ; i < pieceEnCours.nbCases ; ++i)
		{
			DessineSprite(3 + pieceEnCours.cases[i].ligne, 15 + pieceEnCours.cases[i].colonne, pieceEnCours.professeur);
		}

		pieceValidee = 0;
		while (!pieceValidee)
		{
			// On attend que toutes les pièces soient insérées par le joueur
			pthread_mutex_lock(&mutexCasesInserees);
			while (nbCasesInserees < pieceEnCours.nbCases)
			{
				pthread_cond_wait(&condCasesInserees, &mutexCasesInserees);
			}
			pthread_mutex_unlock(&mutexCasesInserees);

			// Tri des cases insérées
			qsort(casesInserees, nbCasesInserees, sizeof(CASE), compare_case);

			// Vérification de la position des cases insérées par rapport à la pièce en cours
			memcpy(casesVerif, casesInserees, sizeof(CASE) * NB_CASES);
			TranslationCases(casesVerif, nbCasesInserees);

			pieceValidee = 1;
			for (i = 0 ; i < nbCasesInserees && pieceValidee == 1 ; ++i)
			{
				if (compare_case(&(pieceEnCours.cases[i]), &(casesVerif[i])) != 0)
					pieceValidee = 0;
			}

			if (pieceValidee)
			{
				for (i = 0 ; i < nbCasesInserees ; ++i)
				{
					tab[casesInserees[i].ligne][casesInserees[i].colonne] = BRIQUE;
					DessineSprite(casesInserees[i].ligne, casesInserees[i].colonne, BRIQUE);
				}

				// On réveille le threadScore et on incrémente le score
				pthread_mutex_lock(&mutexScore);
				++score;
				MAJScore = 1;
				pthread_mutex_unlock(&mutexScore);
				pthread_cond_signal(&condScore);

				// On empêche le thread Fin de lire la pièce avant que la nouvelle ne soit générée
				pthread_mutex_lock(&mutexPieceEnCours);

				// On réveille les 4 threads case
				for (i = 0 ; i < nbCasesInserees ; ++i)
				{
					pthread_kill(threadHandleCase[casesInserees[i].ligne][casesInserees[i].colonne], SIGUSR1);
				}
			}
			else
			{
				for (i = 0 ; i < nbCasesInserees ; ++i)
				{
					EffaceCarre(casesInserees[i].ligne, casesInserees[i].colonne);
					tab[casesInserees[i].ligne][casesInserees[i].colonne] = VIDE;
				}

				pthread_mutex_lock(&mutexTraitement);
				traitementEnCours = 0;
				pthread_mutex_unlock(&mutexTraitement);
				DessineSprite(12, 11, VOYANT_VERT);
			}
			pthread_mutex_lock(&mutexCasesInserees);
			nbCasesInserees = 0;
			pthread_mutex_unlock(&mutexCasesInserees);
		}
	}
}