Update

.envrc

@@ -0,0 +1 @@
+use flake

.gitignore

@@ -1,3 +1,5 @@
 my_radar
 .idea
 .vscode
+.direnv
+*.o

Makefile

@@ -5,31 +5,56 @@
 ## Makefile to build project
 ##
 
-NAME    =       my_radar
+NAME	=	my_radar
+
+LIB	=	libmy.a
+
+LIB_DIR =	lib/my
 
 SRCS = src/main.c \
-       src/utils/print_usages.c
+       src/main2.c \
+       src/map.c \
+       src/simulation.c \
+       src/script.c \
+       src/events.c \
+       src/simulation2.c \
+       src/file_handling.c \
+       src/aircraft.c \
+       src/collision.c \
+       src/init_graphics.c \
+       src/control_tower.c \
+       src/window.c
+
+OBJS	=	$(SRCS:.c=.o)
+
+LIB_SRCS = $(wildcard $(LIB_DIR)/*.c)
+
+LIB_OBJS = $(LIB_SRCS:.c=.o)
 
 CC = gcc
 
-CFLAGS = -Iinclude -Llib/my -lmy -l csfml-graphics -l csfml-system -l csfml-window
+CFLAGS = -lasan -Iinclude
 
-all:  $(NAME)
+LDFLAGS = -L$(LIB_DIR) -lmy -lcsfml-graphics -lcsfml-window -lcsfml-system -lm 
 
-$(NAME):
-	cd lib/my && make
-	$(CC) $(SRCS) -o $(NAME) $(CFLAGS)
+all: $(LIB) $(NAME)
+
+$(LIB): $(LIB_OBJS)
+	ar rc $(LIB_DIR)/$(LIB) $(LIB_OBJS)
+	rm -f $(LIB_OBJS)
+
+$(NAME): $(OBJS)
+	$(CC) $(OBJS) -o $(NAME) $(LDFLAGS)
+
+%.o: %.c
+	$(CC) -c $< -o $@ $(CFLAGS)
 
 clean:
 	$(RM) *.o
 	$(RM) $(OBJS)
 
-fclean: clean
-	cd lib/my && make fclean
+fclean:	clean
+	$(RM) $(LIB_DIR)/$(LIB)
 	$(RM) $(NAME)
 
-re:     fclean all
-
-asan: fclean
-	cd lib/my && make
-	$(CC) $(SRCS) -o $(NAME) -lasan -g3 $(CFLAGS)
+re: fclean all

flake.lock

@@ -0,0 +1,82 @@
+{
+  "nodes": {
+    "epiflake": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1712528066,
+        "narHash": "sha256-JGHzUhdMitSxrS2fQ4Zts9YWrcykpMXm5IjSW0cPcNM=",
+        "owner": "Savapitech",
+        "repo": "EpiFlake",
+        "rev": "39ba7f99f449519e65381aaf6a738a11aa31104e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "Savapitech",
+        "repo": "EpiFlake",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1710146030,
+        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1712439257,
+        "narHash": "sha256-aSpiNepFOMk9932HOax0XwNxbA38GOUVOiXfUVPOrck=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "ff0dbd94265ac470dda06a657d5fe49de93b4599",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "epiflake": "epiflake",
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,27 @@
+{
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+    epiflake = {
+      url = "github:Savapitech/EpiFlake";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, epiflake, nixpkgs, flake-utils }:
+    flake-utils.lib.eachSystem [ "x86_64-linux" ] (system:
+      let
+        pkgs = nixpkgs.legacyPackages.${system};
+      in
+      rec {
+        formatter = pkgs.nixpkgs-fmt;
+
+        devShells.default = pkgs.mkShell {
+          hardeningDisable = [ "all" ];
+          packages = with (epiflake.lib.ShellPkgs pkgs);
+            base ++ debug;
+        };
+      });
+}

include/CSFML.h

@@ -0,0 +1,17 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** csfml.h
+*/
+
+#ifndef CSFML_H
+    #define CSFML_H
+    #include <SFML/Graphics.h>
+
+typedef struct {
+    sfRenderWindow* window;
+    sfSprite* map;
+} csfml;
+
+#endif

include/ControlTower.h

@@ -0,0 +1,22 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** ControlTower.h
+*/
+
+#ifndef CONTROLTOWER_H
+    #define CONTROLTOWER_H
+
+    #include <SFML/Graphics.h>
+
+typedef struct {
+    sfVector2f pos;
+    sfSprite* sprite;
+    int radius;
+} ControlTower;
+void process_tower_line(char *line);
+int is_in_control_area(int i);
+float babylonian_sqrt(float number);
+
+#endif

include/aircraft.h

@@ -0,0 +1,25 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** aircraft.h
+*/
+
+#ifndef AIRCRAFT_H
+    #define AIRCRAFT_H
+
+    #include <SFML/Graphics.h>
+
+typedef struct {
+    sfVector2f pos;
+    sfVector2f dest;
+    sfVector2f direction;
+    sfSprite* sprite;
+    int speed;
+    int delay;
+} Aircraft;
+void configure_aircraft_sprite(Aircraft *aircraft);
+void process_aircraft_line(char *line);
+void destroy_aircraft(int i);
+
+#endif

include/collision.h

@@ -0,0 +1,27 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** collision.h
+*/
+
+#ifndef COLLISION_H
+    #define COLLISION_H
+
+    #include <SFML/Graphics.h>
+    #include "simulation.h"
+    #include "map.h"
+    #include "init_CSFML.h"
+    #include "script.h"
+    #include "../lib/my/lib.h"
+    #include "ControlTower.h"
+    #include "aircraft.h"
+
+void handle_aircraft_collision(int i, int j);
+void handle_aircraft_landing(int i, float deltaTime);
+void draw_hitbox(csfml *csfml, int i);
+void destroy_aircraft(int i);
+int is_in_control_area(int i);
+void destroy_aircraft(int i);
+
+#endif

include/events.h

@@ -0,0 +1,24 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** events.h
+*/
+
+
+#ifndef EVENTS_H
+    #define EVENTS_H
+
+    #include <SFML/Graphics.h>
+    #include "simulation.h"
+    #include "map.h"
+    #include "init_CSFML.h"
+    #include "script.h"
+    #include "ControlTower.h"
+    #include "aircraft.h"
+
+void handle_window_events_simulation(csfml *csfml, int *should_close);
+float babylonian_sqrt(float num);
+
+
+#endif

include/init_CSFML.h

@@ -0,0 +1,21 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** init_csfml.h
+*/
+
+#ifndef INIT_csfml_H
+    #define INIT_csfml_H
+
+    #include <SFML/Graphics.h>
+    #include "CSFML.h"
+
+csfml* create_csfml(void);
+sfRenderWindow* create_window(void);
+sfSprite* load_map_sprite(char *map_filepath, sfRenderWindow* window);
+void set_map_scale(sfSprite* map, sfRenderWindow* window);
+void set_window_framerate(sfRenderWindow* window);
+csfml* init_csfml(char *map_filepath);
+
+#endif

include/map.h

@@ -0,0 +1,17 @@
+/*
+** EPITECH PROJECT, 2023
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** map.h
+*/
+
+#ifndef MAP_H
+    #define MAP_H
+
+    #include <SFML/Graphics.h>
+
+sfSprite* load_map(char *map_filepath);
+void unload_map(sfSprite* map);
+void draw_map(sfRenderWindow* window, sfSprite* map);
+
+#endif

include/my.h

@@ -0,0 +1,18 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-savinien.petitjean
+** File description:
+** my.h
+*/
+
+#ifndef MY_H_
+    #define MY_H_
+    #include "../lib/my/lib.h"
+    #include "CSFML.h"
+
+int check_args(int, char *argv[]);
+void run_csfml(csfml *, sfText *, int *);
+void print_usage(void);
+void initialize_and_run_simulation(csfml *, sfText *, int *, int);
+void handle_window_events(sfEvent, csfml **, int *, int);
+#endif //MY_H_

include/script.h

@@ -0,0 +1,27 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** script.h
+*/
+
+#ifndef SCRIPT_H
+    #define SCRIPT_H
+
+    #include <SFML/Graphics.h>
+    #include "simulation.h"
+    #include "aircraft.h"
+    #include "ControlTower.h"
+    #include "init_CSFML.h"
+
+extern Aircraft* aircrafts;
+extern ControlTower* towers;
+extern int num_aircrafts;
+extern int num_towers;
+extern int num_landed_aircrafts;
+extern int num_destroyed_aircrafts;
+
+void handle_event(sfEvent event, csfml **csfml, int *should_close);
+int read_script(char *filepath);
+
+#endif

include/simulation.h

@@ -0,0 +1,29 @@
+/*
+** EPITECH PROJECT, 2023
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** simulation.h
+*/
+
+#ifndef SIMULATION_H
+    #define SIMULATION_H
+
+    #include <SFML/Graphics.h>
+    #include "script.h"
+    #include "CSFML.h"
+
+typedef struct {
+    csfml* csfml;
+    sfText* timerText;
+    int* should_close;
+    float deltaTime;
+    float elapsed_time;
+} SimulationData;
+int init_simulation(char *script_filepath);
+void init_run_sim(csfml *csfml, sfText* timerText, int *should_close);
+void run_simulation(csfml* csfml, sfText *timerText, int *should_close);
+void run_simulation_loop(SimulationData simData, csfml *csfml);
+void check_end_simulation(csfml *csfml);
+void end_simulation(csfml *csfml, sfSprite*);
+
+#endif

include/window.h

@@ -0,0 +1,28 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet (V4 marche pas)
+** File description:
+** window.h
+*/
+
+#ifndef WINDOW_H
+    #define WINDOW_H
+
+    #include <SFML/Graphics.h>
+    #include "simulation.h"
+    #include "map.h"
+    #include "init_CSFML.h"
+    #include "script.h"
+    #include "ControlTower.h"
+    #include "aircraft.h"
+
+void draw_aircraft(csfml *csfml, int i);
+void update_and_draw_aircrafts(csfml *csfml, float deltaTime);
+void draw_towers(csfml *csfml);
+void update_and_draw(SimulationData simData);
+void draw_aircraft_hitbox(csfml *csfml, int i);
+void handle_aircraft_interactions(int i, float deltaTime);
+void draw_tower_radius(csfml* csfml, int i);
+void update_timer(sfRenderWindow *window, sfText *timerText, float elapsed_time);
+
+#endif

lib/my/Makefile

@@ -20,6 +20,7 @@ SRCS = my_compute_power_rec.c \
        my_put_octal.c \
        my_putchar.c \
        my_putstr.c \
+       my_puterr.c \
        my_revstr.c \
        my_show_word_array.c \
        my_strcat.c \
@@ -32,7 +33,6 @@ SRCS = my_compute_power_rec.c \
        my_swap.c \
 	   my_printf.c \
 	   my_format.c \
-	   my_error.c \
 	   my_strpop.c
 
 

lib/my/lib.h

@@ -21,7 +21,6 @@ int my_put_unsigned_nbr(unsigned int);
 int my_put_hexa(int);
 int my_put_address(int);
 int my_put_hexa_upper(int);
-void my_error(char *);
 int my_put_octal(int);
 int my_swap(int *, int *);
 int my_put_float(float);
@@ -29,6 +28,7 @@ int my_put_float_upper(float);
 void my_put_float2(int *, int, int, int);
 void my_put_float2_upper(int *, int, int, int);
 int my_putstr(char const *);
+int my_puterr(char const *);
 int my_strlen(char const *);
 int my_getnbr(char const *);
 int my_sort_int_array(int *, int);

lib/my/my_puterr.c

@@ -0,0 +1,20 @@
+/*
+** EPITECH PROJECT, 2023
+** CPoolDay07
+** File description:
+** ./my_putstr.c
+*/
+
+#include "lib.h"
+
+int my_puterr(char const *str)
+{
+    int count;
+
+    count = 0;
+    for (int i = 0; str[i] != '\0'; i++) {
+        my_putchar(str[i]);
+        count++;
+    }
+    return (count);
+}

lib/my/my_putstr.c

@@ -9,8 +9,9 @@
 
 int my_putstr(char const *str)
 {
-    int count = 0;
+    int count;
 
+    count = 0;
     for (int i = 0; str[i] != '\0'; i++) {
         my_putchar(str[i]);
         count++;

src/aircraft.c

@@ -0,0 +1,73 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** aircraft.c
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <SFML/Graphics.h>
+#include "../include/simulation.h"
+#include <math.h>
+#include "../include/my.h"
+
+void configure_aircraft_sprite(Aircraft *aircraft)
+{
+    sfTexture* texture;
+    sfVector2u spriteSize;
+
+    aircraft->sprite = sfSprite_create();
+    texture = sfTexture_createFromFile("resources/img/plane.png", NULL);
+    sfSprite_setTexture(aircraft->sprite, texture, sfTrue);
+    spriteSize = sfTexture_getSize(texture);
+    sfSprite_setOrigin(aircraft->sprite,
+    (sfVector2f){spriteSize.x / 2, spriteSize.y / 2});
+    sfSprite_setScale(aircraft->sprite, (sfVector2f){0.10, 0.10});
+}
+
+void calculate_aircraft_direction(Aircraft *aircraft)
+{
+    sfVector2f diff;
+    float length;
+
+    diff = (sfVector2f){aircraft->dest.x - aircraft->pos.x,
+    aircraft->dest.y - aircraft->pos.y};
+    length = sqrt(diff.x * diff.x + diff.y * diff.y);
+    aircraft->direction = (sfVector2f){diff.x / length, diff.y / length};
+    aircraft->speed *= 10;
+}
+
+void process_aircraft_line(char *line)
+{
+    Aircraft* new_aircrafts;
+
+    new_aircrafts = malloc((num_aircrafts + 1) * sizeof(Aircraft));
+    if (aircrafts != NULL) {
+        memcpy(new_aircrafts, aircrafts, num_aircrafts * sizeof(Aircraft));
+        (aircrafts);
+    }
+    aircrafts = new_aircrafts;
+    sscanf(line, "A %f %f %f %f %d %d", &aircrafts[num_aircrafts].pos.x,
+    &aircrafts[num_aircrafts].pos.y,
+    &aircrafts[num_aircrafts].dest.x, &aircrafts[num_aircrafts].dest.y,
+    &aircrafts[num_aircrafts].speed, &aircrafts[num_aircrafts].delay);
+    configure_aircraft_sprite(&aircrafts[num_aircrafts]);
+    calculate_aircraft_direction(&aircrafts[num_aircrafts]);
+    num_aircrafts++;
+}
+
+void draw_aircraft_hitbox(csfml *csfml, int i)
+{
+    sfRectangleShape* hitbox = sfRectangleShape_create();
+    sfVector2f hitboxPos = {aircrafts[i].pos.x - 10, aircrafts[i].pos.y - 10};
+
+    sfRectangleShape_setPosition(hitbox, hitboxPos);
+    sfRectangleShape_setSize(hitbox, (sfVector2f){20, 20});
+    sfRectangleShape_setOutlineColor(hitbox, sfRed);
+    sfRectangleShape_setOutlineThickness(hitbox, 1.0);
+    sfRectangleShape_setFillColor(hitbox, sfTransparent);
+    sfRenderWindow_drawRectangleShape(csfml->window, hitbox, NULL);
+    sfRectangleShape_destroy(hitbox);
+}

src/collision.c

@@ -0,0 +1,80 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** collision.c
+*/
+
+#include <string.h>
+#include <SFML/Graphics.h>
+#include "../include/simulation.h"
+#include <math.h>
+#include "../include/events.h"
+#include "../include/my.h"
+
+void handle_aircraft_collision(int i, int j)
+{
+    if (!is_in_control_area(i) && !is_in_control_area(j)) {
+        /*my_printf(
+        "Collision detected between aircraft %d and %d\n", i, j);*/
+        if (i < j) {
+            destroy_aircraft(i);
+            destroy_aircraft(j - 1);
+        } else {
+            destroy_aircraft(j);
+            destroy_aircraft(i - 1);
+        }
+        //my_printf("Nombre d'avions après collision : %d\n", num_aircrafts);
+    }
+}
+
+void handle_aircraft_landing(int i, float deltaTime)
+{
+    float distance;
+
+    distance = babylonian_sqrt(pow(aircrafts[i].pos.x
+    - aircrafts[i].dest.x, 2) +
+    pow(aircrafts[i].pos.y - aircrafts[i].dest.y, 2));
+    if (distance <= aircrafts[i].speed * deltaTime) {
+        sfSprite_destroy(aircrafts[i].sprite);
+        aircrafts[i].sprite = NULL;
+        for (int j = i; j < num_aircrafts - 1; j++)
+            aircrafts[j] = aircrafts[j + 1];
+        num_aircrafts--;
+        num_landed_aircrafts++;
+        //my_printf("Nombre d'avions après atterrissage : %d\n", num_aircrafts);
+    } else {
+        aircrafts[i].pos.x += aircrafts[i].direction.x *
+        aircrafts[i].speed * deltaTime;
+        aircrafts[i].pos.y += aircrafts[i].direction.y *
+        aircrafts[i].speed * deltaTime;
+    }
+}
+
+void draw_hitbox(csfml *csfml, int i)
+{
+    sfRectangleShape* hitbox = sfRectangleShape_create();
+    sfVector2f hitboxPos = {
+        aircrafts[i].pos.x - 10,
+        aircrafts[i].pos.y - 10
+    };
+
+    sfRectangleShape_setPosition(hitbox, hitboxPos);
+    sfRectangleShape_setSize(hitbox, (sfVector2f){20, 20});
+    sfRectangleShape_setOutlineColor(hitbox, sfRed);
+    sfRectangleShape_setOutlineThickness(hitbox, 1.0);
+    sfRectangleShape_setFillColor(hitbox, sfTransparent);
+    sfRenderWindow_drawRectangleShape(csfml->window, hitbox, NULL);
+    sfRectangleShape_destroy(hitbox);
+}
+
+void destroy_aircraft(int i)
+{
+    sfSprite_destroy(aircrafts[i].sprite);
+    aircrafts[i].sprite = NULL;
+    for (int j = i; j < num_aircrafts - 1; j++) {
+        aircrafts[j] = aircrafts[j + 1];
+    }
+    num_aircrafts--;
+    num_destroyed_aircrafts++;
+}

src/control_tower.c

@@ -0,0 +1,70 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** control_tower.c
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <SFML/Graphics.h>
+#include "../include/simulation.h"
+#include "../include/my.h"
+
+
+void process_tower_line(char *line)
+{
+    sfTexture* texture;
+    ControlTower* new_towers;
+
+    new_towers = malloc((num_towers + 1) * sizeof(ControlTower));
+    if (towers != NULL) {
+        memcpy(new_towers, towers, num_towers * sizeof(ControlTower));
+        (towers);
+    }
+    towers = new_towers;
+    sscanf(line, "T %f %f %d", &towers[num_towers].pos.x,
+    &towers[num_towers].pos.y, &towers[num_towers].radius);
+    towers[num_towers].sprite = sfSprite_create();
+    texture = sfTexture_createFromFile("resources/img/tower.png", NULL);
+    sfSprite_setTexture(towers[num_towers].sprite, texture, sfTrue);
+    sfSprite_setScale(towers[num_towers].sprite, (sfVector2f){0.10, 0.10});
+    sfSprite_setPosition(towers[num_towers].sprite,(sfVector2f){towers[num_towers].pos.x - 25.6, towers[num_towers].pos.y - 25.6});
+    num_towers++;
+}
+
+int is_in_control_area(int i)
+{
+    int k;
+    float dx;
+    float dy;
+    float distance;
+
+    for (k = 0; k < num_towers; k++) {
+        dx = towers[k].pos.x - aircrafts[i].pos.x;
+        dy = towers[k].pos.y - aircrafts[i].pos.y;
+        distance = babylonian_sqrt(dx * dx + dy * dy);
+        if (distance <= towers[k].radius) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+void draw_tower_radius(csfml* csfml, int i)
+{
+    sfCircleShape* radius = sfCircleShape_create();
+    sfVector2f circlePos = {
+        towers[i].pos.x - towers[i].radius,
+        towers[i].pos.y - towers[i].radius
+    };
+
+    sfCircleShape_setPosition(radius, circlePos);
+    sfCircleShape_setRadius(radius, towers[i].radius);
+    sfCircleShape_setOutlineColor(radius, sfBlue);
+    sfCircleShape_setOutlineThickness(radius, 1.0);
+    sfCircleShape_setFillColor(radius, sfTransparent);
+    sfRenderWindow_drawCircleShape(csfml->window, radius, NULL);
+    sfCircleShape_destroy(radius);
+}

src/events.c

@@ -0,0 +1,31 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** events.c
+*/
+
+#include <stdlib.h>
+#include <SFML/Graphics.h>
+#include "../include/simulation.h"
+#include "../include/events.h"
+#include "../include/my.h"
+
+void handle_window_events_simulation(csfml *csfml, int *should_close)
+{
+    sfEvent event;
+
+    while (sfRenderWindow_pollEvent(csfml->window, &event))
+        handle_event(event, &csfml, should_close);
+}
+
+float babylonian_sqrt(float num)
+{
+    const float epsilon = 0.00001;
+    float guess = num / 2.0;
+
+    while (abs(guess * guess - num) >= epsilon) {
+        guess = (guess + num / guess) / 2.0;
+    }
+    return guess;
+}

src/file_handling.c

@@ -0,0 +1,40 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** file_handling.c
+*/
+
+#include <stdio.h>
+#include "../include/simulation.h"
+#include "../include/my.h"
+
+void process_script_line(char *line)
+{
+    if (line[0] == 'A') {
+        process_aircraft_line(line);
+    } else if (line[0] == 'T') {
+        process_tower_line(line);
+    }
+}
+
+int read_script(char *filepath)
+{
+    FILE *file = fopen(filepath, "r");
+    char line[256];
+
+    if (!file) {
+        my_printf("Failed to open the script file: %s\n", filepath);
+        return 84;
+    }
+    while (fgets(line, sizeof(line), file)) {
+        process_script_line(line);
+    }
+    if (ferror(file)) {
+        my_printf("Error reading the script file: %s\n", filepath);
+        fclose(file);
+        return 84;
+    }
+    fclose(file);
+    return 0;
+}

src/init_graphics.c

@@ -0,0 +1,78 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-savinien.petitjean
+** File description:
+** init_csfml.c
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <SFML/Graphics.h>
+#include "../include/map.h"
+#include "init_CSFML.h"
+#include "../include/my.h"
+
+csfml* create_csfml(void)
+{
+    csfml* csfml = malloc(sizeof(csfml));
+
+    if (!csfml) {
+        my_printf("Failed to allocate memory for csfml\n");
+    }
+    return csfml;
+}
+
+sfRenderWindow* create_window(void)
+{
+    sfVideoMode mode = {1920, 1080, 32};
+    sfRenderWindow* window = sfRenderWindow_create(mode,
+        "Air Traffic Simulation", sfResize | sfClose, NULL);
+
+    return window;
+}
+
+sfSprite* load_map_sprite(char *map_filepath, sfRenderWindow* window)
+{
+    sfSprite* map = load_map(map_filepath);
+
+    if (!map) {
+        sfRenderWindow_destroy(window);
+    }
+    return map;
+}
+
+void set_map_scale(sfSprite* map, sfRenderWindow* window)
+{
+    sfVector2u windowSize = sfRenderWindow_getSize(window);
+    sfFloatRect mapBounds = sfSprite_getLocalBounds(map);
+    sfSprite_setScale(map, (sfVector2f){windowSize.x /
+    mapBounds.width, windowSize.y / mapBounds.height});
+}
+
+void set_window_framerate(sfRenderWindow* window)
+{
+    sfRenderWindow_setFramerateLimit(window, 60);
+}
+
+csfml* init_csfml(char *map_filepath)
+{
+    csfml* csfml = create_csfml();
+
+    if (!csfml) {
+        return NULL;
+    }
+    csfml->window = create_window();
+    if (!csfml->window) {
+        (csfml);
+        return NULL;
+    }
+    csfml->map = load_map_sprite(map_filepath, csfml->window);
+    if (!csfml->map) {
+        sfRenderWindow_destroy(csfml->window);
+        (csfml);
+        return NULL;
+    }
+    set_map_scale(csfml->map, csfml->window);
+    set_window_framerate(csfml->window);
+    return csfml;
+}

src/main.c

@@ -1,69 +1,111 @@
 /*
 ** EPITECH PROJECT, 2023
-** B-MUL-100-REN-1-1-myradar-savinien.petitjean
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
 ** File description:
 ** main.c
 */
 
-#include "../include/radar.h"
-#include <SFML/Audio.h>
-#include <SFML/Graphics.h>
 #include <stdlib.h>
+#include <string.h>
+#include <SFML/Graphics.h>
+#include "../include/simulation.h"
+#include "../include/map.h"
+#include "../include/init_CSFML.h"
+#include "../include/my.h"
 
-int main(int ac, char **av)
+int show_hitboxes = 0;
+
+void print_usage(void)
 {
+    my_printf("Air traffic simulation panel\n");
+    my_printf("USAGE\n");
+    my_printf("  ./my_radar [OPTIONS] path_to_script\n");
+    my_printf("  path_to_script The path to the script file.\n");
+    my_printf("OPTIONS\n");
+    my_printf("  -h print the usage and quit.\n");
+    my_printf("USER INTERACTIONS\n");
+    my_printf("  ‘L’ key enable/disable hitboxes and a\n");
+}
 
-    sfVideoMode mode = {1920, 1080, 32};
-    sfRenderWindow* window;
-    sfTexture* txt_background;
-    sfSprite* sprt_background;
-    sfTexture* txt_tower;
-    sfSprite* sprt_tower;
-    sfEvent event;
-
-    sfCircleShape* circle = sfCircleShape_create();
-    sfCircleShape_setRadius(circle, 50);
-    sfCircleShape_setOutlineThickness(circle, 2);
-    sfCircleShape_setOutlineColor(circle, sfBlue);
-    sfCircleShape_setFillColor(circle, sfTransparent);
-    sfCircleShape_setPosition(circle, (sfVector2f){960, 540});
-    sfCircleShape_setScale(circle, (sfVector2f){2, 2});
-
-    if (ac == 2 && my_strcmp(av[1], "-h") == 0) {
-        print_usages();
-        return (0);
+void handle_events_main(sfEvent event, csfml **csfml, int *shouldClose)
+{
+    if (!csfml || !*csfml || !(*csfml)->window) {
+        return;
     }
-    window = sfRenderWindow_create(mode, "My Radar", sfResize | sfClose, NULL);
-    if (!window)
-        return EXIT_FAILURE;
-    txt_background = sfTexture_createFromFile("resources/background.png", NULL);
-    if (!txt_background)
-        return EXIT_FAILURE;
-    txt_tower = sfTexture_createFromFile("resources/tower.png", NULL);
-    if (!txt_tower)
-        return EXIT_FAILURE;
-    sprt_background = sfSprite_create();
-    sprt_tower = sfSprite_create();
-    sfSprite_setPosition(sprt_tower, (sfVector2f){960, 540});
-    sfSprite_setScale(sprt_tower, (sfVector2f){0.2, 0.2});
-    sfSprite_setTexture(sprt_background, txt_background, sfTrue);
-    sfSprite_setTexture(sprt_tower, txt_tower, sfTrue);
-    while (sfRenderWindow_isOpen(window))
-    {
-        while (sfRenderWindow_pollEvent(window, &event))
-        {
-            if (event.type == sfEvtClosed)
-                sfRenderWindow_close(window);
-        }
-        sfRenderWindow_clear(window, sfWhite);
-        sfRenderWindow_drawSprite(window, sprt_background, NULL);
-        sfRenderWindow_drawSprite(window, sprt_tower, NULL);
-        sfRenderWindow_drawCircleShape(window, circle, NULL);
-        sfRenderWindow_display(window);
+    if (event.type == sfEvtClosed) {
+        *shouldClose = 1;
     }
-    sfSprite_destroy(sprt_background);
-    sfTexture_destroy(txt_background);
-    sfRenderWindow_destroy(window);
-    sfCircleShape_destroy(circle);
-    return EXIT_SUCCESS;
-}
+    if (event.type == sfEvtKeyPressed && event.key.code == sfKeyL)
+        show_hitboxes = !show_hitboxes;
+}
+
+csfml* initialize_csfml(void)
+{
+    csfml* csfml = init_csfml("resources/img/background.png");
+
+    if (!csfml)
+        my_printf("Failed to initialize csfml\n");
+    return csfml;
+}
+
+int initialize_simulation(char *script_filepath)
+{
+    if (init_simulation(script_filepath) != 0) {
+        my_printf("Failed to initialize simulation\n");
+        return 84;
+    }
+    return 0;
+}
+
+sfText* create_timer_text(void)
+{
+    sfText* timerText = sfText_create();
+    sfFont* font = sfFont_createFromFile("resources/fonts/Roboto-Black.ttf");
+
+    sfText_setPosition(timerText, (sfVector2f){1550, 0});
+    sfText_setColor(timerText, sfBlack);
+    sfText_setCharacterSize(timerText, 72);
+    if (!font) {
+        my_printf("Failed to load font\n");
+        return NULL;
+    }
+    sfText_setFont(timerText, font);
+    return timerText;
+}
+
+void handle_window_events(sfEvent event, csfml **csfml, int *should_close, int show_hitboxes)
+{
+    if (!csfml || !*csfml || !(*csfml)->window)
+        return;
+    if (event.type == sfEvtClosed)
+        *should_close = 1;
+    if (event.type == sfEvtKeyPressed && event.key.code == sfKeyL)
+        show_hitboxes = !show_hitboxes;
+}
+
+int main(int argc, char *argv[])
+{
+    int show_hitboxes = 0;
+    sfText* timer_text = create_timer_text();
+    csfml* csfml = initialize_csfml();
+    int should_close = 0;
+
+    if (check_args(argc, argv) != 1)
+        return 84;
+    if (!csfml)
+        return 84;
+    if (initialize_simulation(argv[1]) != 0) {
+        if (csfml->window)
+            sfRenderWindow_destroy(csfml->window);
+        (csfml);
+        return 84;
+    }
+    if (!timer_text)
+        return 84;
+    if (csfml && csfml->window)
+        initialize_and_run_simulation(csfml, timer_text, &should_close, show_hitboxes);
+    if (timer_text)
+        sfText_destroy(timer_text);
+    (csfml);
+    return 0;
+}

src/main2.c

@@ -0,0 +1,70 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-savinien.petitjean
+** File description:
+** main2
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <SFML/Graphics.h>
+#include "../include/simulation.h"
+#include "../include/map.h"
+#include "../include/init_CSFML.h"
+#include "../include/my.h"
+
+int check_args(int argc, char *argv[])
+{
+    if (argc > 1 && my_strcmp(argv[1], "-h") == 0) {
+        print_usage();
+        return 0;
+    }
+    if (argc < 2) {
+        my_printf("Usage: %s <script_filepath>\n", argv[0]);
+        return 84;
+    }
+    return 1;
+}
+
+void run_csfml(csfml *csfml, sfText *timerText, int *shouldClose)
+{
+    if (csfml && csfml->window) {    
+        while (csfml && csfml->window) {
+            sfRenderWindow_clear(csfml->window, sfBlack);
+            draw_map(csfml->window, csfml->map);
+            run_simulation(csfml, timerText, shouldClose);
+            if (csfml->window == NULL) {
+            break;
+            }
+            if (sfRenderWindow_isOpen(csfml->window)) {
+                sfRenderWindow_display(csfml->window);
+            }
+        }
+    } else {
+        my_printf("csfml or window is null\n");
+        return;
+    }
+}
+
+void initialize_and_run_simulation(csfml *csfml, sfText *timer_text, int *should_close, int show_hitboxes)
+{
+    sfEvent event;
+
+    if (!csfml) {
+        return;
+    }
+    while (csfml && csfml->window && sfRenderWindow_isOpen(csfml->window) && !*should_close) {
+        while (csfml && csfml->window && sfRenderWindow_pollEvent(csfml->window, &event)) {
+            handle_window_events(event, &csfml, should_close, show_hitboxes);
+            if (!csfml || !csfml->window || !sfRenderWindow_isOpen(csfml->window)) {
+                free(csfml);
+                break;
+            }
+        }
+        if (!csfml || !csfml->window || !sfRenderWindow_isOpen(csfml->window) || *should_close) {
+            free(csfml);
+            break;
+        }
+        run_csfml(csfml, timer_text, should_close);
+    }
+}

src/map.c

@@ -0,0 +1,36 @@
+/*
+** EPITECH PROJECT, 2023
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** map.c
+*/
+
+#include <string.h>
+#include <SFML/Graphics.h>
+#include "../include/map.h"
+#include "../include/my.h"
+
+sfSprite* load_map(char *filepath)
+{
+    sfSprite* sprite = sfSprite_create();
+    sfTexture* texture = sfTexture_createFromFile(filepath, NULL);
+
+    if (!texture)
+        return NULL;
+    sfSprite_setTexture(sprite, texture, sfTrue);
+    return sprite;
+}
+
+void draw_map(sfRenderWindow* window, sfSprite* map)
+{
+    if (map != NULL)
+        sfRenderWindow_drawSprite(window, map, NULL);
+}
+
+void unload_map(sfSprite* map)
+{
+    const sfTexture* texture = sfSprite_getTexture(map);
+
+    sfSprite_destroy(map);
+    sfTexture_destroy((sfTexture*)texture);
+}

src/script.c

@@ -0,0 +1,64 @@
+/*
+** EPITECH PROJECT, 2023
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** script.c
+*/
+
+#include <string.h>
+#include <SFML/Graphics.h>
+#include "../include/simulation.h"
+#include "../include/init_CSFML.h"
+#include "../include/script.h"
+#include "../include/ControlTower.h"
+#include "../include/aircraft.h"
+#include "../include/window.h"
+#include "../include/collision.h"
+#include "../include/my.h"
+
+Aircraft* aircrafts;
+ControlTower* towers;
+int num_aircrafts = 0;
+int num_towers = 0;
+int num_landed_aircrafts = 0;
+int num_destroyed_aircrafts = 0;
+extern int show_hitboxes;
+
+void handle_event(sfEvent event, csfml **csfml, int *should_close)
+{
+    if (!csfml || !*csfml || !(*csfml)->window) {
+        return;
+    }
+    if (event.type == sfEvtClosed) {
+        *should_close = 1;
+    }
+    if (event.type == sfEvtKeyPressed && event.key.code == sfKeyL)
+        show_hitboxes = !show_hitboxes;
+}
+
+void update_timer(sfRenderWindow *window,
+    sfText *timerText, float elapsed_time)
+{
+    char timerString[50] = "";
+
+    my_printf(timerString, "Time: %.2f", elapsed_time);
+    sfText_setString(timerText, timerString);
+    sfRenderWindow_drawText(window, timerText, NULL);
+}
+
+void handle_aircraft_interactions(int i, float deltaTime)
+{
+    sfFloatRect hitbox1;
+    sfFloatRect hitbox2;
+    int j;
+
+    hitbox1 = (sfFloatRect){aircrafts[i].pos.x - 10,
+    aircrafts[i].pos.y - 10, 20, 20};
+    for (j = i + 1; j < num_aircrafts; j++) {
+        hitbox2 = (sfFloatRect){aircrafts[j].pos.x - 10,
+        aircrafts[j].pos.y - 10, 20, 20};
+        if (sfFloatRect_intersects(&hitbox1, &hitbox2, NULL))
+            handle_aircraft_collision(i, j);
+    }
+    handle_aircraft_landing(i, deltaTime);
+}

src/simulation.c

@@ -0,0 +1,84 @@
+/*
+** EPITECH PROJECT, 2023
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** simulation.c
+*/
+
+#include <stdlib.h>
+#include <SFML/Graphics.h>
+#include "../include/simulation.h"
+#include "../include/map.h"
+#include "../include/init_CSFML.h"
+#include "../include/script.h"
+#include "../include/ControlTower.h"
+#include "../include/aircraft.h"
+#include "../include/window.h"
+#include "../include/events.h"
+#include "../include/my.h"
+
+extern Aircraft* aircrafts;
+extern ControlTower* towers;
+extern int num_aircrafts;
+extern int num_towers;
+extern int num_landed_aircrafts;
+extern int num_destroyed_aircrafts;
+extern int show_hitboxes;
+float babylonian_sqrt(float num);
+
+int init_simulation(char *script_filepath)
+{
+    if (read_script(script_filepath) != 0) {
+        my_printf( "Failed to read the script file: %s\n",
+        script_filepath);
+        return 84;
+    }
+    return 0;
+}
+
+void init_run_sim(csfml *csfml, sfText* timerText, int *should_close)
+{
+    SimulationData simData;
+
+    simData.csfml = csfml;
+    simData.timerText = timerText;
+    simData.should_close = should_close;
+    run_simulation_loop(simData, csfml);
+}
+
+void run_simulation(csfml* csfml, sfText *timerText, int *should_close)
+{
+    if (!csfml || !csfml->window) {
+        my_printf( "Failed to initialize csfml\n");
+        return;
+    }
+    init_run_sim(csfml, timerText, should_close);
+    if (csfml) {
+        sfText_destroy(timerText);
+        if (csfml->map)
+            unload_map(csfml->map);
+        if (csfml->window)
+            sfRenderWindow_destroy(csfml->window);
+        (csfml);
+    }
+}
+
+void run_simulation_loop(SimulationData simData, csfml *csfml)
+{
+    sfClock* clock = sfClock_create();
+    float deltaTime = 0;
+    float elapsed_time = 0;
+
+    while (simData.csfml && simData.csfml->window &&
+    sfRenderWindow_isOpen(simData.csfml->window)) {
+        handle_window_events_simulation(simData.csfml, simData.should_close);
+        if (*simData.should_close)
+            break;
+        deltaTime = sfTime_asSeconds(sfClock_restart(clock));
+        elapsed_time += deltaTime;
+        simData.deltaTime = deltaTime;
+        simData.elapsed_time = elapsed_time;
+        update_and_draw(simData);
+    }
+    sfClock_destroy(clock);
+}

src/simulation2.c

@@ -0,0 +1,48 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** simulation2.c
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <SFML/Graphics.h>
+#include "../include/simulation.h"
+#include "../include/map.h"
+#include "../include/my.h"
+
+extern Aircraft* aircrafts;
+extern ControlTower* towers;
+extern int num_aircrafts;
+extern int num_towers;
+extern int num_landed_aircrafts;
+extern int num_destroyed_aircrafts;
+extern int show_hitboxes;
+float babylonian_sqrt(float num);
+
+void check_end_simulation(csfml *csfml)
+{
+    if (num_aircrafts == 0) {
+        my_printf("Nombre d'avions atterris : %d\n", num_landed_aircrafts);
+        my_printf("Nombre d'avions détruits : %d\n", num_destroyed_aircrafts);
+        if (csfml && csfml->window && sfRenderWindow_isOpen(csfml->window)) {
+            sfRenderWindow_close(csfml->window);
+        }
+    }
+}
+
+void end_simulation(csfml *csfml, sfSprite*)
+{
+    for (int i = 0; i < num_aircrafts; i++) {
+        sfSprite_destroy(aircrafts[i].sprite);
+        aircrafts[i].sprite = NULL;
+    }
+    (aircrafts);
+    for (int i = 0; i < num_towers; i++) {
+        sfSprite_destroy(towers[i].sprite);
+        towers[i].sprite = NULL;
+    }
+    (towers);
+    unload_map(csfml->map);
+}

src/window.c

@@ -0,0 +1,67 @@
+/*
+** EPITECH PROJECT, 2024
+** B-MUL-100-REN-1-1-myradar-nathan.barbet
+** File description:
+** window.c
+*/
+
+#include <string.h>
+#include <SFML/Graphics.h>
+#include "../include/simulation.h"
+#include "../include/map.h"
+#include <math.h>
+#include "../include/window.h"
+#include "../include/my.h"
+
+extern int show_hitboxes;
+
+void draw_aircraft(csfml *csfml, int i)
+{
+    float angle;
+
+    if (aircrafts[i].sprite != NULL) {
+        sfSprite_setPosition(aircrafts[i].sprite, aircrafts[i].pos);
+        angle = atan2(aircrafts[i].direction.y,
+        aircrafts[i].direction.x) * 180 / M_PI;
+        sfSprite_setRotation(aircrafts[i].sprite, angle);
+        sfRenderWindow_drawSprite(csfml->window, aircrafts[i].sprite, NULL);
+    }
+    if (show_hitboxes) {
+        draw_aircraft_hitbox(csfml, i);
+    }
+}
+
+void update_and_draw_aircrafts(csfml *csfml, float deltaTime)
+{
+    for (int i = 0; i < num_aircrafts; i++) {
+        handle_aircraft_interactions(i, deltaTime);
+        draw_aircraft(csfml, i);
+    }
+}
+
+void draw_towers(csfml *csfml)
+{
+    for (int i = 0; i < num_towers; i++) {
+        if (towers[i].sprite != NULL) {
+            sfRenderWindow_drawSprite(csfml->window, towers[i].sprite, NULL);
+        }
+        if (show_hitboxes) {
+            draw_tower_radius(csfml, i);
+        }
+    }
+}
+
+void update_and_draw(SimulationData simData)
+{
+    sfRenderWindow_clear(simData.csfml->window, sfBlack);
+    draw_map(simData.csfml->window, simData.csfml->map);
+    update_timer(simData.csfml->window, simData.timerText,
+    simData.elapsed_time);
+    update_and_draw_aircrafts(simData.csfml, simData.deltaTime);
+    draw_towers(simData.csfml);
+    check_end_simulation(simData.csfml);
+    if (!simData.csfml || !simData.csfml->window ||
+    !sfRenderWindow_isOpen(simData.csfml->window) || *simData.should_close)
+        return;
+    sfRenderWindow_display(simData.csfml->window);
+}