void DessineChiffre(int chiffre,int l,int c)
{
switch(chiffre)
{
case 1 : DessineSprite(l,c,S_NUMERO_UN); break;
case 2 : DessineSprite(l,c,S_NUMERO_DEUX); break;
case 3 : DessineSprite(l,c,S_NUMERO_TROIS); break;
case 4 : DessineSprite(l,c,S_NUMERO_QUATRE); break;
default : break;
}
}
void DessineChiffre(int L,int C,int chiffre)
{
switch(chiffre)
{
case 0 : DessineSprite(L,C,CHIFFRE_0); break;
case 1 : DessineSprite(L,C,CHIFFRE_1); break;
case 2 : DessineSprite(L,C,CHIFFRE_2); break;
case 3 : DessineSprite(L,C,CHIFFRE_3); break;
case 4 : DessineSprite(L,C,CHIFFRE_4); break;
case 5 : DessineSprite(L,C,CHIFFRE_5); break;
case 6 : DessineSprite(L,C,CHIFFRE_6); break;
case 7 : DessineSprite(L,C,CHIFFRE_7); break;
case 8 : DessineSprite(L,C,CHIFFRE_8); break;
case 9 : DessineSprite(L,C,CHIFFRE_9); break;
default : break;
}
}
void sigUsr1Handler(int sig)
{
int i;
CASE *pcase;
pcase = (CASE*)pthread_getspecific(cle);
if (analyseLigne(pcase->ligne))
{
for (i = 0 ; i < 10 ; ++i)
{
DessineSprite(pcase->ligne, i, FUSION);
tab[pcase->ligne][i] = FUSION;
}
pthread_mutex_lock(&mutexAnalyse);
if (!recherche_int(pcase->ligne, lignesCompletes, nbLignesCompletes))
{
lignesCompletes[nbLignesCompletes] = pcase->ligne;
++nbLignesCompletes;
}
pthread_mutex_unlock(&mutexAnalyse);
}
if (analyseColonne(pcase->colonne))
{
for (i = 0 ; i < NB_LIGNES ; ++i)
{
DessineSprite(i, pcase->colonne, FUSION);
tab[i][pcase->colonne] = FUSION;
}
pthread_mutex_lock(&mutexAnalyse);
if (!recherche_int(pcase->colonne, colonnesCompletes, nbColonnesCompletes))
{
colonnesCompletes[nbColonnesCompletes] = pcase->colonne;
++nbColonnesCompletes;
}
pthread_mutex_unlock(&mutexAnalyse);
}
pthread_mutex_lock(&mutexAnalyse);
++nbAnalyses;
pthread_mutex_unlock(&mutexAnalyse);
pthread_cond_signal(&condAnalyse);
}
void * threadFinPartie(void *p)
{
int j, i, k, emplacement_possible;
struct sigaction sigact;
// Armement de SIGUSR2
sigact.sa_handler = sigUsr2Handler;
sigaction(SIGUSR2, &sigact, NULL);
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
sigaddset(&sigact.sa_mask, SIGUSR2);
pthread_sigmask(SIG_UNBLOCK, &sigact.sa_mask, NULL);
while (1)
{
pause(); // Attente de SIGUSR2
// Réception de SIGUSR2
printf("(FIN_PARTIE) J'ai recu SIGUSR2 et je me réveillle\n");
pthread_mutex_lock(&mutexPieceEnCours); // Afin d'attendre la si nouvelle pièce n'a pas encore été générée
for (i = 0, emplacement_possible = 0 ; i < NB_LIGNES && !emplacement_possible ; ++i)
{
for (j = 0 ; j < 10 && !emplacement_possible ; ++j)
{
for (k = 0, emplacement_possible = 1 ; k < pieceEnCours.nbCases && emplacement_possible ; k++)
{
if (i+pieceEnCours.cases[k].ligne > NB_LIGNES-1 || j+pieceEnCours.cases[k].colonne > 9)
emplacement_possible = 0;
else if (tab[i+pieceEnCours.cases[k].ligne][j+pieceEnCours.cases[k].colonne] != VIDE)
emplacement_possible = 0;
}
printf("(FIN_PARTIE) Emplacement possible = %d en (%d, %d)\n", emplacement_possible, i, j);
}
}
pthread_mutex_unlock(&mutexPieceEnCours);
if (!emplacement_possible)
{
printf("\n-------------------------------------------\n");
printf("Plus de place dans la grille...\nFin de la partie.\n");
printf("-------------------------------------------\n");
pthread_exit(NULL);
}
else
{
pthread_mutex_lock(&mutexTraitement);
traitementEnCours = 0;
pthread_mutex_unlock(&mutexTraitement);
DessineSprite(12, 11, VOYANT_VERT);
}
}
}
void DessineBille(int couleur,int l,int c)
{
switch(couleur)
{
case GRISE : DessineSprite(l,c,S_BILLE_GRISE); break;
case ROUGE : DessineSprite(l,c,S_BILLE_ROUGE); break;
case BLEUE : DessineSprite(l,c,S_BILLE_BLEUE); break;
case JAUNE : DessineSprite(l,c,S_BILLE_JAUNE); break;
case MAUVE : DessineSprite(l,c,S_BILLE_MAUVE); break;
case VERTE : DessineSprite(l,c,S_BILLE_VERTE); break;
case MAGENTA : DessineSprite(l,c,S_BILLE_MAGENTA); break;
default : DessineSprite(l,c,S_BILLE_GRISE); break;
}
}
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);
}
}
}
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* 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 terminerProgramme()
{
int i, j;
DessineSprite(12, 11, VOYANT_ROUGE);
printf("Suppression du threadEvent...\n");
if (pthread_cancel(threadHandleEvent) != 0)
printf("Erreur de pthread_cancel\n");
pthread_join(threadHandleEvent, NULL);
printf("Suppression des Threads cases...\n");
for (i = 0 ; i < NB_LIGNES ; ++i)
{
for (j = 0 ; j < 10 ; ++j)
{
pthread_cancel(threadHandleCase[i][j]);
}
}
for (i = 0 ; i < NB_LIGNES ; ++i)
{
for (j = 0 ; j < 10 ; ++j)
{
pthread_join(threadHandleCase[i][j], NULL);
}
}
printf("Supression du threadTopScore\n");
pthread_cancel(threadHandleTopScore);
pthread_join(threadHandleTopScore, NULL);
printf("Supression du threadScore\n");
pthread_cancel(threadHandleScore);
pthread_join(threadHandleScore, NULL);
printf("Attente du clic sur la croix avant de fermer la grille...\n");
EVENT_GRILLE_SDL event;
event = ReadEvent();
while (event.type != CROIX)
{
event = ReadEvent();
printf("Action recue du type: %d\n", event.type);
}
// Fermeture de la grille de jeu (SDL)
printf("(THREAD EVENT) Fermeture de la grille...\n");
fflush(stdout);
FermerGrilleSDL();
fflush(stdout);
printf("Suppression du threadDefileMessage\n");
pthread_cancel(threadHandleMessage);
if (cleServer)
{
printf("Deconnection du serveur...\n");
DeconnectionServeur((key_t)cleServer);
}
exit(0);
}
void DessineRaquetteGauche(int l,int c)
{
DessineSprite(l-2,c,S_RAQUETTE_GAUCHE);
}
void DessineRaquetteHaut(int l,int c)
{
DessineSprite(l,c-2,S_RAQUETTE_HAUT);
}
void DessineRaquetteBas(int l,int c)
{
DessineSprite(l,c-2,S_RAQUETTE_BAS);
}
void DessineVerrou(int l,int c)
{
DessineSprite(l,c,S_VERROU);
}
void DessineMur(int l,int c)
{
DessineSprite(l,c,S_MUR);
}
void DessineLettre(int L,int C,char c)
{
c = toupper(c);
switch(c)
{
case 'A' : DessineSprite(L,C,LETTRE_A); break;
case 'B' : DessineSprite(L,C,LETTRE_B); break;
case 'C' : DessineSprite(L,C,LETTRE_C); break;
case 'D' : DessineSprite(L,C,LETTRE_D); break;
case 'E' : DessineSprite(L,C,LETTRE_E); break;
case 'F' : DessineSprite(L,C,LETTRE_F); break;
case 'G' : DessineSprite(L,C,LETTRE_G); break;
case 'H' : DessineSprite(L,C,LETTRE_H); break;
case 'I' : DessineSprite(L,C,LETTRE_I); break;
case 'J' : DessineSprite(L,C,LETTRE_J); break;
case 'K' : DessineSprite(L,C,LETTRE_K); break;
case 'L' : DessineSprite(L,C,LETTRE_L); break;
case 'M' : DessineSprite(L,C,LETTRE_M); break;
case 'N' : DessineSprite(L,C,LETTRE_N); break;
case 'O' : DessineSprite(L,C,LETTRE_O); break;
case 'P' : DessineSprite(L,C,LETTRE_P); break;
case 'Q' : DessineSprite(L,C,LETTRE_Q); break;
case 'R' : DessineSprite(L,C,LETTRE_R); break;
case 'S' : DessineSprite(L,C,LETTRE_S); break;
case 'T' : DessineSprite(L,C,LETTRE_T); break;
case 'U' : DessineSprite(L,C,LETTRE_U); break;
case 'V' : DessineSprite(L,C,LETTRE_V); break;
case 'W' : DessineSprite(L,C,LETTRE_W); break;
case 'X' : DessineSprite(L,C,LETTRE_X); break;
case 'Y' : DessineSprite(L,C,LETTRE_Y); break;
case 'Z' : DessineSprite(L,C,LETTRE_Z); break;
case ' ' : DessineSprite(L,C,LETTRE_ESPACE); break;
case '0' : DessineSprite(L,C,CHIFFRE_0); break;
case '1' : DessineSprite(L,C,CHIFFRE_1); break;
case '2' : DessineSprite(L,C,CHIFFRE_2); break;
case '3' : DessineSprite(L,C,CHIFFRE_3); break;
case '4' : DessineSprite(L,C,CHIFFRE_4); break;
case '5' : DessineSprite(L,C,CHIFFRE_5); break;
case '6' : DessineSprite(L,C,CHIFFRE_6); break;
case '7' : DessineSprite(L,C,CHIFFRE_7); break;
case '8' : DessineSprite(L,C,CHIFFRE_8); break;
case '9' : DessineSprite(L,C,CHIFFRE_9); break;
default : DessineSprite(L,C,LETTRE_ESPACE); break;
}
}
int main(int argc,char* argv[])
{
int i, j;
CASE *pcase;
char buffer[80];
srand((unsigned)time(NULL)); // Pour permettre d'avoir des v. aléatoires.
pieceEnCours.nbCases = 4;
printf("(THREAD MAIN) Masquage de tous les signaux\n");
sigset_t mask;
sigfillset(&mask);
pthread_sigmask(SIG_BLOCK, &mask, NULL);
//Initialisation des mutex, variables de conditions et clés d'accès aux variables spécifiques
pthread_mutex_init(&mutexMessage, NULL);
pthread_mutex_init(&mutexCasesInserees, NULL);
pthread_mutex_init(&mutexScore, NULL);
pthread_mutex_init(&mutexAnalyse, NULL);
pthread_mutex_init(&mutexTraitement, NULL);
pthread_cond_init(&condCasesInserees, NULL);
pthread_cond_init(&condScore, NULL);
pthread_cond_init(&condAnalyse, NULL);
pthread_key_create(&cle, free_case);
// Ouverture de la grille de jeu (SDL)
printf("(THREAD MAIN) Ouverture de la grille de jeu\n");
fflush(stdout);
sprintf(buffer,"!!! TETRIS ZERO GRAVITY !!!");
if (OuvrirGrilleSDL(NB_LIGNES,NB_COLONNES,40,buffer) < 0)
{
printf("Erreur de OuvrirGrilleSDL\n");
fflush(stdout);
exit(1);
}
// Chargement des sprites et de l'image de fond
ChargementImages();
DessineSprite(12,11,VOYANT_VERT);
printf("Nombre d'arguments: %d\n", argc);
if (argc > 1)
{
if ( argc != 3)
{
printf("Il faut executer le programme de la façon suivante : ./Tetris cleServer pseudo\n");
exit(1);
}
///////////////////////////////////////// Mode online /////////////////////////////////////////////
cleServer = atoi(argv[1]);
printf("Connexion au serveur...\n");
if (ConnectionServeur( (key_t)cleServer, argv[2]) == 0)
{
printf("Connexion réussie.\n");
//Creation du thread joueurs connectés ////////////////////////////////////////////////////////////
if (errno = pthread_create(&threadHandleJoueurs, NULL, threadJoueursConnectes, NULL) !=0 )
perror("Erreur de lancement threadJoueursConnectes");
//Creation du thread de TopScore //////////////////////////////////////////////////////////////////
if (errno = pthread_create(&threadHandleTopScore, NULL, threadTopScore, NULL) !=0 )
perror("Erreur de lancement threadTopScore");
}
else
{
printf("\n---------------------------\nImpossible d'établir la connexion au serveur\n");
}
}
//Creation du thread de defilement du message /////////////////////////////////////////////////////
setMessage("Bienvenue dans Tetris Zero Gravity");
if (errno = pthread_create(&threadHandleMessage, NULL, threadDefileMessage, NULL) !=0 )
perror("Erreur de lancement threadDefileMessage");
//Creation du thread de defilement du message /////////////////////////////////////////////////////
if (errno = pthread_create(&threadHandlePiece, NULL, threadPiece, NULL) !=0 )
perror("Erreur de lancement threadPiece");
//Creation du thread Event ////////////////////////////////////////////////////////////////////////
if (errno = pthread_create(&threadHandleEvent, NULL, threadEvent, NULL) !=0 )
perror("Erreur de lancement threadEvent");
//Creation du thread Score ////////////////////////////////////////////////////////////////////////
if (errno = pthread_create(&threadHandleScore, NULL, threadScore, NULL) !=0 )
perror("Erreur de lancement threadScore");
/**/printf("(Main) Thread Score cree. errno = %d\n", (int)errno);
//Creation des threads Case ///////////////////////////////////////////////////////////////////////
for (i = 0 ; i < NB_LIGNES ; ++i)
{
for (j = 0 ; j < 10 ; ++j)
{
pcase = (CASE*)malloc(sizeof(CASE));
pcase->ligne = i;
pcase->colonne = j;
if (errno = pthread_create(&threadHandleCase[i][j], NULL, threadCase, (void*)pcase)!=0)
perror("Erreur de lancement threadCase");
}
}
//Creation du thread Gravité //////////////////////////////////////////////////////////////////////
if (errno = pthread_create(&threadHandleGravite, NULL, threadGravite, NULL) !=0 )
perror("Erreur de lancement threadGravite");
//Creation du thread FinPartie ////////////////////////////////////////////////////////////////////
if (errno = pthread_create(&threadHandleFinPartie, NULL, threadFinPartie, NULL) !=0 )
perror("Erreur de lancement threadFinPartie");
///////////////////////////////////////////////////////////////////////////////////////////////////
printf("(Main) Pret a jouer.\n");
// Attente de la fin de la partie
pthread_join(threadHandleFinPartie, NULL);
terminerProgramme();
}
int main(int argc,char* argv[])
{
EVENT_GRILLE_SDL event;
int i,j;
char buffer[80];
char ok;
pthread_t threadHandleDefileMessage;
pthread_t threadHandlePiece;
pthread_t threadHandleEvent;
pthread_t threadHandleScore;
pthread_t threadHandleGravite;
srand((unsigned)time(NULL));
sigemptyset(&sigAct.sa_mask);
sigAct.sa_handler = handlerSIGUSR1;
sigaction(SIGUSR1,&sigAct,NULL);
sigemptyset(&sigAct.sa_mask);
sigaction(SIGUSR2,&sigAct,NULL);
// Ouverture de la grille de jeu (SDL)
printf("(THREAD MAIN) Ouverture de la grille de jeu\n");
fflush(stdout);
sprintf(buffer,"!!! TETRIS ZERO GRAVITY !!!");
if (OuvrirGrilleSDL(NB_LIGNES,NB_COLONNES,40,buffer) < 0)
{
printf("Erreur de OuvrirGrilleSDL\n");
fflush(stdout);
exit(1);
}
// Chargement des sprites et de l'image de fond
ChargementImages();
DessineSprite(12,11,VOYANT_VERT);
pthread_mutex_init(&mutexMessage,NULL);
pthread_mutex_init(&mutexCasesInserees,NULL);
pthread_cond_init(&condCasesInserees,NULL);
//Creation du thread threadDefileMessage
if(pthread_create(&threadHandleDefileMessage,NULL,(void*(*)(void*))threadDefileMessage,(void*)NULL)!=0)
{
printf("(THREAD MAIN) Erreur de creation threadDefileMessage\n");
exit(-1);
}
//Creation thread piece
if(pthread_create(&threadHandlePiece,NULL,(void*(*)(void*))threadPiece,(void*)NULL)!=0)
{
printf("(THREAD MAIN) Erreur de creation threadPiece\n");
exit(-1);
}
//Creation du thread event
if(pthread_create(&threadHandleEvent,NULL,(void*(*)(void*))threadEvent,(void*)NULL)!=0)
{
printf("(THREAD MAIN) Erreur de creation threadEvent\n");
exit(-1);
}
//Creation du thread Score
if(pthread_create(&threadHandleScore,NULL,(void*(*)(void*))threadScore,(void*)NULL)!=0)
{
printf("(THREAD MAIN) Erreur de creation threadScore\n");
exit(-1);
}
//Creation des threads Cases
pthread_key_create(&cle,NULL);
for(i=0;i<14;i++)
{
for(j=0;j<10;j++)
{
pthread_mutex_lock(&mutexCaseSet);
if(!pCases)
pCases=(CASE*)malloc(sizeof(CASE));
pCases->ligne=i;
pCases->colonne=j;
if(pthread_create(&tabThreadCases[i][j],NULL,(void*(*)(void*))threadCases,(void*)pCases)!=0)
{
printf("(THREAD MAIN) Erreur de creation threadCases\n");
exit(-1);
}
}
}
//Creation threadGravite
if(pthread_create(&threadHandleGravite,NULL,(void*(*)(void*))threadGravite,(void*)NULL)!=0)
{
printf("(THREAD MAIN) Erreur de creation threadGravite\n");
exit(-1);
}
//Creation threadFinPartie
if(pthread_create(&threadHandleFinPartie,NULL,(void*(*)(void*))threadFinPartie,(void*)NULL)!=0)
{
printf("(THREAD MAIN) Erreur de creation threadFinPartie\n");
exit(-1);
}
setMessage("Bienvenue dans Tetris Zero Gravity");
ok = 0;
while(!ok)
{
event = ReadEvent();
if (event.type == CROIX) ok = 1;
}
//pthread_join(threadHandleFinPartie,NULL);
// Fermeture de la grille de jeu (SDL)
printf("(THREAD MAIN) Fermeture de la grille..."); fflush(stdout);
FermerGrilleSDL();
pthread_cancel(threadHandleDefileMessage);
pthread_cancel(threadHandlePiece);
pthread_cancel(threadHandleEvent);
pthread_cancel(threadHandleScore);
for(i=0;i<14;i++)
{
for(j=0;j<10;j++)
{
pthread_cancel(tabThreadCases[i][j]);
}
}
pthread_cancel(threadHandleGravite);
pthread_cancel(threadHandleFinPartie);
printf("OK\n"); fflush(stdout);
exit(0);
}
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* 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 handlerSIGUSR1 (int sig)
{
int nbCaseTemp,cont,i;
CASE *caseTemp;
pthread_mutex_lock(&mutexAnalyse);
caseTemp=(CASE*)pthread_getspecific(cle);
//Analyse Ligne
for(i=0,nbCaseTemp=0;i<10;i++)//verifie si ligne complete
{
if(tab[caseTemp->ligne][i]==BRIQUE)
nbCaseTemp++;
}
if(nbCaseTemp==i)
{
for(i=0,cont=1;i<nbLignesCompletes;i++)//verifie si deja pas trouve par un autre thread
{
if(lignesCompletes[i]==caseTemp->ligne)
{
cont=0;
break;
}
}
if(cont==1)
{
nbLignesCompletes++;
lignesCompletes[i]=caseTemp->ligne;
for(i=0;i<10;i++)
{
DessineSprite(caseTemp->ligne,i,FUSION);
}
}
}
//Analyse Colonne
for(i=0,nbCaseTemp=0;i<14;i++)
{
if(tab[i][caseTemp->colonne]==BRIQUE)
nbCaseTemp++;
}
if(nbCaseTemp==i)
{
for(i=0,cont=1;i<nbColonnesCompletes;i++)
{
if(colonnesCompletes[i]==caseTemp->colonne)
{
cont=0;
break;
}
}
if(cont==1)
{
nbColonnesCompletes++;
colonnesCompletes[i]=caseTemp->colonne;
for(i=0;i<14;i++)
{
DessineSprite(i,caseTemp->colonne,FUSION);
}
}
}
nbAnalyses++;
pthread_mutex_unlock(&mutexAnalyse);
pthread_cond_signal(&condAnalyse);
}
void DessineRaquetteDroite(int l,int c)
{
DessineSprite(l-2,c,S_RAQUETTE_DROITE);
}
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);
}
}
