diff --git a/effets.c b/effets.c
new file mode 100644
index 0000000000000000000000000000000000000000..54362866045e4fc61385ce04f529f67e5439754c
--- /dev/null
+++ b/effets.c
@@ -0,0 +1,20 @@
+#include "effets.h"
+
+Effet nouvel_effet_bloodHit(SDL_Texture **sprites, SDL_Rect pos, int angle){
+  Effet e;
+  e.pos = pos;
+  e.srcrect.x = 0;
+  e.srcrect.y = 0;
+  e.srcrect.w = 128;
+  e.srcrect.h = 128;
+  e.image = sprites[2];
+  e.angle = angle - 90;
+  e.xMax = 1920;
+  return e;
+}
+
+
+
+void afficher_effet(SDL_Renderer *renderer, Effet e){
+  SDL_RenderCopyEx(renderer, e.image, &e.srcrect, &e.pos, e.angle, NULL, SDL_FLIP_NONE);
+}
diff --git a/effets.h b/effets.h
new file mode 100644
index 0000000000000000000000000000000000000000..33276385562072a23c3be98825dbb27db7524294
--- /dev/null
+++ b/effets.h
@@ -0,0 +1,16 @@
+#include <SDL2/SDL.h>
+
+
+typedef struct s_Effet Effet, s_Effet;
+struct s_Effet
+{
+    SDL_Rect pos;
+    SDL_Rect srcrect;
+    SDL_Texture *image;
+    float angle;
+    int xMax;
+};
+
+Effet nouvel_effet_bloodHit(SDL_Texture **sprites, SDL_Rect pos, int angle);
+void afficher_effet(SDL_Renderer *renderer, Effet e);
+
diff --git a/listeB.c b/listeB.c
index a3adaf421bc5a5c6b0e4d05eff396da2a560910b..5efee12f196de40c4f70ab754a674275db42d0be 100644
--- a/listeB.c
+++ b/listeB.c
@@ -8,11 +8,12 @@ ListeB nouvelle_listeB(balle data){
   return L;
 }
 
