void init_Zsg(S_Zsg *sz, int dim, int nbcl){
int i,j;
if(!sz){
fprintf(stderr, "erreur d'allocation\n");
exit(1);
}
sz->dim = dim;
sz->nbcl = nbcl;
sz->Lzsg = NULL;
sz->B = NULL;
sz->App = malloc(sizeof(int *)* sz->dim);
if(sz->App == NULL){
exit(0);
}
for (i=0; i<sz->dim; i++){
sz->App[i] = malloc(sizeof(int) * sz->dim);
for(j=0; j < sz->dim; j++)
sz->App[i][j] = -2; /* Initialiser tout les case a -2 */
}
sz->B = (Liste **)malloc(sizeof(Liste*) * sz->nbcl);
if(sz->B == NULL){
exit(0);
}
for(i=0; i < sz->nbcl; i++){
sz->B[i] = malloc(sizeof(Liste * ));
init_liste(sz->B[i]);
}
sz->Lzsg = malloc(sizeof(Liste *));
init_liste(sz->Lzsg);
/*if ((sz->Lzsg == NULL) || (sz->B == NULL))
exit(0);*/
}
int sequence_aleatoire_imp(int **M, Grille *G, int dim, int aff){
/* initialisation du tableau de couleurs dans la grille */
int *tab = initialise_tab_couleur(G->nbcl);
nb_couleur_initiales(&tab,M,G->dim);
int nbCoups = 0;
srand(time(NULL));
/* On definit Zsg, la zone contenant la case situee en haut a gauche */
Liste L;
init_liste(&L);
int taille = 0;
int new_couleur;
int couleur = M[0][0];
int nbcl = cpt_couleur(tab,G->nbcl);
trouve_zone_imp(M, dim, 0, 0, &taille, &L);
printf("Couleur initiale : %d \n",couleur);
/* selectionne une couleur tant que la grille contient plus d'une couleur */
do{
do{
new_couleur = (int)(rand()%(G->nbcl));
}
while(tab[new_couleur] == 0);
/* si la couleur selectionnee est differente de la couleur de Zsg */
if(new_couleur != couleur){
tab[couleur] -= taille;
couleur = new_couleur;
tab[couleur] += taille;
peint(G,couleur,M,&L);
/* on peint toute les cases avec la nouvelle couleur, puis on effectue une nouvelle recherche afin de voir si notre zone possede de nouvelles cases */
detruit_liste(&L);
taille = 0;
trouve_zone_imp(M,dim,0,0,&taille,&L);
peint(G,couleur,M,&L);
nbcl = cpt_couleur(tab,G->nbcl);
nbCoups++;
if(aff == 1){
//Grille_attente_touche();
Grille_redessine_Grille();
}
if(aff == 2){
affiche_liste(&L);
Grille_attente_touche();
Grille_redessine_Grille();
}
}
}while(nbcl > 1);
printf("Couleur finale : %d\n", couleur);
// printf("nbCoups = %d\n", nbCoups);
return nbCoups;
}
void init_echangeur(echangeur* current,int id){
current->ID=id;
current->nbV=0;
for(int i=0;i<4;++i){
init_liste(&(current->file_attente[i]),i);
}
/* current->mutex = PTHREAD_MUTEX_INITIALIZER;
current->condition = PTHREAD_COND_INITIALIZER;
pthread_mutex_init(current->mutex,NULL);
pthread_cond_init(current->condition,NULL); */
}
void generation_mob_suivante(t_cellule grille[N][M],t_coord personnage){
t_coord coordonnee;
init_liste();
for(coordonnee.x=0;coordonnee.x<N;coordonnee.x++){
for(coordonnee.y=0;coordonnee.y<M;coordonnee.y++){
//printf("\nX=%d,Y=%d",coordonnee.x,coordonnee.y);
if(grille[coordonnee.x][coordonnee.y]==ennemi && !est_present(coordonnee) && chemin_possible(grille,personnage,coordonnee)){
recherche_chemin(grille,coordonnee,personnage);
en_queue();
ajout_droit(coordonnee);
}
}
}
vider_liste();
}
/* Dans cette fonction, on possede deux liste : L contenant les cases composant la zone et pile qui possede les cases adjacente aux cases entree en zone et ce termine quand le premier element de la pile est egal au premier element de L */
void trouve_zone_imp(int **M, int dim, int i, int j, int *taille, Liste *L)
{
int couleur = M[i][j];
Liste *pile = (Liste *)malloc(sizeof(Liste));
int trash1,trash2;
init_liste(pile);
ajoute_en_tete(pile,i,j);
//affiche_liste(pile,M);
M[i][j] = -1;
(*taille) = 0;
do {
ajoute_en_tete(L,(*pile)->i,(*pile)->j);
(*taille)++;
enleve_en_tete(pile,&trash1,&trash2);
/* case de droite */
if((*L)->i != (dim-1) && M[(*L)->i+1][(*L)->j] == couleur)
{
M[(*L)->i+1][(*L)->j] = -1;
ajoute_en_tete(pile,(*L)->i+1,(*L)->j);
}
/* case du bas */
if ((*L)->j != (dim-1) && M[(*L)->i][(*L)->j+1] == couleur)
{
M[(*L)->i][(*L)->j+1] = -1;
ajoute_en_tete(pile,(*L)->i,(*L)->j+1);
}
/* case de gauche */
if ((*L)->i != 0 && M[(*L)->i-1][(*L)->j] == couleur)
{
M[(*L)->i-1][(*L)->j] = -1;
ajoute_en_tete(pile,(*L)->i-1,(*L)->j);
}
/* case du haut */
if((*L)->j != 0 && M[(*L)->i][(*L)->j-1] == couleur)
{
M[(*L)->i][(*L)->j-1] = -1;
ajoute_en_tete(pile,(*L)->i,(*L)->j-1);
}
}
while(!test_liste_vide(pile));
}
void append(liste** l, int x, int y){
liste* l2 = init_liste(x,y);
l2->suivant = *l;
*l = l2;
}
int agrandit_zsg(int **M, S_Zsg *zone, int cl, int k, int l)
{
Liste *pile = (Liste *)malloc(sizeof(Liste));
Liste *bordure = (Liste *)malloc(sizeof(Liste));
int trash1,trash2;
init_liste(pile);
init_liste(bordure);
ajoute_en_tete(pile,k,l);
int taille = 0;
int couleur;
do{
k = (*pile)->i;
l = (*pile)->j;
if (!(appartient_zsg(M, zone, k, l))){
ajoute_zsg(M, zone, k, l);
taille++;
}
enleve_en_tete(pile,&trash1,&trash2);
/* case de droite */
if(k != (zone->dim-1) && zone->App[k+1][l] != -1){
if(zone->App[k+1][l] != -1 && M[k+1][l] == cl && !(appartient_zsg(M, zone, k+1, l))){
//printf("(%d, %d) ajouté à zone\n", k+1, l);
ajoute_en_tete(pile, k+1, l);
}
else{
if(M[k+1][l] != cl && !(appartient_bordure(M, zone, k+1, l))){
ajoute_bordure(M, zone, k+1, l);
//printf("(%d, %d) ajouté à bordure\n", k+1, l);
}
}
}
/* case du bas */
if(l != (zone->dim-1) && zone->App[k][l+1] != -1){
if(zone->App[k][l+1] != -1 && M[k][l+1] == cl && !(appartient_zsg(M, zone, k, l+1))){
//printf("(%d, %d) ajouté à zone\n", k, l+1);
ajoute_en_tete(pile, k, l+1);
}
else{
if(M[k][l+1] != cl && !(appartient_bordure(M, zone, k, l+1))){
ajoute_bordure(M, zone, k, l+1);
//printf("(%d, %d) ajouté à bordure\n", k, l+1);
}
}
}
/* case de gauche */
if(k != 0 && zone->App[k-1][l] != -1){
if(zone->App[k-1][l] != -1 && M[k-1][l] == cl && !(appartient_zsg(M, zone, k-1, l))){
//printf("(%d, %d) ajouté à zone\n", k-1, l);
ajoute_en_tete(pile, k-1, l);
}
else{
if(M[k-1][l] != cl && !(appartient_bordure(M, zone, k-1, l))){
// ajoute_en_tete(bordure, k, l+1);
ajoute_bordure(M, zone, k-1, l);
// printf("(%d, %d) ajouté à bordure\n", k-1, l);
}
}
}
/* case du haut */
if(l != 0 && zone->App[k][l-1] != -1){
if(zone->App[k][l-1] != -1 && M[k][l-1] == cl && !(appartient_zsg(M, zone, k, l-1))){
//printf("(%d, %d) ajouté à zone\n", k, l-1);
ajoute_en_tete(pile, k, l-1);
}
else{
if(M[k][l-1] != cl && !(appartient_bordure(M, zone, k, l-1))){
//printf("(%d, %d) ajouté à bordure\n", k, l-1);
ajoute_bordure(M, zone, k, l-1);
}
}
}
}while(!test_liste_vide(pile));
return taille;
}
int sequence_aleatoire_rapide(int **M, Grille *G, int aff)
{
/* initialisation de Zsg */
Liste Lzsg;
init_liste(&Lzsg);
Liste *B = (Liste*)malloc((G->nbcl)*sizeof(Liste));
int **App = (int**)malloc((G->dim)*sizeof(int*));
int i, j;
int k = 0;
int l = 0;
for (i = 0; i < G->dim; i++){
App[i] = malloc((G->dim)*sizeof(int));
}
for(i = 0; i < G->dim; i++){
for(j = 0; j < G->dim; j++)
App[i][j] = -2;
}
for (i = 0; i < G->nbcl; i++)
init_liste(&B[i]);
S_Zsg zone = init_zsg(G->dim, G->nbcl, Lzsg, B, App);
int couleur = M[0][0];
printf("couleur initiale : %d\n", couleur);
int *tab = initialise_tab_couleur(G->nbcl);
nb_couleur_initiales(&tab,M,G->dim);
int new_couleur;
int nbCoups = 0;
int nbcl = G->nbcl;
int taille;
taille = agrandit_zsg(M, &zone, couleur, 0, 0);
if(aff == 1){
//Grille_attente_touche();
Grille_redessine_Grille();
}
if(aff == 2){
affiche_liste(&(zone.Lzsg));
Grille_attente_touche();
Grille_redessine_Grille();
}
Elnt_liste *actu;
do{
plus_grd_cl(zone,G,&k,&l);
couleur = M[k][l];
actu = B[couleur];
tab[M[0][0]] -= taille;
tab[couleur] += taille;
while(actu != NULL){
taille += agrandit_zsg(M,&zone,couleur,actu->i,actu->j);
actu = actu->suiv;
}
detruit_liste(&(zone.B[couleur]));
peint(G,couleur,M,&(zone.Lzsg));
nbcl = cpt_couleur(tab,G->nbcl);
nbCoups++;
if(aff == 1){
//Grille_attente_touche();
Grille_redessine_Grille();
}
if(aff == 2){
affiche_liste(&(zone.Lzsg));
Grille_attente_touche();
Grille_redessine_Grille();
}
}while(nbcl > 1);
printf("Couleur finale : %d\n", couleur);
//printf("nbCoups = %d\n", nbCoups);
return nbCoups;
}
int agrandit_Zsg(int **M, S_Zsg *Z, int cl, int k, int l){
Liste *Pile = malloc(sizeof(Liste *));
int i, j, x, y, cpt = 0; /* cpt pout compter le nombre de case ajoutes dans ZSG */
Liste *c = Z->B[cl];
int **rm;
if(!rechercher_Liste(k, l, Z->B[cl])){
printf("le case (k, l) n'est pas dans la bordure\n");
exit(EXIT_FAILURE);
}
init_liste(Pile);
rm=(int **) malloc(sizeof(int*)*(Z->dim));
for (x=0;x<(Z->dim);x++){
rm[x]=(int*) malloc(sizeof(int)*(Z->dim));
for (y=0;y<(Z->dim);y++)
rm[x][y]=0;
}
/* placer tous les case de B[cl] dans la pile */
while((*c) != NULL){
ajoute_en_tete(Pile, (*c)->i,( *c)->j);
rm[(*c)->i][(*c)->j] = 1;
c = &((*c)->suiv);
}
detruit_liste(Z->B[cl]); /* detruir la bordure */
while(!test_liste_vide(Pile)){
enleve_en_tete(Pile, &i, &j);
if (M[i][j] == cl) {
/* Si le case est de la bonne couleur, on l'ajoute a la ZSG */
ajoute_Zsg(Z, i, j);
cpt++;
/* a gauche */
if ((i > 0) &&
!((rm[i][j] == 1) || (appartient_Zsg(Z, i - 1, j)))) {
/* Si la case n'est pas dans la pile ni dans la ZSG */
ajoute_en_tete(Pile, i - 1, j);
rm[i-1][j] = 1;
}
/* a droite */
if ((i < Z->dim-1) &&
!(rm[i + 1][j] || (appartient_Zsg(Z, i + 1, j)))) {
/* Si la case n'est pas dans la pile ni dans la ZSG */
ajoute_en_tete(Pile, i + 1, j);
rm[i+1][j] = 1;
}
/* en bas */
if ((j < Z->dim-1) &&
!(rm[i][j + 1] || (appartient_Zsg(Z, i, j+1)))) {
/* Si la case n'est pas dans la pile ni dans la ZSG */
ajoute_en_tete(Pile, i, j+1);
rm[i][j+1] = 1;
}
/* en haut */
if ((j > 0) &&
!(rm[i][j-0] || (appartient_Zsg(Z, i, j-0)))) {
/* Si la case n'est pas dans la pile ni dans la ZSG */
ajoute_en_tete(Pile, i, j-0);
rm[i][j-1] = 1;
}
}
else /* Sinon on l'ajoute a la bordure */
ajoute_Bordure(Z, i, j, M[i][j]);
}
for(i=0; i<Z->dim; i++)
free(rm[i]);
free(rm);
return cpt;
}
