Degats, mort joueur, reset niveau

clavier.c

-/* #include <SDL2/SDL.h>
-#include "clavier.h"
-#include <stdio.h>
-
-
-
-
-
-
-
-void animer_persos(ListeP L){
-  s_ListeP *tmp = L;
-  tmp = tmp->next;
-  animer_perso(&tmp->data);
-  return;
-}
-
-
-*/

clavier.h

-/*#include <SDL2/SDL.h>
-#include "listeB.h"
-
-
-
-
-
-void animer_persos(ListeP L);*/
-

effets.c

@@ -7,9 +7,9 @@ Effet nouvel_effet_bloodHit(SDL_Texture **sprites, SDL_Rect pos, int angle){
   e.srcrect.y = 0;
   e.srcrect.w = 128;
   e.srcrect.h = 128;
-  e.image = sprites[2];
+  e.image = sprites[3];
   e.angle = angle - 90;
-  e.xMax = 1920;
+  e.yMax = 1920;
   return e;
 }
 

effets.h

@@ -8,7 +8,7 @@ struct s_Effet
     SDL_Rect srcrect;
     SDL_Texture *image;
     float angle;
-    int xMax;
+    int yMax;
 };
 
 Effet nouvel_effet_bloodHit(SDL_Texture **sprites, SDL_Rect pos, int angle);

listeB.c

 #include "listeB.h"
 
 