-ListeB cons_listeB(ListeB L, balle data){
-  ListeB tmp;
-  tmp = nouvelle_listeB(data);
-  tmp->next = L;
-  return tmp;
+void cons_listeB(ListeB *L, balle data){
+  ListeB tmp = malloc(sizeof(s_ListeB));
+  tmp->data = data;
+  tmp->next = *L;
+  *L = tmp;
+  return ;
 }
 
 bool est_vide_listeB(ListeB L) {
@@ -21,7 +22,7 @@ bool est_vide_listeB(ListeB L) {
 
 
 
-ListeB incrementer_balles(ListeB LB, ListeP LP, ListeR LR, int v, int xCamera, int yCamera)
+ListeB incrementer_balles(ListeB LB, ListeP LP, ListeR LR, ListeE *LE, int v, int xCamera, int yCamera, SDL_Texture **sprites)
 {
   if(LB == NULL){
     return LB;
@@ -38,7 +39,7 @@ ListeB incrementer_balles(ListeB LB, ListeP LP, ListeR LR, int v, int xCamera, i
   if(ballePos.x < 0 || ballePos.x >= 1000 || ballePos.y <= 0 || ballePos.y >= 700
      || detecter_collision_murs(LR, ballePos, xCamera, yCamera)){
     LB = LB->next;
-    return incrementer_balles(LB, LP, LR, v, xCamera, yCamera);
+    return incrementer_balles(LB, LP, LR, LE, v, xCamera, yCamera, sprites);
   }
 
   ballePos.w = 6;
@@ -46,13 +47,13 @@ ListeB incrementer_balles(ListeB LB, ListeP LP, ListeR LR, int v, int xCamera, i
   ballePos.x = LB->data.ballePos.x - 3;
   ballePos.y = LB->data.ballePos.y - 3;
 
-  if(detecter_collision_perso(LP, ballePos, xCamera, yCamera)) {
+  if(detecter_collision_perso(LP, LE, ballePos, LB->data.degats ,xCamera, yCamera, sprites)) {
     LB = LB->next;
-    return incrementer_balles(LB, LP, LR, v, xCamera, yCamera);
+    return incrementer_balles(LB, LP, LR, LE, v, xCamera, yCamera, sprites);
   }
 
 
-  LB->next = incrementer_balles(LB->next, LP, LR, v, xCamera, yCamera);
+  LB->next = incrementer_balles(LB->next, LP, LR, LE, v, xCamera, yCamera, sprites);
   return LB;
 
 
@@ -67,21 +68,23 @@ void afficher_listeB(SDL_Renderer *renderer, ListeB L) {
   }
 }
 
-ListeB tir_update(ListeB LB, ListeP LP, ListeR LR, int time, SDL_Texture *balleLongueJaune, int v, int xCamera, int yCamera){
+ListeB tir_update(ListeB LB, ListeP LP, ListeR LR, ListeE *LE, int time, SDL_Texture *balleLongueJaune, int v, int xCamera, int yCamera, SDL_Texture **sprites){
   //Si perso en train de tirer
   s_ListeP *tmp = LP;
   while(tmp != NULL){
     if(tmp->data.tir){
       //On fait pop une nouvelle balle toutes les X ms
       if(time > tmp->data.tempsTirPrecedent + 200) {
-        LB = cons_listeB(LB, nouvelle_balle(balleLongueJaune, tmp->data.angle, tmp->data.pos));
+        cons_listeB(&LB, nouvelle_balle(balleLongueJaune, tmp->data.angle, tmp->data.degats, tmp->data.pos));
         tmp->data.tempsTirPrecedent = time;
       }
     }
     tmp = tmp->next;
   }
   //On met a jour les coordonn�es des balles d�j� tir�es, d�pop si n�c�ssaire
-  LB = incrementer_balles(LB, LP, LR, v, xCamera, yCamera);
+  LB = incrementer_balles(LB, LP, LR, LE, v, xCamera, yCamera, sprites);
+
+
   return LB;
 }
 
diff --git a/listeB.h b/listeB.h
index a3f75e9f5048a4dcd35b63efa2d6156e0f4f3669..e8d285cf777c4d501ccf16ca52c759ac7d3a2ecb 100644
--- a/listeB.h
+++ b/listeB.h
@@ -1,6 +1,8 @@
+#include "listeP.h"
 #include <stdio.h>
 #include "projectile.h"
-#include "listeP.h"
+
+
 
 typedef struct s_ListeB *ListeB, s_ListeB;
 struct s_ListeB
@@ -10,8 +12,10 @@ struct s_ListeB
 };
 
 ListeB nouvelle_listeB(balle data);
-ListeB cons_listeB(ListeB L, balle data);
+void cons_listeB(ListeB *L, balle data);
 bool est_vide_listeB(ListeB L);
-ListeB incrementer_balles(ListeB LB, ListeP LP, ListeR LR, int v, int xCamera, int yCamera);
+ListeB incrementer_balles(ListeB LB, ListeP LP, ListeR LR, ListeE *LE, int v, int xCamera, int yCamera,  SDL_Texture **sprites);
 void afficher_listeB(SDL_Renderer *renderer, ListeB L);
-ListeB tir_update(ListeB LB, ListeP LP, ListeR LR, int time, SDL_Texture *balleLongueJaune, int v, int xCamera, int yCamera);
+ListeB tir_update(ListeB LB, ListeP LP, ListeR LR, ListeE *LE, int time, SDL_Texture *balleLongueJaune, int v, int xCamera, int yCamera, SDL_Texture **sprites);
+
+
diff --git a/listeE.c b/listeE.c
new file mode 100644
index 0000000000000000000000000000000000000000..3c1323a8bee6e6b81dc691fdf086769f20452c08
--- /dev/null
+++ b/listeE.c
@@ -0,0 +1,44 @@
+#include "listeE.h"
+
+void cons_listeE(ListeE *L, Effet data){
+  ListeE tmp = malloc(sizeof(s_ListeE));
+  tmp->data = data;
+  tmp->next = *L;
+  *L = tmp;
+  return;
+}
+
+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->next == NULL){
+        tmp = NULL;
+        L = tmp;
+      } else {
+        tmp = malloc(sizeof(s_ListeE));
+        tmp->data = L->next->data;
+        tmp->next = L->next->next;
+        *L = *tmp;
+      }
+    } else {
+      L = L->next;
+    }
+  }
+  return;
+}
+
+
+void afficher_listeE(SDL_Renderer *renderer, ListeE L, int dxCamera, int dyCamera){
+  ListeE tmp = L;
+  while(tmp != NULL) {
+    tmp->data.pos.x -= dxCamera;
+    tmp->data.pos.y -= dyCamera;
+    afficher_effet(renderer, tmp->data);
+    tmp = tmp->next;
+  }
+}
+
+
+
diff --git a/listeE.h b/listeE.h
new file mode 100644
index 0000000000000000000000000000000000000000..a402d1e9367ca3a60dc8b62a838b0a9d6cae56b1
--- /dev/null
+++ b/listeE.h
@@ -0,0 +1,14 @@
+#include "effets.h"
+#include <stdlib.h>
+
+
+typedef struct s_ListeE *ListeE, s_ListeE;
+struct s_ListeE
+{
+    ListeE next;
+    Effet data;
+};
+
+void cons_listeE(ListeE *L, Effet e);
+void afficher_listeE(SDL_Renderer *renderer, ListeE L, int dxCamera, int dyCamera);
+void animer_effets(ListeE L);
diff --git a/listeP.c b/listeP.c
index 0cb33d8e811cb827ed8cb2668ee9e7fa76f8802e..b5fb580cc2981842352a04e26ed6fa6cb57af6aa 100644
--- a/listeP.c
+++ b/listeP.c
@@ -9,12 +9,16 @@ ListeP nouvelle_listeP(Perso data){
   return L;
 }
 
-ListeP cons_listeP(ListeP L, Perso data){
-  ListeP tmp = nouvelle_listeP(data);
-  tmp->next = L;
-  return tmp;
+void cons_listeP(ListeP *L, Perso data){
+  ListeP tmp = malloc(sizeof(s_ListeP));
+  tmp->data = data;
+  tmp->next = *L;
+  *L = tmp;
+  return;
 }
 
+
+
 bool est_vide_listeP(ListeP L){
   return (L == NULL);
 }
@@ -28,46 +32,46 @@ void afficher_listeP(SDL_Renderer *renderer, ListeP L){
 }
 
 Perso* joueur(ListeP L){
-  s_ListeP *tmp = L;
-  while(tmp != NULL){
-    if(tmp->data.ennemi == false){
-      return &tmp->data;
+  while(L != NULL){
+    if(L->data.ennemi == false){
+      return &L->data;
     }
-    tmp = tmp->next;
+    L = L->next;
   }
   return NULL;
 }
 
 
-
-ListeP deplacement_ennemis(ListeP L, int xCamera, int yCamera, int dxCamera, int dyCamera){
-
-  if(L == NULL){
-    return L;
-  }
-
-  s_ListeP *tmp = L;
-  while(tmp != NULL){
-    deplacement_ennemi(&tmp->data, xCamera, yCamera, dxCamera, dyCamera);
-    tmp = tmp->next;
+void deplacement_ennemis(ListeP L, int xCamera, int yCamera, int dxCamera, int dyCamera){
+  while(L != NULL){
+    if(L->data.vie <= 0){
+      *L = *L->next;
+      L = L->next;
+    } else {
+      deplacement_ennemi(&L->data, xCamera, yCamera, dxCamera, dyCamera);
+      L = L->next;
+    }
   }
-
-  return L;
-
+  return;
 }
 
-bool detecter_collision_perso(ListeP L, SDL_Rect rect, int xCamera, int yCamera){
+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;//+ xCamera;
-    ax2 = rect.x + rect.w ;//+ xCamera;
+    ax1 = rect.x;
+    ax2 = rect.x + rect.w ;
     bx1 = L->data.pos.x;
     bx2 = L->data.pos.x + L->data.pos.w;
-    ay1 = rect.y;// + yCamera;
-    ay2 = rect.y;// + rect.h + yCamera;
+    ay1 = rect.y;
+    ay2 = rect.y;
     by1 = L->data.pos.y;
     by2 = L->data.pos.y + L->data.pos.h;
+
     if(ax1 < bx2 && ax2 > bx1 && ay1 < by2 && ay2 > by1 && L->data.ennemi){
+      L->data.vie -= degats;
+      e = nouvel_effet_bloodHit(sprites, L->data.pos, L->data.angle);
+      cons_listeE(LE, e);
       return true;
     }
     L = L->next;
@@ -76,18 +80,14 @@ bool detecter_collision_perso(ListeP L, SDL_Rect rect, int xCamera, int yCamera)
 
 }
 
-void animer_persos2(ListeP L){
+void animer_persos(ListeP L){
  while(L != NULL){
     if(L->data.ennemi){
       animer_perso(&L->data);
     }
     L = L->next;
   }
-}
-
-void animer_persos(ListeP L){
-
-  animer_persos2(L);
   return;
 }
 
+
diff --git a/listeP.h b/listeP.h
index a7e0f05f769f011e5167b44dcd1dff470a923824..ce6c11408b367717d92a9fd3e87fa8998b5e5a07 100644
--- a/listeP.h
+++ b/listeP.h
@@ -1,5 +1,7 @@
 #include "personnage.h"
-#include <stdio.h>
+#include <stdio.h>
+#include "listeE.h"
+
 
 
 typedef struct s_ListeP *ListeP, s_ListeP;
@@ -7,14 +9,18 @@ struct s_ListeP
 {
     ListeP next;
     Perso data;
-};
+};
+
+
 
 ListeP nouvelle_listeP(Perso data);
-ListeP cons_listeP(ListeP L, 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);
-ListeP deplacement_ennemis(ListeP L, int xCamera, int yCamera, int dxCamera, int dyCamera);
-bool detecter_collision_perso(ListeP L, SDL_Rect rect, int xCamera, int yCamera);
+void supprimer_ennemi(ListeP L);
+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 animer_persos2(ListeP L);
+
+
diff --git a/listeR.c b/listeR.c
index b4cab061b69eb093ab59ffb86e21d7af23547fc0..eeeb326996ba547a438fceb3aa90abc386e8030c 100644
--- a/listeR.c
+++ b/listeR.c
@@ -9,14 +9,16 @@ ListeR nouvelle_listeR(SDL_Rect data){
   return L;
 }
 
-ListeR cons_listeR(ListeR L, SDL_Rect data){
-  ListeR tmp = nouvelle_listeR(data);
-  tmp->next = L;
-  return tmp;
+void cons_listeR(ListeR *L, SDL_Rect data){
+  ListeR tmp = malloc(sizeof(s_ListeR));
+  tmp->data = data;
+  tmp->next = *L;
+  *L = tmp;
+  return;
 }
 
 
-ListeR charger_niveau(int *tab, ListeR L){
+void charger_niveau(int *tab, ListeR *L){
   //on met toutes les case � 0 pour dire que tout est du sol (provisoire)
   for(int j = 0; j < 30; j++){
     for(int i = 0; i < 30; i++){
@@ -49,28 +51,28 @@ ListeR charger_niveau(int *tab, ListeR L){
         rect.y = j * 50;
         rect.h = 25;
         rect.w = 50;
-        L = cons_listeR(L, rect);
+        cons_listeR(L, rect);
         break;
       case 2:
         rect.x = i * 50;
         rect.y = j * 50 + 25;
         rect.h = 25;
         rect.w = 50;
-        L = cons_listeR(L, rect);
+        cons_listeR(L, rect);
         break;
       case 3:
         rect.x = i * 50;
         rect.y = j * 50;
         rect.h = 50;
         rect.w = 25;
-        L = cons_listeR(L, rect);
+        cons_listeR(L, rect);
         break;
       case 4:
         rect.x = i * 50 + 25;
         rect.y = j * 50;
         rect.h = 50;
         rect.w = 25;
-        L = cons_listeR(L, rect);
+        cons_listeR(L, rect);
         break;
 
       case 5:
@@ -81,31 +83,30 @@ ListeR charger_niveau(int *tab, ListeR L){
         rect.y = j * 50;
         rect.h = 50;
         rect.w = 50;
-        L = cons_listeR(L, rect);
+        cons_listeR(L, rect);
         break;
       }
     }
   }
-  return L;
+  return ;
 }
 
 
 bool detecter_collision_murs(ListeR L, SDL_Rect rect, int xCamera, int yCamera){
-  s_ListeR *tmp = L;
   int ax1, ax2, bx1, bx2, ay1, ay2, by1, by2;
-  while(tmp != NULL){
+  while(L != NULL){
     ax1 = rect.x + xCamera;
     ax2 = rect.x + rect.w + xCamera;
-    bx1 = tmp->data.x;
-    bx2 = tmp->data.x + tmp->data.w;
+    bx1 = L->data.x;
+    bx2 = L->data.x + L->data.w;
     ay1 = rect.y + yCamera;
     ay2 = rect.y + rect.h + yCamera;
-    by1 = tmp->data.y;
-    by2 = tmp->data.y + tmp->data.h;
+    by1 = L->data.y;
+    by2 = L->data.y + L->data.h;
     if(ax1 < bx2 && ax2 > bx1 && ay1 < by2 && ay2 > by1){
       return true;
     }
-    tmp = tmp->next;
+    L = L->next;
   }
   return false;
 }
diff --git a/listeR.h b/listeR.h
index 9f06adcaaabf640bc190e7f3f572671cb2814d58..de909782ef6f7984cff35582f4f6d5ff51c65cc0 100644
--- a/listeR.h
+++ b/listeR.h
@@ -10,6 +10,6 @@ struct s_ListeR
 };
 
 ListeR nouvelle_listeR(SDL_Rect data);
-ListeR cons_listeR(ListeR L, SDL_Rect data);
-ListeR charger_niveau(int *tab, ListeR L);
+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);
diff --git a/main.c b/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..3554096a59b80b178ffeeec4945082fcd85b5654
--- /dev/null
+++ b/main.c
@@ -0,0 +1,198 @@
+#include "image.h"
+#include "listeB.h"
+
+
+int main(int argc, char *argv[])
+{
+    srand(time(NULL));
+    bool gameover = false;
+    bool tir = false;
+    SDL_Window *fenetre;
+    SDL_Event evenements;
+    SDL_Renderer *ecran;
+    SDL_Texture *fond, *perso, *balleLongueJaune;
+    SDL_Rect persoPos;
+    float mouseX, mouseY;
+    int vitesse = 25, tempsActuel = 0, tempsPrecedent = 0, tempsActuelTir = 0, tempsActuelAnim = 0, tempsPrecedentAnim = 0;
+    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];
+
+
+    //Initialisation SDL
+    if(SDL_Init(SDL_INIT_VIDEO < 0))
+    {
+      printf("Erreur d'initialisation de la SDL %s", SDL_GetError());
+      SDL_Quit();
+      return EXIT_FAILURE;
+    }
+
+    //Initialisation SDL_image (PNG)
+    IMG_Init(IMG_INIT_PNG);
+
+    //Cr�ation fen�tre
+    fenetre = SDL_CreateWindow("gameName", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1000, 700, SDL_WINDOW_RESIZABLE);
+    if(fenetre == NULL)
+    {
+      printf("Erreur d'initialisation de la fenetre %s", SDL_GetError());
+      return EXIT_FAILURE;
+    }
+
+    //Cr�ation renderer
+    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 d�cor (murs etc)
+    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);
+    spritesMap[3] = charger_image("sprites/map/mur_g.png", ecran, 255, 255, 255);
+    spritesMap[4] = charger_image("sprites/map/mur_d.png", ecran, 255, 255, 255);
+    spritesMap[5] = charger_image("sprites/map/mur_hg.png", ecran, 255, 255, 255);
+    spritesMap[6] = charger_image("sprites/map/mur_hd.png", ecran, 255, 255, 255);
+    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_move.png", ecran, 255, 255, 255);
+    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 d�passer 60 ex�cutions/sec (provisoire)
+      tempsActuel = SDL_GetTicks();
+      if (tempsActuel > tempsPrecedent + 16)
+      {
+        //D�tection �v�nements
+        while(SDL_PollEvent(&evenements))
+        {
+          switch(evenements.type)
+          {
+            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;
+
+          }
+        }
+
+
+        joueur_ptr = joueur(persosListe);
+        if(joueur_ptr != NULL){
+          //Gestion d�placement/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;
+        }
+
+
+
+
+
+        //D�placement/angle de tir ennemis
+        deplacement_ennemis(persosListe, xCamera, yCamera, dxCamera, dyCamera);
+
+        //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);
+        tempsPrecedent = tempsActuel;
+      }
+    }
+
+    //Nettoyage
+    SDL_DestroyWindow(fenetre);
+    SDL_DestroyTexture(fond);
+    SDL_DestroyTexture(perso);
+    IMG_Quit();
+    SDL_Quit();
+    return EXIT_SUCCESS;
+}
diff --git a/personnage.c b/personnage.c
new file mode 100644
index 0000000000000000000000000000000000000000..93c06e980a82c1cf423217467976a76662566ccb
--- /dev/null
+++ b/personnage.c
@@ -0,0 +1,144 @@
+#include "personnage.h"
+
+
+Perso nouveau_joueur(SDL_Renderer *renderer, SDL_Texture **sprites){
+  Perso p;
+  p.tempsTirPrecedent = 0;
+  p.image = sprites[0];
+  p.pos.x = 480;
+  p.pos.y = 330;
+  p.pos.w = 40;
+  p.pos.h = 40;
+  p.srcrect.x = 0;
+  p.srcrect.y = 0;
+  p.srcrect.w = 258;
+  p.srcrect.h = 220;
+  p.angle = 0;
+  p.vie = 100;
+  p.degats = 25;
+  p.vitesse = 4;
+  p.tir = false;
+  p.ennemi = false;
+  p.animFlip = 1;
+  return p;
+}
+
+Perso nouvel_ennemi_1(SDL_Renderer *renderer, SDL_Texture **sprites){
+  Perso p;
+  p.tempsTirPrecedent = 0;
+  p.image = sprites[1];
+  //g�n�re des coordonn�es de spawn al�atoires(provisoire)
+  p.pos.x = rand()%100 + 0;
+  p.pos.y = rand()%700 + 0;
+  p.pos.w = 60;
+  p.pos.h = 60;
+  p.srcrect.x = 0;
+  p.srcrect.y = 0;
+  p.srcrect.w = 288;
+  p.srcrect.h = 311;
+  p.angle = 0;
+  p.vie = 100;
+  p.degats = 10;
+  p.vitesse = 2;
+  p.tir = false;
+  p.ennemi = true;
+  p.animFlip = 1;
+  return p;
+}
+
+void afficher_perso(SDL_Renderer *renderer, Perso p)
+{
+  SDL_RenderCopyEx(renderer, p.image, &p.srcrect, &p.pos, p.angle, NULL, SDL_FLIP_NONE);
+}
+
+void deplacement_joueur(Perso *p, ListeR L, int *xCamera, int *yCamera, int *dxCamera, int *dyCamera)
+{
+  int dX = 0;
+  int dY = 0;
+
+  const Uint8 *state = SDL_GetKeyboardState(NULL);
+
+  if(state[SDL_GetScancodeFromKey(SDLK_z)]){
+    dY -= 1;
+  }
+
+  if(state[SDL_GetScancodeFromKey(SDLK_s)]){
+    dY += 1;
+  }
+
+  if(state[SDL_GetScancodeFromKey(SDLK_q)]){
+    dX -= 1;
+  }
+
+  if(state[SDL_GetScancodeFromKey(SDLK_d)]){
+    dX += 1;
+  }
+
+
+  dX = dX * p->vitesse;
+  dY = dY * p->vitesse;
+
+
+  *xCamera += dX;
+  *yCamera += dY;
+  *dxCamera = dX;
+  *dyCamera = dY;
+
+
+  if(detecter_collision_murs(L, p->pos, *xCamera, *yCamera)){
+    *xCamera -= dX;
+    *dxCamera = 0;
+    if(detecter_collision_murs(L, p->pos, *xCamera, *yCamera)){
+      *xCamera += dX;
+      *dxCamera = dX;
+      *yCamera -= dY;
+      *dyCamera = 0;
+      if(detecter_collision_murs(L, p->pos, *xCamera, *yCamera)){
+        *xCamera -= dX;
+        *dxCamera = 0;
+      }
+    }
+  }
+
+  return;
+}
+
+void deplacement_ennemi(Perso *p, int xCamera, int yCamera, int dxCamera, int dyCamera){
+  if(p != NULL){
+    if(p->ennemi){
+      //M�j de la direction du perso
+      angle_ennemi(p);
+      //Compensation du d�calage de la cam�ra + ajout du d�placement
+      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;
+  angle = atan2(mouseY - (p->pos.y + 20), mouseX - (p->pos.x + 20));
+  angle = (angle * 180.0000)/PI;
+  p->angle = angle;
+  return;
+}
+
+void angle_ennemi(Perso *p){
+  float angle;
+  angle = atan2( 350 - (p->pos.y + 20), 500 - (p->pos.x + 20));
+  p->angle = angle;
+  return;
+}
+
+void animer_perso(Perso *p){
+  p->srcrect.y += p->srcrect.h * p->animFlip;
+  if(p->srcrect.y > 4976|| p->srcrect.y < 0){
+    p->animFlip = -p->animFlip;
+    p->srcrect.y += p->srcrect.h * p->animFlip;
+  }
+  return;
+}
+
+
diff --git a/personnage.h b/personnage.h
index efba9718d1991a2bb0a3c869f8ec04c8480de49d..063d219de95ca2c5d9ac535debf6622526569917 100644
--- a/personnage.h
+++ b/personnage.h
@@ -16,6 +16,7 @@ struct s_Personnage
   float angle;
   int tempsTirPrecedent;
   int vie;
+  int degats;
   int vitesse;
   int animFlip;
   bool tir;
diff --git a/projectile.c b/projectile.c
index eb2e94c12a4f099595024de2a68a476a6b787c0d..7653b097417a1eddda70a8e55bb3570f4d453736 100644
--- a/projectile.c
+++ b/projectile.c
@@ -1,13 +1,14 @@
 #include "projectile.h"
 
 
-balle nouvelle_balle(SDL_Texture *image, float angle, SDL_Rect persoPos)
+balle nouvelle_balle(SDL_Texture *image, float angle, int degats, SDL_Rect persoPos)
 {
   balle b;
   b.angle = angle;
   b.collision = false;
   b.image = image;
   b.ballePos = persoPos;
+  b.degats = degats;
   return b;
 }
 
diff --git a/projectile.h b/projectile.h
index 8d1c272b753c2568ad4b9d7e996430a920a3d8bb..fd3bd0abceb2679c2953bd1b4201eb2bec5a7a25 100644
--- a/projectile.h
+++ b/projectile.h
@@ -11,9 +11,10 @@ struct s_Balle
     float angle;
     SDL_Texture *image;
     bool collision;
+    int degats;
 };
 
-balle nouvelle_balle(SDL_Texture *image, float angle, SDL_Rect persoPos);
+balle nouvelle_balle(SDL_Texture *image, float angle, int degats, SDL_Rect persoPos);
 void incrementer_balle(balle *b, int vitesse);
 void afficher_balle(SDL_Renderer *renderer, balle b);
 
diff --git a/sprites/effets/blood/blood_hitv3.png b/sprites/effets/blood/blood_hitv3.png
new file mode 100644
index 0000000000000000000000000000000000000000..d8b1451ebeeb3ef70fd94f8a4aeb5673fbaab0af
Binary files /dev/null and b/sprites/effets/blood/blood_hitv3.png differ