void HandlerDroit(int)
{
S_RAQUETTE* raquetteTraitee;
int parc;
raquetteTraitee = (S_RAQUETTE*)pthread_getspecific(CleRaquette);
pthread_mutex_lock(&mutexTableau);
if(tab[raquetteTraitee->L][raquetteTraitee->C+3] == VIDE)
{
raquetteTraitee->C++;
if(raquetteTraitee->L == 1)
DessineRaquetteHaut(raquetteTraitee->L, raquetteTraitee->C);
else
DessineRaquetteBas(raquetteTraitee->L, raquetteTraitee->C);
for(parc = (raquetteTraitee->C)-2; parc != (raquetteTraitee->C)+3; parc++)
tab[raquetteTraitee->L][parc] = RAQUETTE;
EffaceCarre(raquetteTraitee->L, raquetteTraitee->C-3);
tab[raquetteTraitee->L][raquetteTraitee->C-3] = VIDE;
}
pthread_mutex_unlock(&mutexTableau);
}
void HandlerHaut(int)
{
S_RAQUETTE* raquetteTraitee;
int parc;
raquetteTraitee = (S_RAQUETTE*)pthread_getspecific(CleRaquette);
pthread_mutex_lock(&mutexTableau);
if(tab[raquetteTraitee->L-3][raquetteTraitee->C] == VIDE)
{
raquetteTraitee->L--;
if(raquetteTraitee->C == 1)
DessineRaquetteGauche(raquetteTraitee->L, raquetteTraitee->C);
else
DessineRaquetteDroite(raquetteTraitee->L, raquetteTraitee->C);
for(parc = (raquetteTraitee->L)-2; parc != (raquetteTraitee->L)+3; parc++)
tab[parc][raquetteTraitee->C] = RAQUETTE;
EffaceCarre(raquetteTraitee->L+3, raquetteTraitee->C);
tab[raquetteTraitee->L+3][raquetteTraitee->C] = VIDE;
}
pthread_mutex_unlock(&mutexTableau);
}
//Les raquetes vont passer dedans pour bouger dans la direction voulue
void HandlerGauche(int)
{
S_RAQUETTE* raquetteTraitee;
int parc;
raquetteTraitee = (S_RAQUETTE*)pthread_getspecific(CleRaquette);//On recupere la structure de la raquette qui passe ici
pthread_mutex_lock(&mutexTableau);//lock le tableau pour la modif
if(tab[raquetteTraitee->L][raquetteTraitee->C-3] == VIDE)//Si c'est vide a gauche (pas de mur ou de bille) on peut bouger
{
raquetteTraitee->C--;
if(raquetteTraitee->L == 1)//si en haut
DessineRaquetteHaut(raquetteTraitee->L, raquetteTraitee->C);
else//Si en bas
DessineRaquetteBas(raquetteTraitee->L, raquetteTraitee->C);
for(parc = (raquetteTraitee->C)-2; parc != (raquetteTraitee->C)+3; parc++) // On boucle pour ecrire l'emplacement des raquettes dans le tableau
tab[raquetteTraitee->L][parc] = RAQUETTE;
EffaceCarre(raquetteTraitee->L, raquetteTraitee->C+3); //On efface l'ancienne raquette
tab[raquetteTraitee->L][raquetteTraitee->C+3] = VIDE;
}
pthread_mutex_unlock(&mutexTableau);
}
void* threadEvent(void*)
{
char ok = 0;
EVENT_GRILLE_SDL event;
while(!ok)
{
event = ReadEvent();
if (event.type == CROIX) ok = 1;
if (event.type == CLIC_GAUCHE && event.colonne<10 && tab[event.ligne][event.colonne]==0)
{
DessineSprite(event.ligne,event.colonne,pieceEnCours.professeur);
tab[event.ligne][event.colonne]=pieceEnCours.professeur;
casesInserees[nbCasesInserees].ligne=event.ligne;
casesInserees[nbCasesInserees].colonne=event.colonne;
pthread_mutex_lock(&mutexCasesInserees);
nbCasesInserees++;
pthread_mutex_unlock(&mutexCasesInserees);
pthread_cond_signal(&condCasesInserees);
}
if (event.type == CLIC_DROIT && nbCasesInserees>0)
{
pthread_mutex_lock(&mutexCasesInserees);
nbCasesInserees--;
pthread_mutex_unlock(&mutexCasesInserees);
while(nbCasesInserees!=-1)
{
EffaceCarre(casesInserees[nbCasesInserees].ligne,casesInserees[nbCasesInserees].colonne);
tab[casesInserees[nbCasesInserees].ligne][casesInserees[nbCasesInserees].colonne]=0;
pthread_mutex_lock(&mutexCasesInserees);
nbCasesInserees--;
pthread_mutex_unlock(&mutexCasesInserees);
}
pthread_mutex_lock(&mutexCasesInserees);
nbCasesInserees=0;
pthread_mutex_unlock(&mutexCasesInserees);
}
}
}
/******************************************THREAD BILLE*************************************************
*Controle une bille à l'ecran. Se charge d'afficher la bille dans l'interface, de déplacer celle-ci et
*d'effacer l'image de la bille sur la case qu'elle quitte.
*
********************************************************************************************************/
void* threadBille(void* p)
{
S_BILLE MaBille;
timespec_t tempsNano;
int l, c, ok = 0, inZone = 0;
sigset_t masque, demasque;
memcpy(&MaBille, p,sizeof(S_BILLE)); // On copie la structure reçue
pthread_mutex_unlock(&mutexLanceBille);// On lache le mutex pour que le thread lanceur puisse reutiliser sa structure
pthread_setspecific(CleBille, (void*)&MaBille);//On met un pointeur vers la structure bille en variable spécifique
//Masque qui accepte le SIGTRAP
sigfillset(&demasque);
sigdelset(&demasque, SIGTRAP);
//Masque qui refuse tous les signaux
sigfillset(&masque);
pthread_mutex_lock(&mutexTableau); //Tableau bloqué pour pouvoir choisir l'endroit ou apparaitre et se dessiner.
do
{
l = rand()%11+4;
if(l > 5 && l < 13)
{
c = rand()%4+4;
if(c > 5)
c+=7;
}
else
c = rand()%11+4;
if(tab[l][c] == VIDE)
{
tab[l][c] = BILLE;
ok = 1;
}
}while(!ok);
MaBille.L = l;
MaBille.C = c;
DessineBille(GRISE, l, c); // On dessine et on met dans le tableau
tab[l][c] = BILLE;
pthread_mutex_unlock(&mutexTableau);
tempsNano.tv_sec = 0;
tempsNano.tv_nsec = 500000000L;
nanosleep(&tempsNano, NULL); //La bille reste grise 0,5 sec
DessineBille(MaBille.couleur, MaBille.L, MaBille.C); //puis on la color
tempsNano.tv_sec = 0;
tempsNano.tv_nsec = 350000000L; //init du temps d'attente de la bille
while(c > 0 && c < 18 && l > 0 && l < 18) // tant qu'on ne sort pas du tableau
{
nanosleep(&tempsNano, NULL); //attente de 0,35 sec
pthread_sigmask(SIG_SETMASK, &masque, NULL); // On masque SIGTRAP pour pas être bloqué alors qu'on tient le mutex
pthread_mutex_lock(&mutexTableau); // et on prend le mutex
if(MaBille.dir == GAUCHE) // Si ma bille va à gauche
{
if(tab[l][c-1] == VIDE) // On vérifie qu'on se deplace sur une cse libre
{
if((ZoneMagnetique(l, c-1)) == 1 && inZone == 0) //On verifie si on va rentrer dans la zone magnetique (et si on y est pas deja)
{
attenteZone(l, c-1); // On va se mettre sur la variable de condition et rester bloquer si on ne peut pas rentrer
inZone = 1;// On est autorisé à rentrer dans la zone et on met une sorte de bool à 1 pour indiquer qu'on est dedans.
}
else if (inZone == 1 && (ZoneMagnetique(l, c-1)) == 0) // Si on est deja dans la zone et qu'on en sort
{
pthread_cond_signal(&condZoneMagnetique);// On envoit un signal pour debloquer une bille en attente
inZone = 0; // Et on est plus dans la zone
}
tab[l][c] = VIDE; //On met l'ancienne case à vide
EffaceCarre(l,c); //On efface le dessin dela bille sur l'ancienne case
c -= 1;
DessineBille(MaBille.couleur, l, c); // On dessine sur la nouvelle case
tab[l][c] = BILLE; // la nouvelle case contient une bille
}
else // La case sur laquelle on va aller est pleine
{
MaBille.dir = DROITE; // on change de direction
}
}
else if(MaBille.dir == DROITE)
{
if(tab[l][c+1] == VIDE)
{
if((ZoneMagnetique(l, c+1)) == 1 && inZone == 0)
{
attenteZone(l, c+1);
inZone = 1;
}
else if (inZone == 1 && (ZoneMagnetique(l, c+1)) == 0)
{
pthread_cond_signal(&condZoneMagnetique);
inZone = 0;
}
tab[l][c] = VIDE;
EffaceCarre(l,c);
c += 1;
DessineBille(MaBille.couleur, l, c);
tab[l][c] = BILLE;
}
else
{
MaBille.dir = GAUCHE;
}
}
else if(MaBille.dir == HAUT)
{
if(tab[l+1][c] == VIDE)
{
if((ZoneMagnetique(l+1, c)) == 1 && inZone == 0)
{
attenteZone(l+1, c);
inZone = 1;
}
else if (inZone == 1 && (ZoneMagnetique(l+1, c)) == 0)
{
pthread_cond_signal(&condZoneMagnetique);
inZone = 0;
}
tab[l][c] = VIDE;
EffaceCarre(l,c);
l += 1;
DessineBille(MaBille.couleur, l, c);
tab[l][c] = BILLE;
}
else
{
MaBille.dir = BAS;
}
}
else //BAS
{
if(tab[l-1][c] == VIDE)
{
if((ZoneMagnetique(l-1, c)) == 1 && inZone == 0)
{
attenteZone(l-1, c);
inZone = 1;
}
else if (inZone == 1 && (ZoneMagnetique(l-1, c)) == 0)
{
pthread_cond_signal(&condZoneMagnetique);
inZone = 0;
}
tab[l][c] = VIDE;
EffaceCarre(l,c);
l -= 1;
DessineBille(MaBille.couleur, l, c);
tab[l][c] = BILLE;
}
else
{
MaBille.dir = HAUT;
}
}
pthread_mutex_unlock(&mutexTableau); // On lache la mutex
MaBille.C = c;
MaBille.L = l;
pthread_sigmask(SIG_SETMASK, &demasque, NULL); //On accepte le signal SIGTRAP
}
/******LA BILLE SORT DU TERRAIN***************************/
nanosleep(&tempsNano, NULL); // derniere attente avant de sortir du tableau
pthread_mutex_lock(&mutexBillesSorties);// On prend la mutex bille sortie
//On met dans le vecteur globale des billes sorties notre structure
billesSorties[indiceI].couleur = MaBille.couleur;
billesSorties[indiceI].L = MaBille.L;
billesSorties[indiceI].C = MaBille.C;
billesSorties[indiceI].dir = MaBille.dir;
indiceI++;
if(indiceI >= 10)
indiceI = 0;
pthread_cond_signal(&condSortie); //On reveil le ramsaseur
pthread_mutex_unlock(&mutexBillesSorties);
delBille(MaBille.couleur, MaBille.dir);// MAJ des infos sur les billes
EffaceCarre(l,c); // On efface le carré sur laquelle la bille est morte :(
tab[l][c] = VIDE;
pthread_setspecific(CleBille, NULL); // Pointeur de la variable specific == NULL;
pthread_exit(0);
}
void* threadGravite(void*)
{
int i,j,tmp;
struct timespec temps;
temps.tv_sec=0;
temps.tv_nsec=500000000;
while(1)
{
pthread_mutex_lock(&mutexAnalyse);
while(nbAnalyses<pieceEnCours.nbCases)
pthread_cond_wait(&condAnalyse,&mutexAnalyse);
printf("%d%d\n",nbLignesCompletes,nbColonnesCompletes);
if(nbLignesCompletes == 0 && nbColonnesCompletes == 0)
{
nbAnalyses=0;
}
else
{
printf("ICICICICI\n");
TriTableau(colonnesCompletes,nbColonnesCompletes);
TriTableau(lignesCompletes,nbLignesCompletes);
printf("OKOKOKOK\n");
printf("colonnes:\n");
for(i=0;i<nbColonnesCompletes;i++)
{printf("c: %d\n",colonnesCompletes[i]);}
printf("Lignes:\n");
for(i=0;i<nbLignesCompletes;i++)
{printf("l: %d\n",lignesCompletes[i]);}
for(i=0;i<nbColonnesCompletes && colonnesCompletes[i]<5;i++)//Recule colonne <5
{
nanosleep(&temps,NULL);
tmp=colonnesCompletes[i];
while(tmp!=0)
{
for(j=0;j<14;j++)
{
tab[j][tmp]=tab[j][tmp-1];
if(tab[j][tmp]==0)
{
EffaceCarre(j,tmp);
}
else
{
DessineSprite(j,tmp,BRIQUE);
}
}
tmp--;
}
for(j=0;j<14;j++)
{
EffaceCarre(j,0);
tab[j][0]=0;
}
//AJOUT 5 POINTS
pthread_mutex_unlock(&mutexScore);
score+=5;
MAJScore++;
pthread_mutex_unlock(&mutexScore);
pthread_cond_signal(&condScore);
}
for(i=nbColonnesCompletes-1;i!=-1 && colonnesCompletes[i]>=5;i--) //Recule Colonne >=5
{
nanosleep(&temps,NULL);
tmp=colonnesCompletes[i];
while(tmp!=10)
{
for(j=0;j<14;j++)
{
tab[j][tmp]=tab[j][tmp+1];
if(tab[j][tmp]==0)
{
EffaceCarre(j,tmp);
}
else
{
DessineSprite(j,tmp,BRIQUE);
}
}
tmp++;
}
for(j=0;j<14;j++)
{
EffaceCarre(j,9);
tab[j][9]=0;
}
//AJOUT 5 POINTS
pthread_mutex_unlock(&mutexScore);
score+=5;
MAJScore++;
pthread_mutex_unlock(&mutexScore);
pthread_cond_signal(&condScore);
}
for(i=0;i<nbLignesCompletes && lignesCompletes[i]<7;i++)//Recule Ligne<7
{
nanosleep(&temps,NULL);
tmp=lignesCompletes[i];
while(tmp!=0)
{
for(j=0;j<10;j++)
{
tab[tmp][j]=tab[tmp-1][j];
if(tab[tmp][j]==0)
{
EffaceCarre(tmp,j);
}
else
{
DessineSprite(tmp,j,BRIQUE);
}
}
tmp--;
}
for(j=0;j<10;j++)
{
EffaceCarre(0,j);
tab[0][j]=0;
}
//AJOUT 5 POINTS
pthread_mutex_unlock(&mutexScore);
score+=5;
MAJScore++;
pthread_mutex_unlock(&mutexScore);
pthread_cond_signal(&condScore);
}
for(i=nbLignesCompletes-1;i!=-1 && lignesCompletes[i]>=7;i--)//Recule Ligne>=7
{
nanosleep(&temps,NULL);
tmp=lignesCompletes[i];
while(tmp!=14)
{
for(j=0;j<10;j++)
{
tab[tmp][j]=tab[tmp+1][j];
if(tab[tmp][j]==0)
{
EffaceCarre(tmp,j);
}
else
{
DessineSprite(tmp,j,BRIQUE);
}
}
tmp++;
}
for(j=0;j<10;j++)
{
EffaceCarre(13,j);
tab[13][j]=0;
}
//AJOUT 5 POINTS
pthread_mutex_unlock(&mutexScore);
score+=5;
MAJScore++;
pthread_mutex_unlock(&mutexScore);
pthread_cond_signal(&condScore);
}
nbAnalyses=0;
nbColonnesCompletes=0;
nbLignesCompletes=0;
}
pthread_mutex_unlock(&mutexAnalyse);
//pthread_kill(threadHandleFinPartie,SIGUSR2);
}
}
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);
}
}
}
void * threadEvent(void *p)
{
int i;
char ok = 0;
EVENT_GRILLE_SDL event;
struct timespec bad_click_time;
bad_click_time.tv_sec = 0;
bad_click_time.tv_nsec = 250000000;
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
while(!ok)
{
event = ReadEvent();
switch(event.type)
{
case CROIX:
ok = 1;
break;
case CLIC_GAUCHE:
if (!traitementEnCours)
{
if (event.colonne < 10 && nbCasesInserees < 4)
{
if (tab[event.ligne][event.colonne] == VIDE)
{
DessineSprite(event.ligne, event.colonne, pieceEnCours.professeur);
pthread_mutex_lock(&mutexCasesInserees);
casesInserees[nbCasesInserees].ligne = event.ligne;
casesInserees[nbCasesInserees].colonne = event.colonne;
++nbCasesInserees;
pthread_mutex_unlock(&mutexCasesInserees);
pthread_cond_signal(&condCasesInserees);
tab[event.ligne][event.colonne] = pieceEnCours.professeur;
// printf("\ntab[%d][%d] = %d\n", event.ligne, event.colonne, tab[event.ligne][event.colonne]);
if (nbCasesInserees == 4)
{
pthread_mutex_lock(&mutexTraitement);
traitementEnCours = 1;
pthread_mutex_unlock(&mutexTraitement);
DessineSprite(12, 11, VOYANT_BLEU);
}
}
}
else
{
// Click hors de la zone de jeu (traitement = 0)
DessineSprite(12, 11, VOYANT_ROUGE);
nanosleep(&bad_click_time, NULL);
DessineSprite(12, 11, VOYANT_VERT);
}
}
else
{
// Si on clique pendant un traitement
DessineSprite(12, 11, VOYANT_ROUGE);
nanosleep(&bad_click_time, NULL);
DessineSprite(12, 11, VOYANT_BLEU);
}
break;
case CLIC_DROIT:
printf("Clic droit recu: nous allons effacer %d cases.\n", nbCasesInserees);
for (i = 0 ; i < nbCasesInserees ; ++i)
{
EffaceCarre(casesInserees[i].ligne, casesInserees[i].colonne);
tab[casesInserees[i].ligne][casesInserees[i].colonne] = VIDE;
}
pthread_mutex_lock(&mutexCasesInserees);
nbCasesInserees = 0;
pthread_mutex_unlock(&mutexCasesInserees);
case CLAVIER:
break;
}
}
// Quitter le jeu (réveil du Main)
pthread_cancel(threadHandleFinPartie);
}
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);
}
}
}
void * threadGravite(void *)
{
int i, j, x, y;
struct timespec observation, effet_graphique;
observation.tv_sec = 2;
observation.tv_nsec = 0;
effet_graphique.tv_sec = 0;
effet_graphique.tv_nsec = 500000000;
while (1)
{
// On attend que toutes les analyses soient effectuées
pthread_mutex_lock(&mutexAnalyse);
while (nbAnalyses < pieceEnCours.nbCases)
{
pthread_cond_wait(&condAnalyse, &mutexAnalyse);
}
pthread_mutex_unlock(&mutexAnalyse);
if (nbLignesCompletes == 0 && nbColonnesCompletes == 0)
{
printf("\n(GRAVITE) Rien d'intéressant dans ce move\n");
pthread_mutex_lock(&mutexAnalyse);
nbAnalyses = 0;
pthread_mutex_unlock(&mutexAnalyse);
}
else // Il fat supprimer des lignes/colonnes
{
printf("(GRAVITE) Gravité activée!\n");
printf("(GRAVITE) Suppression de %d lignes et %d colonnes:\n", nbLignesCompletes, nbColonnesCompletes);
nanosleep(&observation, NULL);
if (nbColonnesCompletes != 0)
{
// Tri des colonnes complètes afin de supprimer d'abbord les colonnes de gauche
pthread_mutex_lock(&mutexAnalyse);
qsort(colonnesCompletes, nbColonnesCompletes, sizeof(int), compare_ints);
pthread_mutex_unlock(&mutexAnalyse);
for (x = 0, y = 0 ; x < nbColonnesCompletes ; ++x) // Traitement pour chaque colonne complète
{
// Colonnes de gauche
if (colonnesCompletes[x] < 5)
{
// Décalage des éléments vers la droite
for (i = 0 ; i < NB_LIGNES ; ++i)
{
for (j = colonnesCompletes[x] ; j > 0 ; --j)
{
tab[i][j] = tab[i][j-1];
if (tab[i][j] == VIDE)
EffaceCarre(i, j);
else
DessineSprite(i, j, tab[i][j]);
}
tab[i][0] = VIDE;
EffaceCarre(i, 0);
}
++y; // Y comptera le nombre de fois que nous avons traité des colonnes de gauche
printf("Colonne %d supprimée.\n", colonnesCompletes[x]);
}
else // Colonnes de droite
{
// Décalage des éléments vers la gauche
for (i = 0 ; i < NB_LIGNES ; ++i)
{
for (j = colonnesCompletes[nbColonnesCompletes-1-x + y] ; j < 9 ; ++j)
{
tab[i][j] = tab[i][j+1];
if (tab[i][j] == VIDE)
EffaceCarre(i, j);
else
DessineSprite(i, j, tab[i][j]);
}
tab[i][9] = VIDE;
EffaceCarre(i, 9);
}
printf("Colonne %d supprimée.\n", colonnesCompletes[nbColonnesCompletes-1-x + y]);
}
nanosleep(&effet_graphique, NULL);
}
}
if (nbLignesCompletes != 0)
{
// Tri des lignes complètes afin de supprimer d'abbord les lignes du haut
pthread_mutex_lock(&mutexAnalyse);
qsort(lignesCompletes, nbLignesCompletes, sizeof(int), compare_ints);
pthread_mutex_unlock(&mutexAnalyse);
for (x = 0, y = 0 ; x < nbLignesCompletes ; ++x) // Traitement pour chaque ligne complète
{
// Lignes du haut
if (lignesCompletes[x] < 7)
{
// Décalage des éléments vers le bas
for (j = 0 ; j < 10 ; ++j)
{
for (i = lignesCompletes[x] ; i > 0 ; --i)
{
tab[i][j] = tab[i-1][j];
if (tab[i][j] == VIDE)
EffaceCarre(i, j);
else
DessineSprite(i, j, tab[i][j]);
}
tab[0][j] = VIDE;
EffaceCarre(0, j);
}
++y; // Y Comptera le nombre de fois que l'on a traité des lignes en haut
printf("Ligne %d supprimée.\n", lignesCompletes[x]);
}
else // Lignes du bas
{
// Décalage des éléments vers le haut
for (j = 0 ; j < 10 ; ++j)
{
for (i = lignesCompletes[nbLignesCompletes-1-x+y] ; i < NB_LIGNES-1 ; ++i)
{
tab[i][j] = tab[i+1][j];
if (tab[i][j] == VIDE)
EffaceCarre(i, j);
else
DessineSprite(i, j, tab[i][j]);
}
tab[NB_LIGNES-1][j] = VIDE;
EffaceCarre(NB_LIGNES-1, j);
}
printf("Ligne %d supprimée.\n", lignesCompletes[nbLignesCompletes-1-x+y]);
}
nanosleep(&effet_graphique, NULL);
}
}
// Ajout des points au score
pthread_mutex_lock(&mutexScore);
score += nbColonnesCompletes * COLONNE_COMPLETE;
score += nbLignesCompletes * LIGNE_COMPLETE;
MAJScore = 1;
pthread_mutex_unlock(&mutexScore);
pthread_cond_signal(&condScore);
pthread_mutex_lock(&mutexAnalyse);
nbColonnesCompletes = 0;
nbLignesCompletes = 0;
nbAnalyses = 0;
pthread_mutex_unlock(&mutexAnalyse);
}
// Dans tous les cas:
pthread_kill(threadHandleFinPartie, SIGUSR2);
}
}
