ecosys vb

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include "ecosys.h"

/* Pour utiliser la correction automatique:
cavecorrector 6-7 repertoire
 */



Animal *creer_animal(int x, int y, float energie) {
    //srand(time(NULL));
    Animal *animal = (Animal*)malloc(sizeof(Animal));
    if(animal == NULL) return NULL;
    animal->x = x;
    animal->y = y;
    animal->dir[0] = 1 - (rand()%3);
    animal->dir[1] = 1 - (rand()%3);
    animal->energie = energie;
    animal->precedent=NULL;
    animal->suivant=NULL;
    return animal;
}

Animal *ajouter_en_tete_animal(Animal *liste, Animal *animal) {
    animal->precedent = NULL;
    if(liste->suivant!=NULL){
        animal->suivant=liste->suivant;
        liste->suivant->precedent=animal;
    }
    else{
        animal->suivant=NULL;
    }
    liste->suivant=animal;
    return liste;
}

void ajouter_animal(int x, int y, Animal **liste_animal) {
    if( x<0 || y<0 || x>= SIZE_X || y>= SIZE_Y){
        printf("Erreur de coordonnées.\n");
        exit(1);
    }else{
        ajouter_en_tete_animal(*liste_animal,creer_animal(x,y,energie));
    }
}

/*int compare_animal(Animal *a, Animal *b){
    if(a->x==b->x && a->y==b->y && a->dir[0]==b->dir[0] && a->dir[1]==b->dir[1] && a->energie==b->energie)
        return 1;
    return 0;
}

void enlever_animal(Animal **liste, Animal *animal) {
    Animal *indice=(*liste)->suivant;
    while(indice!=NULL){
        if(compare_animal(indice,animal)){
            if(indice->suivant!=NULL){
                indice->precedent->suivant=indice->suivant;
                if(indice->precedent!=NULL)
                    indice->suivant->precedent=indice->precedent;
            }
        if(indice!=NULL)
            free(indice);
        return; // on a trouve lanimal on a donc fini
        }
        if(indice->suivant!=NULL){
            indice=indice->suivant;
        }
    }
}*/
void enlever_animal(Animal **liste, Animal *animal) {
        if (animal == NULL)
                return;
        if (liste == NULL)
                return;
  if(animal->precedent)
    animal->precedent->suivant = animal->suivant;

  if (animal->suivant)
    animal->suivant->precedent = animal->precedent;


  if (*liste == animal)
    *liste=animal->suivant;

  free(animal);
}
  /*if(animal->precedent != NULL){ // perte de memoire
      animal->precedent->suivant = animal->suivant;
  }else if (animal->suivant != NULL){
      animal->suivant->precedent = animal->precedent;
  }else if(animal->precedent == NULL){
      animal->suivant->precedent = NULL;
  }else if(animal->suivant == NULL){
      animal->precedent->suivant = NULL;
  }
  free(animal->precedent);
  free(animal->suivant);*/
unsigned int compte_animal_rec(Animal *la) {
    if(la)
        return 1 + compte_animal_rec(la->suivant);
    return 0;
}

/*unsigned int compte_animal_it(Animal *la) {//erreur dans le comptage??
    unsigned int cpt = 0;
    while(la->suivant!=NULL){
        cpt++;
        la=la->suivant;
    }
    return cpt-1;
}*/
/*unsigned int compte_animal_it(Animal *la) {
    unsigned int cpt = 0;
    if(la == NULL){
        return cpt;
    }else if(la->suivant == NULL){
        return cpt + 1;
    }else{
        while(la->suivant != NULL){
            //printf("cpt = %u\n", cpt);
            cpt++;
            la = la->suivant;
        }
    return cpt;
    }
}*/
unsigned int compte_animal_it(Animal *la) {
  unsigned int compteur = 0 ;
  while(la){
    la=la->suivant;
    compteur++;
  }

  return compteur;
}

void bouger_animaux(Animal *la) {
    while(la){
      if((float)rand()/((float)RAND_MAX)<p_ch_dir){
        la->dir[0]=1 - (rand()%3);
      }
      else{
        la->x=(la->x+la->dir[0]+SIZE_X)%SIZE_X;
        }
      if((float)rand()/(float)RAND_MAX<p_ch_dir){
        la->dir[1]=1 - (rand()%3);
      }
      else{
        la->y=(la->y+la->dir[1]+SIZE_Y)%SIZE_Y;
      }
      la=la->suivant;
    }
}

