diff --git a/V4 - version final/IMG/barrage.bmp b/V4 - version final/IMG/barrage.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..d5c498c03bd1d78c92b075234cd97da8bf4874cc
Binary files /dev/null and b/V4 - version final/IMG/barrage.bmp differ
diff --git a/V4 - version final/IMG/barrage.png b/V4 - version final/IMG/barrage.png
new file mode 100644
index 0000000000000000000000000000000000000000..b01e074720bc538cb66be3a6937ac0941c89c193
Binary files /dev/null and b/V4 - version final/IMG/barrage.png differ
diff --git a/V4 - version final/IMG/boutton.bmp b/V4 - version final/IMG/boutton.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..fdef830b2cc98ca53885150389932558be2690ed
Binary files /dev/null and b/V4 - version final/IMG/boutton.bmp differ
diff --git a/V4 - version final/IMG/boutton.png b/V4 - version final/IMG/boutton.png
new file mode 100644
index 0000000000000000000000000000000000000000..c9b505b2c71b86b852cd654c2ee8cb0e6a583a77
Binary files /dev/null and b/V4 - version final/IMG/boutton.png differ
diff --git a/V4 - version final/IMG/bullet.bmp b/V4 - version final/IMG/bullet.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..41727a4cbdc2fd2b879a2b0136f90740d896a38c
Binary files /dev/null and b/V4 - version final/IMG/bullet.bmp differ
diff --git a/V4 - version final/IMG/enemy_car.bmp b/V4 - version final/IMG/enemy_car.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..921f7b8ba0e7b0c8508eabdb007acbb8aac6c4fe
Binary files /dev/null and b/V4 - version final/IMG/enemy_car.bmp differ
diff --git a/V4 - version final/IMG/enemy_car.png b/V4 - version final/IMG/enemy_car.png
new file mode 100644
index 0000000000000000000000000000000000000000..a5c7ee8e071f3adbe06f9de12da1b2f28ea4ef8e
Binary files /dev/null and b/V4 - version final/IMG/enemy_car.png differ
diff --git a/V4 - version final/IMG/exit.bmp b/V4 - version final/IMG/exit.bmp
new file mode 100755
index 0000000000000000000000000000000000000000..e98608dab41c7d04b685f2c406914b957a9ccf0d
Binary files /dev/null and b/V4 - version final/IMG/exit.bmp differ
diff --git a/V4 - version final/IMG/main_car.bmp b/V4 - version final/IMG/main_car.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..6cbf99e55e53368df10e0642f6a02ae78635f873
Binary files /dev/null and b/V4 - version final/IMG/main_car.bmp differ
diff --git a/V4 - version final/IMG/menu.bmp b/V4 - version final/IMG/menu.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..2279f00e33796aba5c7f80a5e082724788c4cf08
Binary files /dev/null and b/V4 - version final/IMG/menu.bmp differ
diff --git a/V4 - version final/IMG/new_game.bmp b/V4 - version final/IMG/new_game.bmp
new file mode 100755
index 0000000000000000000000000000000000000000..6de58c8de83b7cecb2e4ba256212ed3e6b76bbe3
Binary files /dev/null and b/V4 - version final/IMG/new_game.bmp differ
diff --git a/V4 - version final/IMG/road.bmp b/V4 - version final/IMG/road.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..2279f00e33796aba5c7f80a5e082724788c4cf08
Binary files /dev/null and b/V4 - version final/IMG/road.bmp differ
diff --git a/V4 - version final/IMG/settings.bmp b/V4 - version final/IMG/settings.bmp
new file mode 100755
index 0000000000000000000000000000000000000000..48e5326011de7f88fa580b50431a88b97df42c44
Binary files /dev/null and b/V4 - version final/IMG/settings.bmp differ
diff --git a/V4 - version final/IMG/voiture.png b/V4 - version final/IMG/voiture.png
new file mode 100644
index 0000000000000000000000000000000000000000..4f3dc697771868eff55c5ab38d5dcc49ec727736
Binary files /dev/null and b/V4 - version final/IMG/voiture.png differ
diff --git a/V4 - version final/Makefile b/V4 - version final/Makefile
new file mode 100755
index 0000000000000000000000000000000000000000..18461e7b658986564b6d54dd97a1d560f7384d89
--- /dev/null
+++ b/V4 - version final/Makefile
@@ -0,0 +1,19 @@
+CC = gcc
+CFLAGS = -W -Wall -ansi -std=c99 -g
+LIBS = -L./SDL2_ttf/.libs -L./SDL2_image/.libs
+LDFLAGS = `sdl2-config --cflags --libs` -lSDL2_ttf -lSDL2_image -lSDL2_ttf
+INCLUDES = -I./SDL2_ttf -I./SDL2_image
+EXEC = main
+SRC = main.c fonctions_SDL.c data.c logic.c colision.c events.c graphics.c liste.c
+OBJ = $(SRC:.c=.o) -lm
+
+all: $(EXEC)
+main: $(OBJ)
+ $(CC) $(CFLAGS) $(INCLUDES) -o $@ $^ $(LIBS) $(LDFLAGS)
+%.o: %.c
+ $(CC) $(CFLAGS) -o $@ -c $<
+clean:
+ rm -rf *.o *~
+mrproper: clean
+ rm -rf $(EXEC)
+
\ No newline at end of file
diff --git a/V4 - version final/colision.c b/V4 - version final/colision.c
new file mode 100755
index 0000000000000000000000000000000000000000..8189cd56d88111d8c32e49785c33f0ad578a762e
--- /dev/null
+++ b/V4 - version final/colision.c
@@ -0,0 +1,99 @@
+/**
+ * \file collision.c
+ * \brief Gestion des collisions du jeu
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#include "colision.h"
+#include "liste.h"
+#include <stdio.h>
+
+void handle_Main_Barrage_collision(sprite_t *sp1, sprite_t *sp2, world_t *world, resources_t *textures,
+ SDL_Renderer *renderer) {
+ if (sprites_collide(sp1, sp2)) {
+ sp1->direction = 2;
+ move_all_except_rick(world, renderer, textures);
+ sp1->direction = 0;
+ sp1->speed = 0;
+ }
+}
+
+void handle_Main_Enemy_collision(world_t *world, sprite_t *sp1, sprite_t *sp2) {
+
+ if (sprites_collide(sp1, sp2)) {
+
+ int push = 200 + (rand() % (100 * world->Main_car.speed));
+
+ if (world->Main_car.life > 0) {
+ world->Main_car.life--;
+ if (world->Main_car.life <= 0 && world->dead == 0) {
+ world->dead = 1;
+ world->time_mort = time(NULL);
+ }
+
+ if (sp1->position.x <= sp2->position.x) {
+ if (sp1->position.y <= sp2->position.y) {
+ sp2->position.x += push;
+ sp2->position.y += push;
+ } else {
+ sp2->position.x += push;
+ sp2->position.y -= push;
+ }
+ } else {
+ if (sp1->position.y <= sp2->position.y) {
+ sp2->position.x -= push;
+ sp2->position.y += push;
+ } else {
+ sp2->position.x += push;
+ sp2->position.y -= push;
+ }
+ }
+ }
+
+ }
+}
+
+
+void handle_Bullet_Enemy_collision(world_t *world, sprite_t *sp1, sprite_t *sp2) {
+
+ if (sprites_collide(sp1, sp2)) {
+
+ int recul = 100 + (rand() % 100);
+
+ if (sp1->position.x <= sp2->position.x) {
+ if (sp1->position.y <= sp2->position.y) {
+ sp2->position.x += recul;
+ } else {
+ sp2->position.x += recul;
+ }
+ } else {
+ if (sp1->position.y <= sp2->position.y) {
+ sp2->position.x -= recul;
+ } else {
+ sp2->position.x += recul;
+ }
+ }
+
+
+ if (sp2->life > 0) {
+ sp2->life--;
+ int temp = 0;
+ temp = sp2->h;
+ sp2->h = sp2->w;
+ sp2->w = temp;
+ sp2->direction = sp1->direction;
+ if (sp1->direction != 1) {
+ sp2->position.x -= sp2->w;
+ }
+ }
+
+ sp2->count = 0;
+
+
+ sp1->position.x = 100000;
+ sp1->position.y = 100000;
+ }
+}
+
+
diff --git a/V4 - version final/colision.h b/V4 - version final/colision.h
new file mode 100755
index 0000000000000000000000000000000000000000..daafbaa05d3e6c24dabab8f81917d7a3be2c330f
--- /dev/null
+++ b/V4 - version final/colision.h
@@ -0,0 +1,22 @@
+/**
+ * \file collision.h
+ * \brief Gestion des collisions du jeu
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#ifndef V1_COLISION_H
+#define V1_COLISION_H
+
+#include "data.h"
+#include "logic.h"
+
+void handle_Main_Enemy_collision(world_t *world, sprite_t *sp1, sprite_t *sp2);
+
+void handle_Bullet_Enemy_collision(world_t *world, sprite_t *sp1, sprite_t *sp2);
+
+void handle_Main_Barrage_collision(sprite_t *sp1, sprite_t *sp2, world_t *world, resources_t *textures,
+ SDL_Renderer *renderer);
+
+
+#endif //V1_COLISION_H
diff --git a/V4 - version final/colision.o b/V4 - version final/colision.o
new file mode 100644
index 0000000000000000000000000000000000000000..3beee060e12a631e751ac9c9ed4dfa6853b82b42
Binary files /dev/null and b/V4 - version final/colision.o differ
diff --git a/V4 - version final/constants.h b/V4 - version final/constants.h
new file mode 100755
index 0000000000000000000000000000000000000000..d9d1853113c37b121b664cdabaa5c86d3cc47dc6
--- /dev/null
+++ b/V4 - version final/constants.h
@@ -0,0 +1,66 @@
+/**
+ * \file const.h
+ * \brief Rassemblement des constantes utiles au jeu
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <time.h>
+#include <math.h>
+#include <string.h>
+
+
+#include "fonctions_SDL.h"
+
+
+#ifndef V1_CONSTANTS_H
+#define V1_CONSTANTS_H
+
+
+#define SCREEN_WIDTH 840
+
+#define SCREEN_HEIGHT 650
+
+#define RICK_STEP 50
+
+#define SPEED_LIIMIT 10
+
+#define NUMBER_ENEMY_CAR 5
+
+#define NUMBER_LIFES 10
+
+#define NUMBER_BARRAGE 50
+
+#define NUMBER_ROADS 100
+
+
+struct resources_s {
+
+ SDL_Texture *main_car;
+
+ SDL_Texture *enemy_car;
+
+ SDL_Texture *barrage;
+
+ SDL_Texture *road;
+
+ SDL_Texture *bullet;
+
+ SDL_Texture *menu;
+
+ SDL_Texture *exit_button;
+
+ SDL_Texture *new_game_button;
+
+ SDL_Texture *settings_button;
+
+ TTF_Font *font;
+};
+typedef struct resources_s resources_t;
+
+#endif
diff --git a/V4 - version final/data.c b/V4 - version final/data.c
new file mode 100755
index 0000000000000000000000000000000000000000..260ac84f03ee6764ad462c37264eafc498537377
--- /dev/null
+++ b/V4 - version final/data.c
@@ -0,0 +1,469 @@
+/**
+ * \file data.c
+ * \brief Gestion des données du jeu
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#include "data.h"
+#include "graphics.h"
+#include "liste.h"
+#include "logic.h"
+#include "colision.h"
+#include <stdio.h>
+
+
+void init_sprite_ptr(sprite_t *sprite, int x, int y, int w, int h, int v, int life, nature_t nat) {
+ sprite->direction = 0;
+ sprite->dir_texture = 3;
+ sprite->count = 0;
+ sprite->position.y = y;
+ sprite->h = h;
+ sprite->w = w;
+ sprite->disappear = 0;
+ sprite->speed = v;
+ sprite->life = life;
+ sprite->nature = nat;
+ sprite->position.x = x;
+}
+
+
+sprite_t init_sprite(sprite_t sprite, int x, int y, int w, int h, int v, int life, nature_t nat) {
+ sprite.dir_texture = 3;
+ sprite.count = 0;
+ sprite.h = h;
+ sprite.w = w;
+ sprite.disappear = 0;
+ sprite.speed = v;
+ sprite.life = life;
+ sprite.nature = nat;
+ sprite.position.x = x;
+ sprite.position.y = y;
+ sprite.direction = 0;
+ return sprite;
+}
+
+
+void init_data(world_t *world) {
+
+ srand(time(NULL));
+ world->mouse = init_sprite(world->mouse, (SCREEN_WIDTH) / 2, (SCREEN_HEIGHT) / 2, 1, 1, 1, 1, Menu);
+
+ world->Enemy_car = l_vide();
+ world->Barrage = l_vide();
+ world->Road = l_vide();
+ world->bullet = l_vide();
+ world->gameover = 0;
+ world->nb_bullets = 0;
+ world->stop_menu = 0;
+ world->dead = 0;
+
+
+ world->Menu = init_sprite(world->Menu, (SCREEN_WIDTH) / 2,
+ (SCREEN_HEIGHT) / 2,
+ SCREEN_WIDTH,
+ SCREEN_HEIGHT,
+ 1, 1, Menu);
+
+
+ world->new_game_menu = init_sprite(world->new_game_menu, 150, 100,
+ 200,
+ 100,
+ 1, 1, Menu);
+
+ world->settings_menu = init_sprite(world->settings_menu, 400,
+ 100,
+ 200,
+ 100,
+ 1, 1, Menu);
+
+ world->exit_menu = init_sprite(world->exit_menu, 650,
+ 100,
+ 200,
+ 100,
+ 1, 1, Menu);
+
+
+ init_sprite_ptr(&world->Main_car, SCREEN_WIDTH / 2, 3 * SCREEN_HEIGHT / 4, 45, 100, 0, 10, Main_car);
+
+
+ for (int i = 0; i < NUMBER_ROADS; i++) {
+
+ int x = SCREEN_WIDTH / 2;
+ int y = ((i + 2) * 650) - (650 * NUMBER_ROADS);
+
+ sprite_t temp_sprite;
+ temp_sprite = init_sprite(temp_sprite, x, y, 840, 650, 1, 1, Road);
+ world->Road = ajouter(world->Road, temp_sprite);
+ }
+
+
+ for (int i = 0; i < NUMBER_ENEMY_CAR; i++) {
+
+ int x = i * 20;
+ int y = 1500;
+
+ sprite_t temp_sprite;
+ temp_sprite = init_sprite(temp_sprite, x, y, 45, 100, 7, 4, Enemy_car);
+ world->Enemy_car = ajouter(world->Enemy_car, temp_sprite);
+ }
+
+
+ for (int i = 0; i < NUMBER_BARRAGE; i++) {
+
+ int x = rand() % (SCREEN_WIDTH - 110);
+ int y = -500 - (rand() % NUMBER_ROADS * 650);
+
+ sprite_t temp_sprite;
+ temp_sprite = init_sprite(temp_sprite, x, y, 210, 109, 1, 1, Barrage);
+ world->Barrage = ajouter(world->Barrage, temp_sprite);
+ }
+
+
+}
+
+
+void init_game(SDL_Window **window, SDL_Renderer **renderer, resources_t *textures, world_t *world) {
+ init_ttf();
+ init_sdl(window, renderer, SCREEN_WIDTH, SCREEN_HEIGHT);
+ init_data(world);
+ init_textures(*renderer, textures, world);
+
+}
+
+
+void update_menu(world_t *world, resources_t *textures, SDL_Renderer *renderer) {
+
+}
+
+
+void update_data(world_t *world, resources_t *textures, SDL_Renderer *renderer) {
+ move_enemy_car(world, textures, renderer);
+ move_bullets(world, textures, renderer);
+ move_all_except_rick(world, renderer, textures);
+
+
+ list_t temp_Barrage = world->Barrage;
+ while (temp_Barrage != NULL) {
+ handle_Main_Barrage_collision(&world->Main_car, &temp_Barrage->val, world, textures, renderer);
+ temp_Barrage = temp_Barrage->nxt;
+ }
+
+ if (SDL_GetTicks() % 10000 > 9990) {
+
+ }
+ if (world->dead == 1 && (time(NULL) - world->time_mort > 5)) {
+ world->gameover = 1;
+ }
+}
+
+
+int is_game_over(world_t *world) {
+ return world->gameover;
+}
+
+
+void move_all_except_rick(world_t *world, SDL_Renderer *renderer, resources_t *textures) {
+ if (world->Main_car.life > 0) {
+ list_t temp_enemy_car = world->Enemy_car;
+ list_t temp_barrage = world->Barrage;
+ list_t temp_road = world->Road;
+ list_t temp_bullet = world->bullet;
+ sprite_t temp_main_car = world->Main_car;
+ int d = world->Main_car.direction;
+
+
+ if (d == 0) {
+ temp_main_car.position.y -= RICK_STEP;
+ } else if (d == 1) {
+ temp_main_car.position.x += RICK_STEP;
+ } else if (d == 2) {
+ temp_main_car.position.y += RICK_STEP;
+ } else if (d == 3) {
+ temp_main_car.position.x -= RICK_STEP;
+ }
+
+
+ switch (d) {
+ case 0:
+ temp_enemy_car = world->Enemy_car;
+ while (temp_enemy_car != NULL) {
+ temp_enemy_car->val.position.y += world->Main_car.speed;
+ if (temp_enemy_car->val.life != 0 && (distance(temp_enemy_car->val, world->Main_car) < 400)) {
+ handle_Main_Enemy_collision(world, &world->Main_car, &temp_enemy_car->val);
+ }
+ temp_enemy_car = temp_enemy_car->nxt;
+ }
+ temp_barrage = world->Barrage;
+ while (temp_barrage != NULL) {
+ temp_barrage->val.position.y += world->Main_car.speed;
+ temp_barrage = temp_barrage->nxt;
+ }
+ temp_road = world->Road;
+ while (temp_road != NULL) {
+ temp_road->val.position.y += world->Main_car.speed;
+ temp_road = temp_road->nxt;
+ }
+ temp_bullet = world->bullet;
+ while (temp_bullet != NULL) {
+ temp_bullet->val.position.y += world->Main_car.speed;
+ temp_bullet = temp_bullet->nxt;
+ }
+ break;
+ case 1:
+ temp_enemy_car = world->Enemy_car;
+ while (temp_enemy_car != NULL) {
+ temp_enemy_car->val.position.x -= world->Main_car.speed;
+ if (temp_enemy_car->val.life != 0 && (distance(temp_enemy_car->val, world->Main_car) < 400)) {
+ handle_Main_Enemy_collision(world, &world->Main_car, &temp_enemy_car->val);
+ }
+ temp_enemy_car = temp_enemy_car->nxt;
+ }
+ temp_barrage = world->Barrage;
+ while (temp_barrage != NULL) {
+ temp_barrage->val.position.x -= world->Main_car.speed;
+ temp_barrage = temp_barrage->nxt;
+ }
+ temp_road = world->Road;
+ while (temp_road != NULL) {
+ temp_road->val.position.x -= world->Main_car.speed;
+ temp_road = temp_road->nxt;
+ }
+ temp_bullet = world->bullet;
+ while (temp_bullet != NULL) {
+ temp_bullet->val.position.x -= world->Main_car.speed;
+ temp_bullet = temp_bullet->nxt;
+ }
+ break;
+ case 2:
+ temp_enemy_car = world->Enemy_car;
+ while (temp_enemy_car != NULL) {
+ temp_enemy_car->val.position.y -= world->Main_car.speed;
+ if (temp_enemy_car->val.life != 0 && (distance(temp_enemy_car->val, world->Main_car) < 400)) {
+ handle_Main_Enemy_collision(world, &world->Main_car, &temp_enemy_car->val);
+ }
+ temp_enemy_car = temp_enemy_car->nxt;
+ }
+ temp_barrage = world->Barrage;
+ while (temp_barrage != NULL) {
+ temp_barrage->val.position.y -= world->Main_car.speed;
+ temp_barrage = temp_barrage->nxt;
+ }
+ temp_road = world->Road;
+ while (temp_road != NULL) {
+ temp_road->val.position.y -= world->Main_car.speed;
+ temp_road = temp_road->nxt;
+ }
+ temp_bullet = world->bullet;
+ while (temp_bullet != NULL) {
+ temp_bullet->val.position.y -= world->Main_car.speed;
+ temp_bullet = temp_bullet->nxt;
+ }
+ break;
+ case 3:
+ temp_enemy_car = world->Enemy_car;
+ while (temp_enemy_car != NULL) {
+ temp_enemy_car->val.position.x += world->Main_car.speed;
+ if (temp_enemy_car->val.life != 0 && (distance(temp_enemy_car->val, world->Main_car) < 400)) {
+ handle_Main_Enemy_collision(world, &world->Main_car, &temp_enemy_car->val);
+ }
+ temp_enemy_car = temp_enemy_car->nxt;
+ }
+ temp_barrage = world->Barrage;
+ while (temp_barrage != NULL) {
+ temp_barrage->val.position.x += world->Main_car.speed;
+ temp_barrage = temp_barrage->nxt;
+ }
+ temp_road = world->Road;
+ while (temp_road != NULL) {
+ temp_road->val.position.x += world->Main_car.speed;
+ temp_road = temp_road->nxt;
+ }
+ temp_bullet = world->bullet;
+ while (temp_bullet != NULL) {
+ temp_bullet->val.position.x += world->Main_car.speed;
+ temp_bullet = temp_bullet->nxt;
+ }
+ break;
+ }
+
+ }
+}
+
+
+void move_enemy_car(world_t *world, resources_t *textures, SDL_Renderer *renderer) {
+ list_t temp_enemy_car = world->Enemy_car;
+ while (temp_enemy_car != NULL) {
+ if (temp_enemy_car->val.life != 0 && world->Main_car.life > 0) {
+ move_enemy_to_main(temp_enemy_car, world, textures, renderer);
+ handle_Main_Enemy_collision(world, &world->Main_car, &temp_enemy_car->val);
+ }
+ temp_enemy_car = temp_enemy_car->nxt;
+ }
+}
+
+
+void move_enemy_to_main(list_t enemy_car, world_t *world, resources_t *textures, SDL_Renderer *renderer) {
+ if (enemy_car->val.position.x < world->Main_car.position.x) {
+ if (enemy_car->val.position.y < world->Main_car.position.y) {
+ if (enemy_car->val.direction != 1) {
+ enemy_car->val.direction = 1;
+ } else {
+ enemy_car->val.position.x += enemy_car->val.speed;
+ enemy_car->val.position.y += enemy_car->val.speed;
+ }
+ } else if (enemy_car->val.position.y > world->Main_car.position.y) {
+ if (enemy_car->val.direction != 1) {
+ enemy_car->val.direction = 1;
+ } else {
+ enemy_car->val.position.x += enemy_car->val.speed;
+ enemy_car->val.position.y -= enemy_car->val.speed;
+ }
+ } else if (enemy_car->val.position.y == world->Main_car.position.y) {
+ if (enemy_car->val.direction != 1) {
+ enemy_car->val.direction = 1;
+ } else {
+ enemy_car->val.position.x += enemy_car->val.speed;
+ }
+ }
+ } else if (enemy_car->val.position.x > world->Main_car.position.x) {
+ if (enemy_car->val.position.y < world->Main_car.position.y) {
+ if (enemy_car->val.direction != 3) {
+ enemy_car->val.direction = 3;
+ } else {
+ enemy_car->val.position.x -= enemy_car->val.speed;
+ enemy_car->val.position.y += enemy_car->val.speed;
+ }
+ } else if (enemy_car->val.position.y > world->Main_car.position.y) {
+ if (enemy_car->val.direction != 3) {
+ enemy_car->val.direction = 3;
+ } else {
+ enemy_car->val.position.x -= enemy_car->val.speed;
+ enemy_car->val.position.y -= enemy_car->val.speed;
+ }
+
+ } else if (enemy_car->val.position.y == world->Main_car.position.y) {
+ if (enemy_car->val.direction != 3) {
+ enemy_car->val.direction = 3;
+ } else {
+ enemy_car->val.position.x -= enemy_car->val.speed;
+ }
+ }
+ } else if (enemy_car->val.position.x == world->Main_car.position.x) {
+ if (enemy_car->val.position.y < world->Main_car.position.y) {
+ enemy_car->val.position.y += enemy_car->val.speed;
+ } else if (enemy_car->val.position.y > world->Main_car.position.y) {
+ enemy_car->val.position.y -= enemy_car->val.speed;
+ }
+ }
+}
+
+
+void move_sprite_randomly(list_t sprite, resources_t *textures, SDL_Renderer *renderer) {
+ int count_max = (rand() % 50) + 50;
+ if (sprite->val.count < count_max) {
+ switch (sprite->val.direction) {
+ case 0:
+ sprite->val.position.y -= sprite->val.speed;
+ sprite->val.count++;
+ break;
+ case 1:
+ sprite->val.position.x += sprite->val.speed;
+ sprite->val.count++;
+ break;
+ case 2:
+ sprite->val.position.y += sprite->val.speed;
+ sprite->val.count++;
+ break;
+ case 3:
+ sprite->val.position.x -= sprite->val.speed;
+ sprite->val.count++;
+ break;
+
+ }
+ } else {
+ sprite->val.count = 0;
+ sprite->val.direction = (rand() % (4));
+ switch (sprite->val.direction) {
+ case 0:
+ sprite->val.position.y -= sprite->val.speed;
+ sprite->val.count++;
+ break;
+ case 1:
+ sprite->val.position.x += sprite->val.speed;
+ sprite->val.count++;
+ break;
+ case 2:
+ sprite->val.position.y += sprite->val.speed;
+ sprite->val.count++;
+ break;
+ case 3:
+ sprite->val.position.x -= sprite->val.speed;
+ sprite->val.count++;
+ break;
+
+ }
+ }
+}
+
+
+void clean_data(world_t *world) {
+ for (int i = 0; i < NUMBER_ENEMY_CAR - 1; i++) {
+ supprimerElementEnFin(world->Enemy_car);
+ }
+ for (int i = 0; i < NUMBER_BARRAGE - 1; i++) {
+ supprimerElementEnFin(world->Barrage);
+ }
+ for (int i = 0; i < NUMBER_ROADS - 1; i++) {
+ supprimerElementEnFin(world->Road);
+ }
+}
+
+
+void move_bullets(world_t *world, resources_t *textures, SDL_Renderer *renderer) {
+ list_t temp_bullet = world->bullet;
+ while (temp_bullet != NULL) {
+ if (distance(temp_bullet->val, world->Main_car) < 3 * SCREEN_HEIGHT) {
+ if (temp_bullet->val.direction == 3) {
+ temp_bullet->val.position.x -= temp_bullet->val.speed;
+ list_t temp_enemy_car = world->Enemy_car;
+ while (temp_enemy_car != NULL) {
+ if (temp_enemy_car->val.life != 0) {
+ handle_Bullet_Enemy_collision(world, &temp_bullet->val, &temp_enemy_car->val);
+ }
+ temp_enemy_car = temp_enemy_car->nxt;
+ }
+ } else if (temp_bullet->val.direction == 1) {
+ temp_bullet->val.position.x += temp_bullet->val.speed;
+ list_t temp = world->Enemy_car;
+ while (temp != NULL) {
+ if (temp->val.life != 0) {
+ handle_Bullet_Enemy_collision(world, &temp_bullet->val, &temp->val);
+ }
+ temp = temp->nxt;
+ }
+ } else if (temp_bullet->val.direction == 2) {
+ temp_bullet->val.position.y += temp_bullet->val.speed;
+ list_t temp_enemy_car = world->Enemy_car;
+ while (temp_enemy_car != NULL) {
+ if (temp_enemy_car->val.life != 0) {
+ handle_Bullet_Enemy_collision(world, &temp_bullet->val, &temp_enemy_car->val);
+ }
+ temp_enemy_car = temp_enemy_car->nxt;
+ }
+ } else if (temp_bullet->val.direction == 0) {
+ temp_bullet->val.position.y -= temp_bullet->val.speed;
+ list_t temp_enemy_car = world->Enemy_car;
+ while (temp_enemy_car != NULL) {
+ if (temp_enemy_car->val.life != 0) {
+ handle_Bullet_Enemy_collision(world, &temp_bullet->val, &temp_enemy_car->val);
+ }
+ temp_enemy_car = temp_enemy_car->nxt;
+ }
+ }
+ }
+
+ temp_bullet = temp_bullet->nxt;
+
+ }
+}
diff --git a/V4 - version final/data.h b/V4 - version final/data.h
new file mode 100755
index 0000000000000000000000000000000000000000..2bb467ba14a3d7227b02725a2c41592f7da649ae
--- /dev/null
+++ b/V4 - version final/data.h
@@ -0,0 +1,103 @@
+/**
+ * \file data.h
+ * \brief Gestion des données du jeu
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#ifndef V1_DATA_H
+#define V1_DATA_H
+
+#include "constants.h"
+
+
+
+struct position_s {
+ int x;
+ int y;
+};
+typedef struct position_s position_t;
+
+typedef enum {
+ Main_car, Enemy_car, Road, Bullet, Car, Barrage, Barre, Menu
+} nature_t;
+
+struct sprite_s {
+ position_t position;
+ int h;
+ int w;
+ int disappear;
+ int direction;
+ int dir_texture;
+ int count;
+ int speed;
+ int life;
+ nature_t nature;
+};
+typedef struct sprite_s sprite_t;
+
+
+typedef struct element element;
+struct element {
+ sprite_t val;
+ struct element *nxt;
+};
+
+typedef element *list_t;
+
+
+struct world_s {
+ sprite_t Menu;
+ sprite_t new_game_menu;
+ sprite_t settings_menu;
+ sprite_t exit_menu;
+ sprite_t Main_car;
+ list_t Barrage;
+ int gameover; /*!< Champ indiquant si l'on est à la fin du jeu */
+ list_t Enemy_car;
+ list_t Road;
+ list_t bullet;
+ int nb_bullets;
+ bool stop_menu;
+ sprite_t mouse;
+ int time_debut_jeu;
+ int time_mort;
+ int dead;
+};
+typedef struct world_s world_t;
+
+
+void init_game(SDL_Window **window, SDL_Renderer **renderer, resources_t *textures, world_t *world);
+
+void init_sprite_ptr(sprite_t *sprite, int x, int y, int w, int h, int v, int life, nature_t nature);
+
+sprite_t init_sprite(sprite_t sprite, int x, int y, int w, int h, int v, int life, nature_t nature);
+
+void init_data(world_t *world);
+
+void update_menu(world_t *world, resources_t *textures, SDL_Renderer *renderer);
+
+void update_data(world_t *world, resources_t *textures, SDL_Renderer *renderer);
+
+int is_game_over(world_t *world);
+
+int sprites_collide(sprite_t *sp1, sprite_t *sp2);
+
+void move_all_except_rick(world_t *world, SDL_Renderer *renderer, resources_t *textures);
+
+void move_enemy_car(world_t *world, resources_t *textures, SDL_Renderer *renderer);
+
+void move_sprite_randomly(list_t enemy_car, resources_t *textures, SDL_Renderer *renderer);
+
+void move_enemy_to_main(list_t enemy_car, world_t *world, resources_t *textures, SDL_Renderer *renderer);
+
+double distance(sprite_t s1, sprite_t s2);
+
+void clean_data(world_t *world);
+
+void move_bullets(world_t *world, resources_t *textures, SDL_Renderer *renderer);
+
+void handle_Bullet_Zombie_collision(world_t *world, sprite_t *sp1, sprite_t *sp2);
+
+
+#endif //V1_DATA_H
diff --git a/V4 - version final/data.o b/V4 - version final/data.o
new file mode 100644
index 0000000000000000000000000000000000000000..4032398754b76c5b77139b4b72f73cf732c78c4d
Binary files /dev/null and b/V4 - version final/data.o differ
diff --git a/V4 - version final/events.c b/V4 - version final/events.c
new file mode 100755
index 0000000000000000000000000000000000000000..6c33e00b7ef39da0d624e67815bb1cc8349ba4ed
--- /dev/null
+++ b/V4 - version final/events.c
@@ -0,0 +1,95 @@
+/**
+ * \file events.c
+ * \brief Gestion des entrées claviers du joueur
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#include "events.h"
+#include "constants.h"
+#include "data.h"
+#include "colision.h"
+#include "liste.h"
+
+
+void handle_events(SDL_Event *event, SDL_Renderer *renderer, world_t *world, resources_t *textures) {
+
+ while (SDL_PollEvent(event)) {
+
+ if (world->stop_menu == 0) {
+ if (event->type == SDL_MOUSEMOTION) {
+ world->mouse.position.x = event->button.x;
+ world->mouse.position.y = event->button.y;
+ }
+ if (event->type == SDL_MOUSEBUTTONDOWN) {
+ if (sprites_collide(&world->mouse, &world->new_game_menu)) {
+ world->stop_menu = 1;
+ }
+ }
+ if (event->type == SDL_MOUSEBUTTONDOWN) {
+ if (sprites_collide(&world->mouse, &world->exit_menu)) {
+ world->gameover = 1;
+ }
+ }
+ } else if (world->Main_car.life > 0 && world->dead != 1) {
+ if (event->type == SDL_MOUSEBUTTONDOWN) {
+ if (event->button.button == SDL_BUTTON_LEFT) {
+ sprite_t temp_sprite;
+ int x, y;
+ int direction;
+ if (world->Main_car.dir_texture == 3) {
+ x = world->Main_car.position.x - world->Main_car.w;
+ y = world->Main_car.position.y + 0.07 * world->Main_car.h;
+ direction = 3;
+ } else if (world->Main_car.dir_texture == 1) {
+ x = world->Main_car.position.x + world->Main_car.w;
+ y = world->Main_car.position.y + 0.07 * world->Main_car.h;
+ direction = 1;
+ } else if (world->Main_car.dir_texture == 2) {
+ x = world->Main_car.position.x + 20;
+ y = world->Main_car.position.y + 30;
+ direction = 2;
+ } else if (world->Main_car.dir_texture == 0) {
+ x = world->Main_car.position.x;
+ y = world->Main_car.position.y - 100;
+ direction = 0;
+ }
+
+ temp_sprite = init_sprite(temp_sprite, x, y, 16, 16, 50, 1, Bullet);
+ temp_sprite.direction = direction;
+ world->nb_bullets++;
+ world->bullet = ajouter(world->bullet, temp_sprite);
+ }
+
+ }
+
+ if (event->type == SDL_KEYDOWN) {
+ if (event->key.keysym.sym == SDLK_UP) {
+ world->Main_car.direction = 0;
+ world->Main_car.dir_texture = 0;
+ world->Main_car.direction = 0;
+ if (world->Main_car.speed < SPEED_LIIMIT) {
+ world->Main_car.speed++;
+ }
+ } else if (event->key.keysym.sym == SDLK_RIGHT) {
+ world->Main_car.direction = 0;
+ if (world->Main_car.position.x < SCREEN_WIDTH - world->Main_car.w) {
+ world->Main_car.position.x += 15;
+ }
+ } else if (event->key.keysym.sym == SDLK_DOWN) {
+
+ if (world->Main_car.speed > 0) {
+ world->Main_car.speed--;
+ }
+ } else if (event->key.keysym.sym == SDLK_LEFT) {
+ world->Main_car.direction = 0;
+ if (world->Main_car.position.x > world->Main_car.w) {
+ world->Main_car.position.x -= 15;
+ }
+ } else if (event->key.keysym.sym == SDLK_ESCAPE) {
+ world->stop_menu = 0;
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/V4 - version final/events.h b/V4 - version final/events.h
new file mode 100755
index 0000000000000000000000000000000000000000..3b856cf368ea81ec095ceb0c9a6154d11900e12c
--- /dev/null
+++ b/V4 - version final/events.h
@@ -0,0 +1,17 @@
+/**
+ * \file event.h
+ * \brief Gestion des entrées claviers du joueur
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#ifndef V1_EVENTS_H
+#define V1_EVENTS_H
+
+#include <SDL2/SDL_mixer.h>
+#include "constants.h"
+#include "data.h"
+
+void handle_events(SDL_Event *event, SDL_Renderer *renderer, world_t *world, resources_t *textures);
+
+#endif //V1_EVENTS_H
diff --git a/V4 - version final/events.o b/V4 - version final/events.o
new file mode 100644
index 0000000000000000000000000000000000000000..a8a289784aa69a7199f07806695c7bec34eec028
Binary files /dev/null and b/V4 - version final/events.o differ
diff --git a/V4 - version final/fastcar b/V4 - version final/fastcar
new file mode 100755
index 0000000000000000000000000000000000000000..841963cc27744312ee2d5f6e891a93d014752bbe
Binary files /dev/null and b/V4 - version final/fastcar differ
diff --git a/V4 - version final/fonctions_SDL.c b/V4 - version final/fonctions_SDL.c
new file mode 100755
index 0000000000000000000000000000000000000000..3cce92c1b96a4ed1c737334c05306cf236efd7d7
--- /dev/null
+++ b/V4 - version final/fonctions_SDL.c
@@ -0,0 +1,123 @@
+/**
+ * \file fonctions_SDL.c
+ * \brief sur-couche de SDL2 pour simplifier son utilisation pour le projet
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#include "fonctions_SDL.h"
+
+int init_sdl(SDL_Window **window, SDL_Renderer **renderer, int width, int height)
+{
+ if(0 != SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO))
+ {
+ fprintf(stderr, "Erreur initialisation de la SDL : %s", SDL_GetError());
+ return -1;
+ }
+ if(0 != SDL_CreateWindowAndRenderer(width, height, SDL_WINDOW_SHOWN, window, renderer))
+ {
+ fprintf(stderr, "Erreur lors de la creation de l'image et du renderer : %s", SDL_GetError());
+ return -1;
+ }
+ return 0;
+}
+
+SDL_Texture* charger_image(const char* nomfichier, SDL_Renderer* renderer)
+{
+
+ SDL_Surface* surface = SDL_LoadBMP(nomfichier);
+
+ return SDL_CreateTextureFromSurface(renderer, surface);
+}
+
+SDL_Texture* charger_image_transparente(const char path[], SDL_Renderer *renderer)
+{
+ SDL_Surface *temp = NULL;
+ SDL_Texture *texture = NULL;
+ temp = SDL_LoadBMP(path);
+
+ if(NULL == temp)
+ {
+ fprintf(stderr, "Erreur pendant chargement image BMP: %s", SDL_GetError());
+ return NULL;
+ }
+ SDL_SetColorKey(temp, SDL_TRUE, SDL_MapRGB(temp->format, 255, 0, 255));
+ texture = SDL_CreateTextureFromSurface(renderer, temp);
+ SDL_FreeSurface(temp);
+ if(NULL == texture)
+ {
+ fprintf(stderr, "Erreur pendant creation de la texture liee a l'image chargee: %s", SDL_GetError());
+ return NULL;
+ }
+ return texture;
+}
+
+
+void clear_renderer(SDL_Renderer *renderer){
+ SDL_RenderClear(renderer);
+}
+
+void apply_texture(SDL_Texture *texture,SDL_Renderer *renderer,int x, int y){
+ SDL_Rect dst = {0, 0, 0, 0};
+
+ SDL_QueryTexture(texture, NULL, NULL, &dst.w, &dst.h);
+ dst.x = x; dst.y = y;
+
+ SDL_RenderCopy(renderer, texture, NULL, &dst);
+}
+
+void update_screen(SDL_Renderer *renderer){
+ SDL_RenderPresent(renderer);
+}
+
+void clean_texture(SDL_Texture *texture){
+ if(NULL != texture){
+ SDL_DestroyTexture(texture);
+ }
+}
+
+void clean_sdl(SDL_Renderer *renderer,SDL_Window *window){
+ if(NULL != renderer)
+ SDL_DestroyRenderer(renderer);
+ if(NULL != window)
+ SDL_DestroyWindow(window);
+ SDL_Quit();
+}
+
+void init_audio(){
+ SDL_Init(SDL_INIT_AUDIO);
+}
+
+
+void init_ttf(){
+ if(TTF_Init()==-1) {
+ printf("TTF_Init: %s\n", TTF_GetError());
+ }
+}
+
+TTF_Font * load_font(const char *path, int font_size){
+ TTF_Font *font = TTF_OpenFont(path, font_size);
+ if(font == NULL){
+ fprintf(stderr, "Erreur pendant chargement font: %s\n", SDL_GetError());
+ }
+ return font;
+}
+
+void apply_text(SDL_Renderer *renderer,int x, int y, int w, int h, const char *text, TTF_Font *font, SDL_Color color){
+
+ SDL_Surface* surface = TTF_RenderText_Solid(font, text, color);
+ SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
+ SDL_Rect dstrect2 = {x, y, w, h};
+ SDL_RenderCopy(renderer, texture, NULL, &dstrect2);
+ SDL_FreeSurface(surface);
+ clean_texture(texture);
+
+}
+
+void clean_font(TTF_Font * font){
+ TTF_CloseFont(font);
+}
+
+
+
+
diff --git a/V4 - version final/fonctions_SDL.h b/V4 - version final/fonctions_SDL.h
new file mode 100755
index 0000000000000000000000000000000000000000..53afc8365fa25c40435372ffd8435060aa7bad9a
--- /dev/null
+++ b/V4 - version final/fonctions_SDL.h
@@ -0,0 +1,40 @@
+/**
+ * \file fonctions_SDL.h
+ * \brief en-tête du module correspondant à une sur-couche de SDL2 pour simplifier son utilisation pour le projet
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+#include <SDL2/SDL_mixer.h>
+#include <SDL2/SDL2_rotozoom.h>
+#include <stdio.h>
+
+int init_sdl(SDL_Window **window, SDL_Renderer **renderer, int width, int height);
+
+SDL_Texture* charger_image(const char* nomfichier, SDL_Renderer* renderer);
+
+SDL_Texture* charger_image_transparente(const char path[], SDL_Renderer *renderer);
+
+void clear_renderer(SDL_Renderer *renderer);
+
+void apply_texture(SDL_Texture *texture,SDL_Renderer *renderer,int x, int y);
+
+void update_screen(SDL_Renderer *renderer);
+
+void clean_texture(SDL_Texture *texture);
+
+void clean_sdl(SDL_Renderer *renderer,SDL_Window *window);
+
+void init_ttf();
+
+TTF_Font * load_font(const char *path, int font_size);
+
+void apply_text(SDL_Renderer *renderer,int x, int y, int w, int h, const char *text, TTF_Font *font, SDL_Color color);
+
+void clean_font(TTF_Font * font);
+
+void init_audio();
+
+
diff --git a/V4 - version final/fonctions_SDL.o b/V4 - version final/fonctions_SDL.o
new file mode 100644
index 0000000000000000000000000000000000000000..b5905e2e1ecb2340bb41926489aa52ef0bb45ea4
Binary files /dev/null and b/V4 - version final/fonctions_SDL.o differ
diff --git a/V4 - version final/font/arial.ttf b/V4 - version final/font/arial.ttf
new file mode 100755
index 0000000000000000000000000000000000000000..ab68fb197d4479b3b6dec6e85bd5cbaf433a87c5
Binary files /dev/null and b/V4 - version final/font/arial.ttf differ
diff --git a/V4 - version final/graphics.c b/V4 - version final/graphics.c
new file mode 100755
index 0000000000000000000000000000000000000000..5eca0868fd53da0e2578a2fc83aa301640006958
--- /dev/null
+++ b/V4 - version final/graphics.c
@@ -0,0 +1,155 @@
+/**
+ * \file graphics.c
+ * \brief Gestion de l'affichage du jeu
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#include "graphics.h"
+
+
+void init_textures(SDL_Renderer *renderer, resources_t *textures, world_t *world) {
+
+ textures->font = load_font("font/arial.ttf", 200);
+
+ textures->main_car = charger_image_transparente("IMG/main_car.bmp", renderer);
+
+ textures->enemy_car = charger_image_transparente("IMG/enemy_car.bmp", renderer);
+
+ textures->barrage = charger_image_transparente("IMG/barrage.bmp", renderer);
+
+ textures->road = charger_image_transparente("IMG/road.bmp", renderer);
+
+ textures->bullet = charger_image_transparente("IMG/bullet.bmp", renderer);
+
+ textures->menu = charger_image_transparente("IMG/menu.bmp", renderer);
+
+ textures->new_game_button = charger_image_transparente("IMG/boutton.bmp", renderer);
+
+ textures->settings_button = charger_image_transparente("IMG/boutton.bmp", renderer);
+
+ textures->exit_button = charger_image_transparente("IMG/boutton.bmp", renderer);
+
+}
+
+
+void refresh_menu(SDL_Renderer *renderer, world_t *world, resources_t *textures) {
+ clear_renderer(renderer);
+ apply_sprite(renderer, textures->menu, &world->Menu);
+ apply_sprite(renderer, textures->new_game_button, &world->new_game_menu);
+ apply_sprite(renderer, textures->settings_button, &world->settings_menu);
+ apply_sprite(renderer, textures->exit_button, &world->exit_menu);
+ apply_text(renderer, (60), 50, 180, 90, "New Game", textures->font,(SDL_Color){243, 89, 0});
+ apply_text(renderer, (310), 50, 180, 90, "Settings", textures->font,(SDL_Color){243, 89, 0});
+ apply_text(renderer, (560), 50, 180, 90, "Exit", textures->font,(SDL_Color){243, 89, 0});
+
+ apply_text(renderer, (SCREEN_WIDTH-610), 200, 400, 14*4, "Bienvenue", textures->font,(SDL_Color){243, 89, 0});
+ apply_text(renderer, (SCREEN_WIDTH-620), 340, 400, 14*4, "Appuyer sur ", textures->font,(SDL_Color){243, 89, 0});
+ apply_text(renderer, (SCREEN_WIDTH-620), 410, 400, 14*4, "'NEW GAME'", textures->font,(SDL_Color){240, 248, 255, 0.993});
+ apply_text(renderer, (SCREEN_WIDTH-620), 460, 400, 14*4, "pour commencer", textures->font,(SDL_Color){243, 89, 0});
+ apply_text(renderer, (SCREEN_WIDTH-800), 600, 200, 14*3, "YATIME MAROUANE", textures->font,(SDL_Color){253, 217, 13});
+ apply_text(renderer, (SCREEN_WIDTH-250), 600, 200, 14*3, "AIT OUALI MAROUANE", textures->font,(SDL_Color){253, 217, 13});
+ update_screen(renderer);
+}
+
+void refresh_graphics(SDL_Renderer *renderer, world_t *world, resources_t *textures) {
+
+ clear_renderer(renderer);
+
+ list_t temp_road = world->Road;
+ while (temp_road != NULL) {
+ if (distance(temp_road->val, world->Main_car) < 2 * SCREEN_HEIGHT) {
+ apply_sprite(renderer, textures->road, &temp_road->val);
+ }
+ temp_road = temp_road->nxt;
+ }
+
+ list_t temp_barrage = world->Barrage;
+ while (temp_barrage != NULL) {
+ if (temp_barrage->val.disappear == 0) {
+ if (distance(temp_barrage->val, world->Main_car) < 2 * SCREEN_HEIGHT) {
+ apply_sprite(renderer, textures->barrage, &temp_barrage->val);
+ }
+ }
+ temp_barrage = temp_barrage->nxt;
+ }
+
+
+ list_t temp_enemy = world->Enemy_car;
+
+ while (temp_enemy != NULL) {
+ if (distance(temp_enemy->val, world->Main_car) < 2 * SCREEN_HEIGHT) {
+ if (temp_enemy->val.life >= 0) {
+ apply_sprite(renderer, textures->enemy_car, &temp_enemy->val);
+ }
+ }
+
+ temp_enemy = temp_enemy->nxt;
+ }
+
+ apply_sprite(renderer, textures->main_car, &world->Main_car);
+
+
+ if (world->nb_bullets != 0) {
+ list_t temp_bullet = world->bullet;
+ for (int i = 0; i < world->nb_bullets; i++) {
+ apply_sprite(renderer, textures->bullet, &temp_bullet->val);
+ temp_bullet = temp_bullet->nxt;
+ }
+ }
+
+
+ if (world->Main_car.life == 0) {
+ SDL_Color color = {255, 50, 50};
+ char fin_jeu[20] = "GAME OVER";
+ int W = 800;
+ int H = 200;
+ int X = SCREEN_WIDTH / 2 - W / 2;
+ int Y = SCREEN_HEIGHT / 4;
+ apply_text(renderer, X, Y, W, H, fin_jeu, textures->font, color);
+ }
+
+
+ update_screen(renderer);
+}
+
+void apply_sprite(SDL_Renderer *renderer, SDL_Texture *texture, sprite_t *sprite) {
+ if (texture != NULL) {
+ apply_texture(texture, renderer,
+ (sprite->position.x) - ((sprite->w) / 2),
+ (sprite->position.y) - ((sprite->h) / 2)
+ );
+ }
+}
+
+
+void clean(SDL_Window *window, SDL_Renderer *renderer, resources_t *textures, world_t *world) {
+ clean_data(world);
+ clean_textures(textures);
+ clean_sdl(renderer, window);
+ TTF_Quit();
+}
+
+void clean_textures(resources_t *textures) {
+
+ clean_texture(textures->main_car);
+
+ clean_texture(textures->enemy_car);
+
+ clean_texture(textures->barrage);
+
+ clean_texture(textures->road);
+
+ clean_texture(textures->bullet);
+
+ clean_texture(textures->menu);
+
+ clean_texture(textures->new_game_button);
+
+ clean_texture(textures->settings_button);
+
+ clean_texture(textures->exit_button);
+
+ clean_font(textures->font);
+
+}
\ No newline at end of file
diff --git a/V4 - version final/graphics.h b/V4 - version final/graphics.h
new file mode 100755
index 0000000000000000000000000000000000000000..06577aa3cb2fe2d20f68392941c1c7a7756b3d91
--- /dev/null
+++ b/V4 - version final/graphics.h
@@ -0,0 +1,32 @@
+/**
+ * \file graphics.h
+ * \brief Gestion de l'affichage du jeu
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#ifndef V1_GRAPHICS_H
+#define V1_GRAPHICS_H
+
+
+#include "constants.h"
+#include "data.h"
+#include "liste.h"
+#include "fonctions_SDL.h"
+
+
+
+void init_textures(SDL_Renderer *renderer, resources_t *textures, world_t *world);
+
+void refresh_menu(SDL_Renderer *renderer, world_t *world, resources_t *textures);
+
+void refresh_graphics(SDL_Renderer *renderer, world_t *world, resources_t *textures);
+
+void apply_sprite(SDL_Renderer *renderer, SDL_Texture *texture, sprite_t *sprite);
+
+void clean(SDL_Window *window, SDL_Renderer *renderer, resources_t *textures, world_t *world);
+
+void clean_textures(resources_t *textures);
+
+
+#endif //V1_GRAPHICS_H
diff --git a/V4 - version final/graphics.o b/V4 - version final/graphics.o
new file mode 100644
index 0000000000000000000000000000000000000000..e08c7cb8cca3e4a7e06233498fe4cdf7692c0341
Binary files /dev/null and b/V4 - version final/graphics.o differ
diff --git a/V4 - version final/liste.c b/V4 - version final/liste.c
new file mode 100755
index 0000000000000000000000000000000000000000..5e7e640c399ec670e79eb2e25fec145407fe6f0f
--- /dev/null
+++ b/V4 - version final/liste.c
@@ -0,0 +1,76 @@
+/**
+ * \file liste.c
+ * \brief Gestion des listes
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#include "liste.h"
+
+
+
+list_t ajouter(list_t liste, sprite_t valeur) {
+ element *nouvelElement = malloc(sizeof(element));
+ nouvelElement->val = valeur;
+ nouvelElement->nxt = NULL;
+ if (liste == NULL) {
+ return nouvelElement;
+ } else {
+ element *temp = liste;
+ while (temp->nxt != NULL) {
+ temp = temp->nxt;
+ }
+ temp->nxt = nouvelElement;
+ return liste;
+ }
+}
+
+bool estVide(list_t liste) {
+ return (liste == NULL) ? 1 : 0;
+}
+
+list_t supprimerElementEnTete(list_t liste) {
+ if (liste != NULL) {
+ element *aRenvoyer = liste->nxt;
+ free(liste);
+ return aRenvoyer;
+ } else {
+ return NULL;
+ }
+}
+
+list_t supprimerElementEnFin(list_t liste) {
+ if (liste == NULL)
+ return NULL;
+
+ if (liste->nxt == NULL) {
+ free(liste);
+ return NULL;
+ }
+
+ element *tmp = liste;
+ element *ptmp = liste;
+ while (tmp->nxt != NULL) {
+ ptmp = tmp;
+ tmp = tmp->nxt;
+ }
+
+ ptmp->nxt = NULL;
+ free(tmp);
+ return liste;
+}
+
+
+list_t l_vide() {
+ return NULL;
+}
+
+int tailleListe(list_t liste) {
+ list_t liste_temp = liste;
+ int i = 0;
+ while (liste_temp != NULL) {
+ i++;
+ liste_temp = liste_temp->nxt;
+ }
+ return i;
+}
\ No newline at end of file
diff --git a/V4 - version final/liste.h b/V4 - version final/liste.h
new file mode 100755
index 0000000000000000000000000000000000000000..352263a436f3556bda084c4c9302269518d4e20f
--- /dev/null
+++ b/V4 - version final/liste.h
@@ -0,0 +1,27 @@
+/**
+ * \file liste.h
+ * \brief Gestion des listes
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#ifndef V1_LISTE_H
+#define V1_LISTE_H
+
+
+#include "constants.h"
+#include "data.h"
+
+list_t ajouter(list_t liste, sprite_t valeur);
+
+bool estVide(list_t liste);
+
+list_t supprimerElementEnTete(list_t liste);
+
+list_t supprimerElementEnFin(list_t liste);
+
+list_t l_vide();
+
+int tailleListe(list_t liste);
+
+#endif //V1_LISTE_H
diff --git a/V4 - version final/liste.o b/V4 - version final/liste.o
new file mode 100644
index 0000000000000000000000000000000000000000..0dfd738a2ce095461ca5a5401449ffdc2cfa9c16
Binary files /dev/null and b/V4 - version final/liste.o differ
diff --git a/V4 - version final/logic.c b/V4 - version final/logic.c
new file mode 100755
index 0000000000000000000000000000000000000000..7749b1074a0376ab84a36920140a85befeb3863a
--- /dev/null
+++ b/V4 - version final/logic.c
@@ -0,0 +1,40 @@
+/**
+ * \file logic.c
+ * \brief Gestion de la logique du jeu (physique)
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#include "logic.h"
+
+
+double distance(sprite_t s1, sprite_t s2) {
+ double s1x = s1.position.x;
+ double s1y = s1.position.y;
+ double s2x = s2.position.x;
+ double s2y = s2.position.y;
+ return (sqrt(pow(s1x - s2x, 2) + pow(s1y - s2y, 2)));
+}
+
+int sprites_collide(sprite_t *sp1, sprite_t *sp2) {
+
+ int gauche1, gauche2, droite1, droite2, haut1, haut2, bas1, bas2;
+
+
+ haut1 = sp1->position.y - (sp1->h) / 2;
+ bas1 = sp1->position.y + (sp1->h) / 2;
+ haut2 = sp2->position.y - (sp2->h) / 2;
+ bas2 = sp2->position.y + (sp2->h) / 2;
+ gauche1 = sp1->position.x - (sp1->w) / 2;
+ droite1 = sp1->position.x + (sp1->w) / 2;
+ gauche2 = sp2->position.x - (sp2->w) / 2;
+ droite2 = sp2->position.x + (sp2->w) / 2;
+
+
+ if (bas1 <= haut2 || haut1 >= bas2 || droite1 <= gauche2 || gauche1 >= droite2) {
+ return false;
+ } else {
+ return true;
+ }
+}
+
diff --git a/V4 - version final/logic.h b/V4 - version final/logic.h
new file mode 100755
index 0000000000000000000000000000000000000000..5a6b07f70aa8b7d105514dac2c76f3b32d9753d5
--- /dev/null
+++ b/V4 - version final/logic.h
@@ -0,0 +1,18 @@
+/**
+ * \file logic.h
+ * \brief Gestion de la logique du jeu (physique)
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#ifndef V1_LOGIC_H
+#define V1_LOGIC_H
+
+#include "data.h"
+
+double distance(sprite_t s1, sprite_t s2);
+
+int sprites_collide(sprite_t* sp1, sprite_t* sp2);
+
+
+#endif //V1_LOGIC_H
diff --git a/V4 - version final/logic.o b/V4 - version final/logic.o
new file mode 100644
index 0000000000000000000000000000000000000000..aa2bae5ed195f6b416498a56f2431f2b78868cca
Binary files /dev/null and b/V4 - version final/logic.o differ
diff --git a/V4 - version final/main b/V4 - version final/main
new file mode 100755
index 0000000000000000000000000000000000000000..f404b91729641c3dc1e3fe907f064f6b0387751c
Binary files /dev/null and b/V4 - version final/main differ
diff --git a/V4 - version final/main.c b/V4 - version final/main.c
new file mode 100755
index 0000000000000000000000000000000000000000..ee85d56fa9cdb8cf5c8528c891fa448a903f04ec
--- /dev/null
+++ b/V4 - version final/main.c
@@ -0,0 +1,45 @@
+/**
+ * \file main.c
+ * \brief Boucle de jeu
+ * \author YATIME Marouane - AIT OUALI Marouane
+ * \date 27 decembre 2021
+ */
+
+#include "constants.h"
+#include "data.h"
+#include "graphics.h"
+#include "events.h"
+
+int main() {
+
+ SDL_Event event;
+ world_t world;
+ resources_t textures;
+ SDL_Renderer *renderer;
+ SDL_Window *fenetre;
+
+ time_t t;
+ srand((unsigned) time(&t));
+ world.time_debut_jeu = t;
+
+ init_game(&fenetre, &renderer, &textures, &world);
+
+ while (!is_game_over(&world)) {
+ if (world.stop_menu == 0) {
+ handle_events(&event, renderer, &world, &textures);
+ update_menu(&world, &textures, renderer);
+ refresh_menu(renderer, &world, &textures);
+ } else {
+ refresh_graphics(renderer, &world, &textures);
+ update_data(&world, &textures, renderer);
+ handle_events(&event, renderer, &world, &textures);
+ }
+ SDL_Delay(4);
+ }
+
+
+ clean(fenetre, renderer, &textures, &world);
+
+ SDL_Quit();
+ return 0;
+}
diff --git a/V4 - version final/main.o b/V4 - version final/main.o
new file mode 100644
index 0000000000000000000000000000000000000000..9af21e848fea2b6c821e04b70c835baba47d42ef
Binary files /dev/null and b/V4 - version final/main.o differ