-ListeB nouvelle_listeB(balle data){
-  ListeB L = malloc(sizeof(s_ListeB));
-  L->data = data;
-  L->next = NULL;
-  return L;
-}
-
 void cons_listeB(ListeB *L, balle data){
   ListeB tmp = malloc(sizeof(s_ListeB));
   tmp->data = data;
   tmp->next = *L;
   *L = tmp;
-  return ;
+  return;
 }
 
 bool est_vide_listeB(ListeB L) {
@@ -72,7 +65,7 @@ ListeB tir_update(ListeB LB, ListeP LP, ListeR LR, ListeE *LE, int time, SDL_Tex
   //Si perso en train de tirer
   s_ListeP *tmp = LP;
   while(tmp != NULL){
-    if(tmp->data.tir){
+    if(tmp->data.tir && tmp->data.ennemi == false){
       //On fait pop une nouvelle balle toutes les X ms
       if(time > tmp->data.tempsTirPrecedent + 200) {
         cons_listeB(&LB, nouvelle_balle(balleLongueJaune, tmp->data.angle, tmp->data.degats, tmp->data.pos));

listeB.h

@@ -11,7 +11,7 @@ struct s_ListeB
     balle data;
 };
 
-ListeB nouvelle_listeB(balle data);
+
 void cons_listeB(ListeB *L, balle data);
 bool est_vide_listeB(ListeB L);
 ListeB incrementer_balles(ListeB LB, ListeP LP, ListeR LR, ListeE *LE, int v, int xCamera, int yCamera,  SDL_Texture **sprites);

listeE.c

 #include "listeE.h"
 
+
 void cons_listeE(ListeE *L, Effet data){
   ListeE tmp = malloc(sizeof(s_ListeE));
   tmp->data = data;
@@ -12,7 +13,7 @@ void animer_effets(ListeE L){
   ListeE tmp;
   while(L != NULL){
     L->data.srcrect.y += L->data.srcrect.h;
-    if(L->data.srcrect.y >= L->data.xMax){
+    if(L->data.srcrect.y >= L->data.yMax){
       if(L->next == NULL){
         tmp = NULL;
         L = tmp;

listeP.c

 #include "listeP.h"
 
 
-
-ListeP nouvelle_listeP(Perso data){
-  ListeP L = malloc(sizeof(s_ListeP));
-  L->data = data;
-  L->next = NULL;
-  return L;
-}
-
 void cons_listeP(ListeP *L, Perso data){
   ListeP tmp = malloc(sizeof(s_ListeP));
   tmp->data = data;
@@ -24,6 +16,7 @@ bool est_vide_listeP(ListeP L){
 }
 
 void afficher_listeP(SDL_Renderer *renderer, ListeP L){
+
   ListeP tmp = L;
   while(tmp != NULL) {
     afficher_perso(renderer, tmp->data);
@@ -32,6 +25,7 @@ void afficher_listeP(SDL_Renderer *renderer, ListeP L){
 }
 
 Perso* joueur(ListeP L){
+
   while(L != NULL){
     if(L->data.ennemi == false){
       return &L->data;
@@ -41,14 +35,39 @@ Perso* joueur(ListeP L){
   return NULL;
 }
 
+void deplacement_ennemi(Perso *p, Perso *joueur, int xCamera, int yCamera, int dxCamera, int dyCamera){
+
+  int dX = 0;
+  int dY = 0;
+
+  if(p != NULL){
+    if(p->ennemi){
+      //Mj de la direction du perso
+      angle_ennemi(p);
+      //Compensation du dcalage de la camra + ajout du dplacement
+      dX = p->pos.x + round(-dxCamera + cos(p->angle) * p->vitesse);
+      dY = p->pos.y + round(-dyCamera + sin(p->angle) * p->vitesse);
+      //if(!detecter_collision_avec_joueur(p, joueur)){
+        detecter_collision_avec_joueur(p, joueur);
+        p->pos.x = dX;
+        p->pos.y = dY;
+    //  }
+
+      p->angle = (p->angle * 180.0000)/PI;
+    }
+  }
+  return;
+}
 
 void deplacement_ennemis(ListeP L, int xCamera, int yCamera, int dxCamera, int dyCamera){
+  Perso *joueur_ptr = joueur(L);
   while(L != NULL){
-    if(L->data.vie <= 0){
+    if(L->data.vie <= 0 && L->data.ennemi){
       *L = *L->next;
       L = L->next;
     } else {
-      deplacement_ennemi(&L->data, xCamera, yCamera, dxCamera, dyCamera);
+      deplacement_ennemi(&L->data, joueur_ptr, xCamera, yCamera, dxCamera, dyCamera);
+
       L = L->next;
     }
   }
@@ -56,8 +75,10 @@ void deplacement_ennemis(ListeP L, int xCamera, int yCamera, int dxCamera, int d
 }
 
 bool detecter_collision_perso(ListeP L, ListeE *LE, SDL_Rect rect, int degats, int xCamera, int yCamera, SDL_Texture **sprites){
+
   int ax1, ax2, bx1, bx2, ay1, ay2, by1, by2;
   Effet e;
+
   while(L != NULL){
     ax1 = rect.x;
     ax2 = rect.x + rect.w ;
@@ -80,12 +101,35 @@ bool detecter_collision_perso(ListeP L, ListeE *LE, SDL_Rect rect, int degats, i
 
 }
 
-void animer_persos(ListeP L){
+void detecter_collision_avec_joueur(Perso *p, Perso *joueur){
+
+  int ax1, ax2, bx1, bx2, ay1, ay2, by1, by2;
+
+  ax1 = p->pos.x;
+  ax2 = p->pos.x + p->pos.w ;
+  bx1 = joueur->pos.x + 0.3 * joueur->pos.w;
+  bx2 = joueur->pos.x + 0.7 * joueur->pos.w;
+  ay1 = p->pos.y;
+  ay2 = p->pos.y + p->pos.h;
+  by1 = joueur->pos.y + 0.3 * joueur->pos.h;
+  by2 = joueur->pos.y + 0.7 * joueur->pos.h;
+
+  if(ax1 < bx2 && ax2 > bx1 && ay1 < by2 && ay2 > by1){
+    p->tir = true;
+    p->vitesse = 1;
+  }
+
+  return;
+}
+
+
+void animer_persos(ListeP L, SDL_Texture **sprites, Perso *joueur){
+
  while(L != NULL){
-    if(L->data.ennemi){
-      animer_perso(&L->data);
-    }
-    L = L->next;
+  if(L->data.ennemi){
+    animer_perso(&L->data, joueur, sprites);
+  }
+  L = L->next;
   }
   return;
 }

listeP.h

@@ -13,14 +13,15 @@ struct s_ListeP
 
 
 
-ListeP nouvelle_listeP(Perso data);
 void cons_listeP(ListeP *L, Perso data);
 bool est_vide_listeP(ListeP L);
 void afficher_listeP(SDL_Renderer *renderer, ListeP L);
 Perso* joueur(ListeP L);
 void supprimer_ennemi(ListeP L);
+void deplacement_ennemi(Perso *p, Perso *joueur, int xCamera, int yCamera, int dxCamera, int dyCamera);
 void deplacement_ennemis(ListeP L, int xCamera, int yCamera, int dxCamera, int dyCamera);
 bool detecter_collision_perso(ListeP L, ListeE *LE, SDL_Rect rect, int degats, int xCamera, int yCamera, SDL_Texture **sprites);
-void animer_persos(ListeP L);
+void detecter_collision_avec_joueur(Perso *p, Perso *joueur);
+void animer_persos(ListeP L, SDL_Texture **sprites, Perso *joueur);
 
 

listeR.c

 #include "listeR.h"
 
 
-
-ListeR nouvelle_listeR(SDL_Rect data){
-  ListeR L = malloc(sizeof(s_ListeR));
-  L->data = data;
-  L->next = NULL;
-  return L;
-}
-
 void cons_listeR(ListeR *L, SDL_Rect data){
   ListeR tmp = malloc(sizeof(s_ListeR));
   tmp->data = data;

listeR.h

@@ -9,7 +9,7 @@ struct s_ListeR
   SDL_Rect data;
 };
 
-ListeR nouvelle_listeR(SDL_Rect data);
+
 void cons_listeR(ListeR *L, SDL_Rect data);
 void charger_niveau(int *tab, ListeR *L);
 bool detecter_collision_murs(ListeR L, SDL_Rect rect, int xCamera, int yCamera);

main.c

@@ -5,24 +5,20 @@
 int main(int argc, char *argv[])
 {
     srand(time(NULL));
-    bool gameover = false;
-    bool tir = false;
+    bool gameover, tir, exit;
     SDL_Window *fenetre;
     SDL_Event evenements;
     SDL_Renderer *ecran;
-    SDL_Texture *fond, *perso, *balleLongueJaune;
-    SDL_Rect persoPos;
+    SDL_Texture *tmp, *balleSprite, *sprites[4], *spritesMap[9];
     float mouseX, mouseY;
-    int vitesse = 25, tempsActuel = 0, tempsPrecedent = 0, tempsActuelTir = 0, tempsActuelAnim = 0, tempsPrecedentAnim = 0;
+    int vitesse, tempsActuel, tempsPrecedent, tempsActuelTir, tempsActuelAnim, tempsPrecedentAnim,
+        xCamera, yCamera, dxCamera, dyCamera, map[30][30]; ;
     ListeB ballesTirees;
     ListeP persosListe;
     ListeR mursListe;
     ListeE effetsListe;
-    Perso *joueur_ptr;
-    SDL_Texture *sprites[3];
-    SDL_Texture *spritesMap[9];
-    int xCamera = 0, yCamera = 0, dxCamera = 0, dyCamera = 0;
-    int map[30][30];
+    Perso p, *joueur_ptr;
+
 
 
     //Initialisation SDL
@@ -48,10 +44,8 @@ int main(int argc, char *argv[])
     ecran = SDL_CreateRenderer(fenetre, -1, SDL_RENDERER_ACCELERATED);
 
     //Chargement images
-    balleLongueJaune = charger_image("sprites/projectiles/balle/balle_longue_jaune.png", ecran, 255, 255, 255);
-
-
-    //Chargement du dcor (murs etc)
+    balleSprite = charger_image("sprites/projectiles/balle/balle_longue_jaune.png", ecran, 255, 255, 255);
+    //Murs + Sols
     spritesMap[0] = charger_image("sprites/map/sol.png", ecran, 0, 0, -1);
     spritesMap[1] = charger_image("sprites/map/mur_h.png", ecran, 255, 255, 255);
     spritesMap[2] = charger_image("sprites/map/mur_b.png", ecran, 255, 255, 255);
@@ -62,136 +56,155 @@ int main(int argc, char *argv[])
     spritesMap[7] = charger_image("sprites/map/mur_bg.png", ecran, 255, 255, 255);
     spritesMap[8] = charger_image("sprites/map/mur_bd.png", ecran, 255, 255, 255);
 
-    fond = charger_image("sprites/fond.png", ecran, -1, -1, -1);
-    perso = charger_image("sprites/perso/handgun/idle/survivor_idle.png", ecran, 255, 255, 255);
-    sprites[0] = perso;
-    perso = charger_image("sprites/ennemis/zombie/move/zombie_moveV2.png", ecran, 0, 0, -1);
-    sprites[1] = perso;
-    perso = charger_image("sprites/effets/blood/blood_hitv3.png", ecran, 0, 0, -1);
-    sprites[2] = perso;
-
-
-    SDL_Rect tmpRect;
-    tmpRect.x = 0;
-    tmpRect.y = 0;
-    tmpRect.w = 0;
-    tmpRect.h = 0;
-    mursListe = nouvelle_listeR(tmpRect);
-    charger_niveau(map[0], &mursListe);
-
-
-    Perso p = nouveau_joueur(ecran , sprites);
-    persosListe = nouvelle_listeP(p);
-    p = nouvel_ennemi_1(ecran, sprites);
-    cons_listeP(&persosListe, p);
-    p = nouvel_ennemi_1(ecran, sprites);
-    cons_listeP(&persosListe, p);
-    p = nouvel_ennemi_1(ecran, sprites);
-    cons_listeP(&persosListe, p);
-    p = nouvel_ennemi_1(ecran, sprites);
-    cons_listeP(&persosListe, p);
-    p = nouvel_ennemi_1(ecran, sprites);
-    cons_listeP(&persosListe, p);
-    p = nouvel_ennemi_1(ecran, sprites);
-    cons_listeP(&persosListe, p);
-
-
-    balle b = nouvelle_balle(balleLongueJaune, 0, 0, persoPos);
-    ballesTirees = nouvelle_listeB(b);
-
-    effetsListe = NULL;
-
-    //Boucle de jeu
-    while(!gameover)
-    {
-      //Petit timer pour pas dpasser 60 excutions/sec (provisoire)
-      tempsActuel = SDL_GetTicks();
-      if (tempsActuel > tempsPrecedent + 16)
+    //Personnages + Effets
+    tmp = charger_image("sprites/perso/handgun/idle/survivor_idle.png", ecran, 255, 255, 255);
+    sprites[0] = tmp;
+    tmp = charger_image("sprites/ennemis/zombie/move/zombie_moveV2.png", ecran, 0, 0, -1);
+    sprites[1] = tmp;
+    tmp = charger_image("sprites/ennemis/zombie/attack/zombie_attack.png", ecran, 0, 0, -1);
+    sprites[2] = tmp;
+    tmp = charger_image("sprites/effets/blood/blood_hitv3.png", ecran, 0, 0, -1);
+    sprites[3] = tmp;
+
+    exit = false;
+
+    while(!exit){
+
+      gameover = false;
+      tir = false;
+
+      vitesse = 25;
+      tempsActuel = 0;
+      tempsPrecedent = 0;
+      tempsActuelTir = 0;
+      tempsActuelAnim = 0;
+      tempsPrecedentAnim = 0;
+      xCamera = 0;
+      yCamera = 0;
+      dxCamera = 0;
+      dyCamera = 0;
+
+      mursListe = NULL;
+      ballesTirees = NULL;
+      effetsListe = NULL;
+      persosListe = NULL;
+      joueur_ptr = NULL;
+
+      charger_niveau(map[0], &mursListe);
+
+      p = nouveau_joueur(ecran, sprites);
+      cons_listeP(&persosListe, p);
+      p = nouvel_ennemi_1(ecran, sprites);
+      cons_listeP(&persosListe, p);
+      p = nouvel_ennemi_1(ecran, sprites);
+      cons_listeP(&persosListe, p);
+      p = nouvel_ennemi_1(ecran, sprites);
+      cons_listeP(&persosListe, p);
+      p = nouvel_ennemi_1(ecran, sprites);
+      cons_listeP(&persosListe, p);
+
+
+
+      //Boucle de jeu
+      while(!gameover)
       {
-        //Dtection vnements
-        while(SDL_PollEvent(&evenements))
+        tempsActuel = SDL_GetTicks();
+        if (tempsActuel > tempsPrecedent + 16)
         {
-          switch(evenements.type)
+          //Dtection vnements
+          while(SDL_PollEvent(&evenements))
           {
-            case SDL_QUIT:
-              gameover = true;
-              break;
-            case SDL_MOUSEMOTION:
-              mouseX = evenements.motion.x;
-              mouseY = evenements.motion.y;
-              break;
-            case SDL_MOUSEBUTTONDOWN:
-              switch(evenements.button.button)
-              {
-                case SDL_BUTTON_LEFT:
-                  tir = true;
-                  break;
-              }
-              break;
-            case SDL_MOUSEBUTTONUP:
-              switch(evenements.button.button)
-              {
-                case SDL_BUTTON_LEFT:
-                  tir = false;
-                  break;
-              }
-              break;
-
-            case SDL_KEYDOWN:
-              switch(evenements.key.keysym.sym)
-              {
-                case SDLK_ESCAPE:
-                  gameover = true;
-                  break;
-              }
-              break;
-
+            switch(evenements.type)
+            {
+              case SDL_QUIT:
+                gameover = true;
+                exit = true;
+                break;
+              case SDL_MOUSEMOTION:
+                mouseX = evenements.motion.x;
+                mouseY = evenements.motion.y;
+                break;
+              case SDL_MOUSEBUTTONDOWN:
+                switch(evenements.button.button)
+                {
+                  case SDL_BUTTON_LEFT:
+                    tir = true;
+                    break;
+                }
+                break;
+              case SDL_MOUSEBUTTONUP:
+                switch(evenements.button.button)
+                {
+                  case SDL_BUTTON_LEFT:
+                    tir = false;
+                    break;
+                }
+                break;
+
+              case SDL_KEYDOWN:
+                switch(evenements.key.keysym.sym)
+                {
+                  case SDLK_ESCAPE:
+                    gameover = true;
+                    exit = true;
+                    break;
+                }
+                break;
+
+            }
           }
-        }
 
 
-        joueur_ptr = joueur(persosListe);
-        if(joueur_ptr != NULL){
-          //Gestion dplacement/angle de tir
-          joueur_ptr->tir = tir;
-          deplacement_joueur(joueur_ptr, mursListe, &xCamera, &yCamera, &dxCamera, &dyCamera);
-          angle_joueur((joueur_ptr), mouseX, mouseY);
-        }
-
+          joueur_ptr = joueur(persosListe);
+          if(joueur_ptr != NULL){
+            //Gestion dplacement/angle de tir
+            joueur_ptr->tir = tir;
+            deplacement_joueur(joueur_ptr, mursListe, &xCamera, &yCamera, &dxCamera, &dyCamera);
+            angle_joueur((joueur_ptr), mouseX, mouseY);
+          }
 
-        tempsActuelAnim = SDL_GetTicks();
-        if(tempsActuelAnim > tempsPrecedentAnim + 40 ){
-          animer_persos(persosListe);
-          animer_effets(effetsListe);
-          tempsPrecedentAnim = tempsActuelAnim;
-        }
 
+          tempsActuelAnim = SDL_GetTicks();
+          if(tempsActuelAnim > tempsPrecedentAnim + 40 ){
+            animer_persos(persosListe, sprites, joueur_ptr);
+            animer_effets(effetsListe);
+            tempsPrecedentAnim = tempsActuelAnim;
+          }
 
+          //Dtection mort joueur
+          if(joueur_ptr->vie <= 0){
+            gameover = true;
+          }
 
 
+          //Dplacement/angle de tir ennemis
+          deplacement_ennemis(persosListe, xCamera, yCamera, dxCamera, dyCamera);
 
-        //Dplacement/angle de tir ennemis
-        deplacement_ennemis(persosListe, xCamera, yCamera, dxCamera, dyCamera);
+          //Tir
+          tempsActuelTir = SDL_GetTicks();
+          ballesTirees = tir_update(ballesTirees, persosListe, mursListe, &effetsListe, tempsActuelTir, balleSprite, vitesse, xCamera, yCamera, sprites);
 
-        //Tir
-        tempsActuelTir = SDL_GetTicks();
-        ballesTirees = tir_update(ballesTirees, persosListe, mursListe, &effetsListe, tempsActuelTir, balleLongueJaune, vitesse, xCamera, yCamera, sprites);
+          //Affichage
+          SDL_RenderClear(ecran);
+          afficher_niveau(map[0], ecran, spritesMap, xCamera, yCamera);
+          afficher_listeE(ecran, effetsListe, dxCamera, dyCamera);
+          afficher_listeP(ecran, persosListe);
+          afficher_listeB(ecran, ballesTirees);
+          SDL_RenderPresent(ecran);
 
-        //Affichage
-        SDL_RenderClear(ecran);
-        afficher_niveau(map[0], ecran, spritesMap, xCamera, yCamera);
-        afficher_listeE(ecran, effetsListe, dxCamera, dyCamera);
-        afficher_listeP(ecran, persosListe);
-        afficher_listeB(ecran, ballesTirees);
-        SDL_RenderPresent(ecran);
-        tempsPrecedent = tempsActuel;
+          tempsPrecedent = tempsActuel;
+        }
       }
+
+      if(gameover)
+      printf("gameover :(\n");
+
     }
 
     //Nettoyage
     SDL_DestroyWindow(fenetre);
-    SDL_DestroyTexture(fond);
-    SDL_DestroyTexture(perso);
+    SDL_DestroyTexture(balleSprite);;
+    SDL_DestroyTexture(tmp);
     IMG_Quit();
     SDL_Quit();
     return EXIT_SUCCESS;

personnage.c

@@ -105,19 +105,6 @@ void deplacement_joueur(Perso *p, ListeR L, int *xCamera, int *yCamera, int *dxC
   return;
 }
 
-void deplacement_ennemi(Perso *p, int xCamera, int yCamera, int dxCamera, int dyCamera){
-  if(p != NULL){
-    if(p->ennemi){
-      //Mj de la direction du perso
-      angle_ennemi(p);
-      //Compensation du dcalage de la camra + ajout du dplacement
-      p->pos.x += round(-dxCamera + cos(p->angle) * p->vitesse);
-      p->pos.y += round(-dyCamera + sin(p->angle) * p->vitesse);
-      p->angle = (p->angle * 180.0000)/PI;
-    }
-  }
-  return;
-}
 
 void angle_joueur(Perso *p, float mouseX, float mouseY){
   float angle;
@@ -134,11 +121,47 @@ void angle_ennemi(Perso *p){
   return;
 }
 
-void animer_perso(Perso *p){
-  p->srcrect.y += p->srcrect.h * p->animFlip;
-  if(p->srcrect.y >= p->yMax|| p->srcrect.y < 0){
-    p->animFlip = -p->animFlip;
+void animer_perso(Perso *p, Perso *joueur, SDL_Texture **sprites){
+  if(p->tir){
+    if(p->srcrect.w != 318){
+      p->image = sprites[2];
+      p->pos.w = 60;
+      p->pos.h = 60;
+      p->srcrect.w = 318;
+      p->srcrect.h = 294;
+      p->srcrect.y = 0;
+      p->yMax = 2646;
+      p->animFlip = 1;
+    } else {
+      p->srcrect.y += p->srcrect.h * p->animFlip;
+      if(p->srcrect.y == p->srcrect.h * 6){
+        if(joueur->vie < p->degats){
+          joueur->vie = 0;
+        }else {
+          joueur->vie -= p->degats;
+        }
+      } else if(p->srcrect.y == p->yMax){
+        p->image = sprites[1];
+        p->pos.w = 50;
+        p->pos.h = 50;
+        p->srcrect.w = 229;
+        p->srcrect.h = 259;
+        p->srcrect.y = 0;
+        p->yMax = 4403;
+        p->animFlip = 1;
+        p->tir = false;
+        p->vitesse = 2;
+      }
+    }
+
+  }
+
+  else {
     p->srcrect.y += p->srcrect.h * p->animFlip;
+    if((p->srcrect.y >= p->yMax || p->srcrect.y < 0) && !p->tir){
+      p->animFlip = -p->animFlip;
+      p->srcrect.y += p->srcrect.h * p->animFlip;
+    }
   }
   return;
 }

personnage.h

 #include <time.h>
+#include <stdio.h>
 #include <math.h>
 #include "image.h"
 #include "listeR.h"
@@ -19,6 +20,7 @@ struct s_Personnage
   int degats;
   int vitesse;
   int animFlip;
+  int yMax;
   bool tir;
   bool ennemi;
 };
@@ -28,8 +30,7 @@ Perso nouveau_joueur(SDL_Renderer *renderer, SDL_Texture **sprites);
 Perso nouvel_ennemi_1(SDL_Renderer *renderer, SDL_Texture **sprites);
 void afficher_perso(SDL_Renderer *renderer, Perso p);
 void deplacement_joueur(Perso *p, ListeR L, int *xCamera, int *yCamera, int *dxCamera, int *dyCamera);
-void deplacement_ennemi(Perso *p, int xCamera, int yCamera, int dxCamera, int dyCamera);
 void angle_ennemi(Perso *p);
 void angle_joueur(Perso *p, float mouseX, float mouseY);
-void animer_perso(Perso *p);
+void animer_perso(Perso *p, Perso *joueur, SDL_Texture **sprites);