void reproduce(Animal **liste_animal) {
    if(*liste_animal == NULL){
        exit(EXIT_FAILURE);
    }
  Animal *sereproduit=(*liste_animal)->suivant;
  while(sereproduit!=NULL){
    if((float)rand()/(float)RAND_MAX<p_reproduce){
        ajouter_animal(sereproduit->x,sereproduit->y,liste_animal);
    }
    sereproduit=sereproduit->suivant;
  }
}
/*
void rafraichir_proies(Animal **liste_proie) {
  //ici cesty une copie donc faux
  Animal *onterafraichit=*liste_proie;
  while(onterafraichit->suivant!=NULL){
    printf("o");
    bouger_animaux(onterafraichit);
    onterafraichit->energie+=-d_proie;
    if(onterafraichit->energie<0){
      enlever_animal(liste_proie,onterafraichit);
    }
    onterafraichit=onterafraichit->suivant;
  }
  reproduce(liste_proie);
  return ;
}*/

void rafraichir_proies(Animal **liste_proie) {
    if((*liste_proie)->suivant){ // pourquoi si cette condition c'est bon, sinon on a un free qd mm? a explorer?
        Animal *onterafraichit=(*liste_proie)->suivant;
        bouger_animaux(onterafraichit);
        while(onterafraichit){
            //printf("o");
            onterafraichit->energie+=-d_proie;
            if(onterafraichit->energie<=0)
                enlever_animal(liste_proie,onterafraichit);
            onterafraichit=onterafraichit->suivant;
        }
        reproduce(liste_proie);
    }
    else{
        exit(EXIT_FAILURE);
    }
}


Animal *animal_en_XY(Animal *l, int x, int y) {
    while(l){
        if(l->x==x && l->y==y){
            return l;
        }
        l=l->suivant;
    }
  return NULL;
}

void rafraichir_predateurs(Animal **liste_predateur, Animal **liste_proie) {
    Animal *fresh=(*liste_predateur)->suivant,*adresse;
    bouger_animaux(fresh);
    while(fresh){
        fresh->energie=fresh->energie - d_predateur;
        if(fresh->energie<=0){
            enlever_animal(liste_predateur, fresh);
        }
        adresse = animal_en_XY(*liste_proie,fresh->x, fresh->y);
        if(adresse){
            if(rand()/(float)RAND_MAX<p_manger){
                enlever_animal(liste_proie, adresse);
            }
        }
        fresh = fresh->suivant;
    }
    reproduce(liste_predateur);

}
/*
void afficher_ecosys(Animal *liste_proie,Animal *liste_predateur) {
    int i, j;
    //Animal *proies=liste_proie->suivant,*predateurs=liste_predateur->suivant;
    //int len = max(liste_proie, liste_predateur);
    for(i = 0; i<SIZE_Y; i++){
        for(j = 0; j<SIZE_X; j++){
            if(animal_en_XY(liste_proie,i,j)){
                if(animal_en_XY(liste_predateur,i,j)){
                    printf("@");
                }
                printf("*");
            }
            else if(animal_en_XY(liste_predateur,i,j))
                printf("O");
            else
                printf(" ");
        }
        printf("\n");
    }
    // le soucis ici c'est que si on trouve le 3e animal en bas a droite par exemple, on a perdu la reference du 4 et 5 car les boucles over
    // lidee serait plutot de parcourir a chaque fois les deux structures
}*/

void afficher_ecosys(Animal *liste_proie,Animal *liste_predateur) {
    int i,j;
    liste_predateur=liste_predateur->suivant;
    liste_proie=liste_proie->suivant;
    char tab[SIZE_X][SIZE_Y];
    for(i=0;i<SIZE_X;i++){
        for(j=0;j<SIZE_Y;j++){
            tab[i][j] = ' ';
        }
    }
    while(liste_proie){
        tab[liste_proie->x][liste_proie->y] = '*';
        liste_proie = liste_proie->suivant;
    }
    while(liste_predateur){
        if(tab[liste_predateur->x][liste_predateur->y]=='*'){
            tab[liste_predateur->x][liste_predateur->y] = '@';
        }else{
            tab[liste_predateur->x][liste_predateur->y] = 'O';
        }
        liste_predateur=liste_predateur->suivant;
    }
    printf(" ____________________\n");
    for(i=0;i<SIZE_X;i++){
        printf("|");
        for(j=0;j<SIZE_Y;j++){
            printf("%c", tab[i][j]);
        }
        printf("|\n");
    }
}

void liberer_liste_animaux(Animal *liste) {
    Animal *np = liste;
    if (!liste) return;
    //assert(!liste->precedent); /* debut de la liste */
    do {
        np = liste->suivant;
        free(liste);
        liste = np;
    }while (liste);
}

void clear_screen() {
  printf("\x1b[2J\x1b[1;1H");  /* code ANSI X3.4 pour effacer l'ecran */
}