FiddleComputers

Projet NF05

Dec 21st, 2019 (edited)
110
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <string.h>
  5.  
  6. struct Passenger
  7. {
  8.     struct Flight* flight; //Pointeur vers le vol sur lequel le vol est inscrit
  9.     struct Luggage* luggages[2]; //Tableau contenant les bagages du passager
  10.     char* last_name;
  11.     char* first_name;
  12.     char* nationality;
  13.     int priority; //0 pour non-priotaire, 1 pour prioritaire
  14.     int seat; //Numéro de la place du passager dans l'avion
  15.     int birthday[3]; // [0] = jour, [1] = mois, [2] = année
  16.     int ticket; //Numéro du ticket du passager (généré aléatoirement)
  17.     char* passport; //Numéro de passeport (2 chiffres, 2 lettres, 5 chiffres)
  18.     int etape; //Correspond à l'étape du scénario à laquelle se situe le passager, 0 pour l'étape d'inscription, 1 enregistrement, 2 passage des frontières, 3 passage de la sécurité, 4 embarquement, 5 en vol
  19.  
  20.     int struct_size; //Taille d'un élément "Passenger"
  21. };
  22.  
  23. struct Flight
  24. {
  25.     int registered_passengers_count; //Nombre de passagers enregistres sur le vol
  26.     int onboard_passengers_count; //Nombre de passagers ayant embarques
  27.     int seats; //Nombre de places dans le vol
  28.     int rows; //Nombre de rangées
  29.     int columns; //Nombre de colonne
  30.     int seats_per_column; //Nombre de place par colonne sur une rangée
  31.     int tickets_available; //Nombre de places disponibles à l'achat
  32.     int luggage_slots; //Poids maximum des bagages
  33.     int luggages_weight; //Poids de tous les bagages chargés
  34.     char* destination; //Destination du vol
  35.     int* occupied_seats; //Tableau des places occupes 0 -> pour place libre | 1 -> pour réservée | 2 -> pour passager assis
  36.  
  37.     int took_off; //0 si le vol n'a pas décollé, 1 si le vol a décollé
  38.  
  39.     int struct_size; //Taille d'un élément "Flight"
  40. };
  41.  
  42. struct Luggage
  43. {
  44.     struct Passenger* owner; //Pointeur vers le passager propriétaire du bagage
  45.     int priority; //Priorité du bagage 0 pour pas prioritaire, 1 pour prioritaire
  46.     float weight; //Poids du bagage en kg
  47.     int ticket; //Numéro ticket du bagage (généré aléatoirement)
  48.     int boarded; //0 si le bagage n'est pas chargé, 1 si le bagage est chargé
  49.  
  50.     int struct_size; //Taille d'un élément "Luggage"
  51. };
  52.  
  53. int what_to_do, count, i;
  54. struct Passenger **passengers;  int passengers_length;  int passengers_size;
  55. struct Flight **flights;        int flights_length;     int flights_size;
  56.  
  57.  
  58. //Fonctions qui sont necessaires au fonctionnement du programme
  59. struct Flight*      create_flight(struct Flight *f, int rows, int columns, int seats_per_column, int luggage_slots, char destination[]); //Instanciation d'un élément de structure Flight
  60. struct Passenger*   create_passenger(struct Passenger *p, struct Flight *flight, char last_name[], char first_name[], int priority, int birthday[], int ticket, char *passport, char* nationality); //Instanciation d'un élément de structure Passenger
  61. struct Luggage*     create_luggage(struct Luggage *l, struct Passenger *p, int priority, float weight); //Instanciation d'un élément de structure Luggage
  62.  
  63. //Scenario
  64. void                add_passengers(); //etape 0 -> achat des billets pour les passagers
  65. void                add_flights(); //Création des vols
  66. void                register_passenger(); // etape 1 -> enregistrement d'un passager sur un vol
  67. void                register_luggage(struct Passenger *p); //Création des bagages
  68. void                borders_passenger(); //etape 2 -> faire passer les frontières à un passager
  69. void                security_passenger(); //etape 3 -> faire passer la sécurité
  70. void                board_passengers(); //etape 4 -> embarquement des passagers sur un vol
  71. void                board_luggages(); //chargement des bagages sur un vol
  72. void                flight_take_off(); //etape 5 -> décollage de l'avion
  73.  
  74. //Procedures menu
  75. void flight_menu(); //Menu interface vol
  76. void passenger_menu(); //Menu interface passagers
  77. void modify_passenger_menu(); //Menu de modification des passagers
  78.  
  79. //Procédures d'affichage
  80. void show_flights(); //Afficher toutes les infos relatives aux vols
  81. void show_passengers(struct Passenger** p, int length); //Afficher toutes les infos relatives aux passagers
  82. void show_registered_on_flight(); //Affiche toutes les infos des passagers enregistrés sur un vol
  83. void show_occupied_seats_on_flight(struct Flight *f); //Affiche toutes les places sur un vol et leur état
  84.  
  85. //Fonctions qui simplifient la vie
  86. char*   input_string(); //Permet d'entrer une chaîne de caractères et de la stocker dans un pointeur
  87. struct Passenger**  get_registered_passengers_on_flight(int id); //Récupère la liste des passagers enregistrés sur un vol
  88. struct Passenger*   find_passenger(char* name, int ticket); //Récupère un passager selon son nom ou son ticket
  89.  
  90. int main()
  91. {
  92.     time_t t;
  93.     srand((unsigned) time(&t)); //Permet de créer une "seed" qui est nécessaire au fonctionnement de la fonction "rand()" utilisée plus tard dans le programme
  94.  
  95.     what_to_do = 1; //Ces variables sont globales et sont définies dans le fichier "functions.h"
  96.     passengers_length = 0;
  97.     flights_length = 0;
  98.  
  99.     printf("Bienvenue dans votre programme de gestion d'aeroport !\n");
  100.     printf("Qu'allez-vous pouvoir faire ?\n");
  101.     printf("Nous allons tout d'abord vous demander de mettre en place votre aeroport, en specifiant les vols disponibles.\n");
  102.     printf("Vous allez ensuite pouvoir effectuer toute une panoplie d'actions pour simuler le fonctionnement de l'aeroport.\n");
  103.     printf("Amusez-vous bien !\n");
  104.  
  105.     printf("Puisque vous venez de lancer le programme, il y a quelques premieres etapes necessaires au bon fonctionnement de l'application a effectuer.\n");
  106.     printf("Veuillez nous indiquer combien de vol(s) seront disponibles a l'ouverture de votre aeroport.\n");
  107.     scanf("%d", &count); getchar(); //count est aussi globale
  108.  
  109.     add_flights(); //Avant de commencer à utiliser le programme, l'utilisateur doit créer un ou plusieurs vol(s).
  110.     flights_length = count;
  111.    
  112.     do {
  113.         printf("\nEntrer le nombre correspondant a l'action a effectuer.\n");
  114.         printf("0 - Quitter\n");
  115.         printf("1 - Gerer les vols\n");
  116.         printf("2 - Gerer les passagers\n");
  117.         scanf("%d", &what_to_do);
  118.  
  119.         switch(what_to_do)
  120.         {
  121.             case 0:
  122.                 printf("Merci de votre utilisation. A bientot !\n");
  123.                 return 0; //Quitte le programme
  124.                 break;
  125.             case 1:
  126.                 flight_menu(); //Menu des vols
  127.                 break;
  128.             case 2:
  129.                 passenger_menu(); //Menu des passagers
  130.                 break;
  131.         }
  132.     } while(what_to_do != 0);
  133. }
  134.  
  135.  
  136. struct Flight *create_flight(struct Flight *f, int rows, int columns, int seats_per_column, int luggage_slots, char destination[])
  137. {
  138.     int array_size = 0; //La taille du tableau "destination"
  139.     while(destination[array_size] != '\0')
  140.     {
  141.         array_size++;
  142.     }
  143.     array_size++; //On connaît sa taille, on va pouvoir attribuer toute la mémoire nécessaire
  144.  
  145.     int seats = rows * columns * seats_per_column; //On sait combien de la place le vol compte. On stocke un entier par place dans le tableau "occupied_seats"
  146.  
  147.     f = realloc(f, sizeof(*f) + array_size + seats*sizeof(int)); //On ajuste la mémoire à la taille exacte dont nous avons besoin
  148.     f->seats = seats; //On procède à l'initialisation des attributs de la structure
  149.     f->rows = rows;
  150.     f->columns = columns;
  151.     f->seats_per_column = seats_per_column;
  152.     f->luggage_slots = luggage_slots;
  153.     f->luggages_weight = 0;
  154.     f->took_off = 0;
  155.     f->tickets_available = seats;
  156.  
  157.     int i;
  158.     f->occupied_seats = malloc(seats*sizeof(int));
  159.     for(i=0;i<seats;i++)
  160.     {
  161.         f->occupied_seats[i] = 0; //On initialise les cases du tableau à 0 (toutes les places sont au départ disponibles)
  162.     }
  163.  
  164.     f->destination = malloc(array_size); //Juste ce qu'il faut
  165.     for(i=0;i<array_size;i++)
  166.     {
  167.         f->destination[i] = destination[i]; //On copie le tableau
  168.     }
  169.  
  170.     f->registered_passengers_count = 0;
  171.     f->onboard_passengers_count = 0;
  172.     f->struct_size = sizeof(*f) + array_size  + seats*sizeof(int); //C'est la taille propre à chaque structure, on s'en sert pour allouer la mémoire nécessaire pour tout stocker dans les tableaux globaux "flights" et "passengers"
  173.  
  174.     return f;
  175. }
  176.  
  177. struct Passenger *create_passenger(struct Passenger *p, struct Flight *flight, char last_name[], char first_name[], int priority, int birthday[], int ticket, char* passport, char* nationality)
  178. {
  179.     int first_name_size = 0, last_name_size = 0, birthday_size = 3 * sizeof(int), luggage_size = 2 * sizeof(struct Luggage), nationality_size = 0;
  180.  
  181.     while(last_name[last_name_size] != '\0')
  182.     {
  183.         last_name_size++;
  184.     }
  185.     last_name_size++; //On connaît la taille de son nom de famille
  186.  
  187.     while(first_name[first_name_size] != '\0')
  188.     {
  189.         first_name_size++;
  190.     }
  191.     first_name_size++; //De son prénom
  192.  
  193.     while(nationality[nationality_size] != '\0')
  194.     {
  195.         nationality_size++;
  196.     }
  197.     nationality_size++; //De sa nationalité
  198.  
  199.     p = realloc(p, sizeof(*p) + first_name_size + last_name_size + birthday_size + flight->struct_size + luggage_size + 10 + nationality_size); //On attribut la mémoire nécessaire. "10" correspond à la taille du la chaîne "passport" qui contient 9 caractères et le caractère '\0'
  200.     p->flight = flight;
  201.     p->priority = priority;
  202.     p->ticket = ticket;
  203.     p->etape = 0;
  204.  
  205.     int i;
  206.  
  207.     p->last_name = malloc(last_name_size);
  208.     for(i=0;i<last_name_size;i++)
  209.     {
  210.         p->last_name[i] = last_name[i]; //On copie
  211.     }
  212.  
  213.     p->first_name = malloc(first_name_size);
  214.     for(i=0;i<first_name_size;i++)
  215.     {
  216.         p->first_name[i] = first_name[i]; //On copie
  217.     }
  218.  
  219.     for(i=0;i<3;i++)
  220.     {
  221.         p->birthday[i] = birthday[i]; //On copie
  222.     }
  223.  
  224.     p->passport = malloc(10);
  225.     for(i=0;i<10;i++)
  226.     {
  227.         p->passport[i] = passport[i]; //On copie
  228.     }
  229.  
  230.     p->nationality = malloc(nationality_size);
  231.     for(i=0;i<nationality_size;i++)
  232.     {
  233.         p->nationality[i] = nationality[i]; //On copie
  234.     }
  235.  
  236.     p->struct_size = sizeof(*p) + first_name_size + last_name_size + birthday_size + flight->struct_size + luggage_size + 10 + nationality_size; //On se souvient de la taille exacte de cette structure
  237.  
  238.     return p;
  239. }
  240.  
  241. struct Luggage* create_luggage(struct Luggage *l, struct Passenger *p, int priority, float weight)
  242. {
  243.     l = realloc(l, sizeof(*l) + p->struct_size);
  244.     l->owner = p;
  245.     l->priority = priority;
  246.     l->weight = weight;
  247.     l->ticket = rand() % 1000000000; //On génère aléatoirement le numéro du bagage
  248.     l->boarded = 0;
  249.  
  250.     l->struct_size = sizeof(*l) + p->struct_size;
  251.  
  252.     return l;
  253. }
  254.  
  255. void show_flights() //Affichage de tous les vols et de leurs infos infos
  256. {
  257.     for(int i=0;i<flights_length;i++)
  258.     {
  259.         printf("|----\t NUMERO DE VOL :    %d   \t----|\n", i);
  260.         printf("|----\t Destination :      %s   \t----|\n", flights[i]->destination);
  261.         printf("|    \t Nombre inscrits :  %d   \t    |\n", flights[i]->registered_passengers_count);
  262.         printf("|    \t Nombre embarques : %d   \t    |\n", flights[i]->onboard_passengers_count);
  263.         printf("|    \t Nombre places :    %d   \t    |\n", flights[i]->seats);
  264.         printf("|    \t Bagages max :      %dkg \t    |\n", flights[i]->luggage_slots);
  265.         printf("|    \t Bagages charges :  %dkg \t    |\n", flights[i]->luggages_weight);
  266.         printf("|----\t-------------------------\t----|\n");
  267.     }
  268. }
  269.  
  270. void show_registered_on_flight() //Affichage de tous les passagers enregistrés sur un vol
  271. {
  272.     int flight_id;
  273.     show_flights();
  274.     printf("De quel vol voulez-vous afficher les passagers enregistres ?\n");
  275.     do {
  276.         scanf("%d", &flight_id);
  277.         if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol.\n");
  278.     } while(flight_id > flights_length-1 ||flight_id < 0);
  279.  
  280.     show_passengers(get_registered_passengers_on_flight(flight_id), flights[flight_id]->registered_passengers_count);
  281.  
  282. }
  283.  
  284. void show_passengers(struct Passenger** p, int length) //Affiche les infos des passagers contenus dans un tableau de pointeurs de taille length
  285. {
  286.     printf("------------------------------\n");
  287.     for(i=0;i<length;i++)
  288.     {
  289.         printf("%s %s\n", p[i]->first_name, passengers[i]->last_name);
  290.  
  291.         int day = p[i]->birthday[0];
  292.         int month = p[i]->birthday[1];
  293.         int year = p[i] -> birthday[2];
  294.  
  295.         printf("Date de naissance : ");
  296.  
  297.         if(day < 10) //On formatte la date de naissance pour afficher des dates telles que 01/01/2000 et non 1/1/2000
  298.         {
  299.             printf("0%d", day);
  300.         }
  301.         else
  302.         {
  303.             printf("%d", day);
  304.         }
  305.  
  306.         printf("/");
  307.  
  308.         if(month<10)
  309.         {
  310.             printf("0%d", month);
  311.         }
  312.         else
  313.         {
  314.             printf("%d", month);
  315.         }
  316.  
  317.         printf("/%d\n", year);
  318.         printf("Prioritaire : "); //On transforme le 1 et le 0 en "oui" et "non"
  319.         if(p[i]->priority == 1)
  320.         {
  321.             printf("oui");
  322.         }
  323.         else
  324.         {
  325.             printf("non");
  326.         }
  327.         printf("\n");
  328.  
  329.         printf("Numero de passeport : %s\n", p[i]->passport);
  330.         printf("Numero de billet : %d\n", p[i]->ticket);
  331.         printf("Etape : "); //On affiche l'étape en fonction du code
  332.         switch(p[i]->etape) {
  333.             case 0:
  334.                 printf("Achat billet\n");
  335.                 break;
  336.             case 1:
  337.                 printf("Enregistrement\n");
  338.                 break;
  339.             case 2:
  340.                 printf("Passage des frontieres\n");
  341.                 break;
  342.             case 3:
  343.                 printf("Passage de la securite\n");
  344.                 break;
  345.             case 4:
  346.                 printf("Embarquement\n");
  347.                 break;
  348.             case 5:
  349.                 printf("En vol.\n");
  350.                 break;
  351.         }
  352.  
  353.         printf("Nationalite : %s\n", p[i]->nationality);
  354.  
  355.         printf("------------------------------\n");
  356.     }
  357. }
  358.  
  359.  
  360. void show_occupied_seats_on_flight(struct Flight *f) //On affiche la distribution des places dans un vol
  361. {
  362.     printf("\n0 -> Place disponible | 1 -> Place reservee | 2 -> Passager assis\n\n");
  363.  
  364.     int i;
  365.     for(i=0;i<f->seats;i++)
  366.     {
  367.         printf("%d", f->occupied_seats[i]); //On afficje l'état de chaque place
  368.         if((i+1) % (f->seats_per_column * f->columns) == 0) //On revient à la ligne après chaque rangée
  369.         {
  370.             printf("\n");
  371.         }
  372.         else if((i+1) % f->seats_per_column == 0) //On met un pipe entre chaque colonne
  373.         {
  374.             printf(" | ");
  375.         }
  376.         else //On met un espace entre chaque place
  377.         {
  378.             printf(" ");
  379.         }
  380.     }
  381.     printf("\n");
  382. }
  383.  
  384.  
  385. void flight_menu() //Le menu de gestion des vols
  386. {
  387.     printf("\nEntree dans le menu vol. Quelle action voulez-vous effectuer ?\n");
  388.     printf("0 - Retour au menu principal\n");
  389.     printf("1 - Ajouter un ou plusieurs vols\n");
  390.     printf("2 - Afficher les vols\n");
  391.     printf("3 - Afficher les passagers enregistres sur un vol.\n");
  392.     printf("4 - Afficher la distribution des places sur un vol.\n");
  393.     printf("5 - Embarquer les passagers sur un vol.\n");
  394.     printf("6 - Charger les bagages sur un vol.\n");
  395.     printf("7 - Faire decoller un vol.\n");
  396.     scanf("%d", &what_to_do); getchar();
  397.     switch(what_to_do) {
  398.         case 0:
  399.             printf("Retour au menu principal.\n");
  400.             what_to_do = 1;
  401.             return; //On quitte le menu de gestion des vols
  402.             break;
  403.         case 1:
  404.             printf("Combien de vols voulez-vous ajouter ?\n");
  405.             scanf("%d", &count); getchar(); //count est globale, et sera utilisée dans add_flights
  406.             add_flights();
  407.             flights_length += count; //On ajoute count vols au nombre total de vols
  408.             if(count > 1) printf("Vos vols ont bien ete ajoutes !\n");
  409.             else printf("Votre vol a bien ete ajoute !\n");
  410.             break;
  411.         case 2:
  412.             printf("Affichage de tous les vols !\n");
  413.             show_flights(); //Affichage des vols
  414.             break;
  415.         case 3:
  416.             show_registered_on_flight(); //Affichage des passagers enregistrés sur un vol
  417.             break;
  418.         case 4:
  419.             show_flights(); //Affichage des vols afin que l'utilisateur puisse choisir pour quel vol afficher la distribution des places
  420.             int flight_id;
  421.             printf("De quel vol voulez-vous afficher la distribution des places occupees ?\n");
  422.             do {
  423.                 scanf("%d", &flight_id);
  424.                 if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol.\n");
  425.             } while(flight_id > flights_length-1 ||flight_id < 0);
  426.             struct Flight *f = flights[flight_id];
  427.             show_occupied_seats_on_flight(f); //Affichage de la distribution des places
  428.             break;
  429.         case 5:
  430.             printf("Preparation a l'embarquement des passagers...\n");
  431.             board_passengers(); //Procédure d'embarquement des passagers
  432.             break;
  433.         case 6:
  434.             printf("Preparation au chargement de bagages...\n");
  435.             board_luggages(); //Procédure du chargement des bagages
  436.             break;
  437.         case 7:
  438.             printf("Preparation au decollage d'un avion...\n");
  439.             flight_take_off(); //Décollage d'un avion
  440.         default:
  441.             what_to_do = 1;
  442.             return; //Par défaut, on retourne au menu principal
  443.             break;
  444.     }
  445. }
  446.  
  447. void passenger_menu() //Menu de la gestion des passagers
  448. {
  449.     printf("\nEntree dans le menu passager. Quelle action voulez-vous effectuer ?\n");
  450.     printf("0 - Retour au menu principal\n");
  451.     printf("1 - Ajouter un ou plusieurs passagers\n");
  452.     printf("2 - Afficher les passagers\n");
  453.     printf("3 - Enregistrer un passager\n");
  454.     printf("4 - Faire passer les frontieres a un passager\n");
  455.     printf("5 - Faire passer la securite a un passager.\n");
  456.     printf("6 - Modifier un passager.\n");
  457.     scanf("%d", &what_to_do); getchar();
  458.     switch(what_to_do) {
  459.         case 0:
  460.             printf("Retour au menu principal.\n");
  461.             what_to_do = 1;
  462.             return; //Retour au menu principal
  463.             break;
  464.         case 1:
  465.             printf("Combien de passagers voulez-vous ajouter ?\n");
  466.             scanf("%d", &count); getchar(); //Pareillement au menu des vols, count est globale est sera utilisée dans add_passengers()
  467.             add_passengers();
  468.             passengers_length += count; //On ajoute le nombre de passagers ajoutés au nombre total de passagers
  469.             if (count > 1) printf("Les passagers ont bien ete ajoutes !\n"); //Toujours de la grammaire...
  470.             else printf("Le passager a bien ete ajoute !\n");
  471.             break;
  472.         case 2:
  473.             printf("Affichage de tous les passagers...\n");
  474.             show_passengers(passengers, passengers_length);
  475.             break;
  476.         case 3:
  477.             printf("Demarrage de la procedure d'enregistrement.\n");
  478.             register_passenger(); //Procédure d'enregistrement des passagers
  479.             break;
  480.         case 4:
  481.             printf("Demarrage de la procedure du passage des frontieres.\n");
  482.             borders_passenger(); //etc
  483.             break;
  484.         case 5:
  485.             printf("Demarrage de la procedure du passage de la securite.\n");
  486.             security_passenger();
  487.             break;
  488.         case 6:
  489.             modify_passenger_menu(); //Voir... juste en-dessous !
  490.             break;
  491.     }
  492. }
  493.  
  494. void modify_passenger_menu()
  495. {
  496.     printf("Liste de tous les passagers : \n");
  497.     show_passengers(passengers, passengers_length);
  498.  
  499.     printf("Comment voulez-vous choisir le passager a modifier ?\n");
  500.     printf("\t- Par son numero de billet (0)\n");
  501.     printf("\t- Par son nom (1)\n");
  502.     int procedure, i, success = 0;
  503.     struct Passenger *p;
  504.     scanf("%d", &procedure); getchar();
  505.     switch(procedure)
  506.     {
  507.     case 0:
  508.         printf("Entrer le numero de ticket du passager a modifier.\n");
  509.  
  510.         int ticket;
  511.         scanf("%d", &ticket); getchar();
  512.  
  513.         p = find_passenger(NULL, ticket);
  514.  
  515.         break;
  516.     case 1:
  517.         printf("Entrer le nom du passager a modifier.\n");
  518.  
  519.         char* nom;
  520.         nom = input_string();
  521.  
  522.         p = find_passenger(nom, -1);
  523.  
  524.         break;
  525.     }
  526.     if(p != NULL)
  527.     {
  528.         do {
  529.             printf("\nVeuillez choisir l'action a effectuer sur %s %s.\n", p->first_name, p->last_name);
  530.             printf("0 - Revenir au menu principal\n");
  531.             printf("1 - Modifier le prenom\n");
  532.             printf("2 - Modifier le nom\n");
  533.             printf("3 - Modifier la nationalite\n");
  534.             printf("4 - Modifier la priorite\n");
  535.             printf("5 - Modifier l'anniversaire\n");
  536.             printf("6 - Modifier le passeport\n");
  537.             printf("7 - Modifier les bagages\n");
  538.             printf("8 - Modifier le vol\n");
  539.             scanf("%d", &what_to_do); getchar(); //Quel attribut du passager l'utilisateur veut-il modifier ?
  540.  
  541.             passengers_size -= p->struct_size;
  542.  
  543.             switch(what_to_do) {
  544.                 case 0:
  545.                     what_to_do = 1;
  546.                     return; //Retour au menu principal
  547.                     break;
  548.                 case 1:
  549.                     printf("Entrer le nouveau prenom de %s %s : ", p->first_name, p->last_name);
  550.                     char *first_name = input_string();
  551.                     p = create_passenger(p, p->flight, p->last_name, first_name, p->priority, p->birthday, p->ticket, p->passport, p->nationality); //C'est pour cela que dans la fonction create_passenger(...) on réalloue la mémoire au lieu de simplement l'allouer. Si on l'allouait simplement, le tableau des passager contiendrait après cela une adresse erronée ! On aurait alors (et on en eu d'ailleurs...) une erreur de segmentation.
  552.                     break;
  553.                 case 2:
  554.                     printf("Entrer le nouveau nom de %s %s : ", p->first_name, p->last_name);
  555.                     char *last_name = input_string();
  556.                     p = create_passenger(p, p->flight, last_name, p->first_name, p->priority, p->birthday, p->ticket, p->passport, p->nationality); //Du coup, on recrée une strucuture semblable à celle avant la modification, on change juste l'attribut qui nous intéresse
  557.                     break;
  558.                 case 3:
  559.                     printf("Nationalite : %s.\n", p->nationality);
  560.                     printf("Entrer la nouvelle nationalite de %s %s : ", p->first_name, p->last_name);
  561.                     char *nationality = input_string();
  562.                     p = create_passenger(p, p->flight, p->last_name, p->first_name, p->priority, p->birthday, p->ticket, p->passport, nationality);
  563.                     break;
  564.                 case 4:
  565.                     printf("Priorite: %d.\n", p->priority);
  566.                     printf("Entrer la nouvelle priorite de %s %s (0 : non-prioritaire | 1 : prioritaire) : ", p->first_name, p->last_name);
  567.                     scanf("%d", &p->priority); getchar();
  568.                     break;
  569.                 case 5:
  570.                     printf("Changement de la date de naissance de %s %s.\n", p->first_name, p->last_name);
  571.                     printf("Jour : "); scanf("%d", &p->birthday[0]);
  572.                     printf("Mois : "); scanf("%d", &p->birthday[1]);
  573.                     printf("Annee : "); scanf("%d", &p->birthday[2]); getchar(); //Là on peut directement aller modifier les valeurs de birthday, car c'est un tableau statique
  574.                     break;
  575.                 case 6:
  576.                     printf("Entrer le nouveau numero de passeport de %s %s (2 chiffres, 2 lettre, 5 chiffres) : ", p->first_name, p->last_name);
  577.                     char *passport = input_string();
  578.                     p = create_passenger(p, p->flight, p->last_name, p->first_name, p->priority, p->birthday, p->ticket, passport, p->nationality);
  579.                     break;
  580.                 case 7:
  581.                     printf("Nouvelle procedure d'enregistrement des bagages pour %s %s.\n", p->first_name, p->last_name);
  582.                     register_luggage(p); //On écrase les précédents bagages par les nouveaux
  583.                     break;
  584.                 case 8: //Le cas le plus complexe, le changement de vol
  585.                     show_flights();
  586.                     if(p->etape > 0 && p->etape != 5)
  587.                     {
  588.                         p->flight->occupied_seats[p->seat] = 0; //On met directement la place du passager comme étant libre
  589.                     }
  590.                     p->flight->tickets_available++; //La place est disponible à l'achat
  591.                     if(p->etape > 3)
  592.                     {
  593.                         p->flight->onboard_passengers_count--; //Si le passager était embarqué, il ne l'est plus
  594.                     }
  595.  
  596.                     if(p->etape > 0)
  597.                     {
  598.                         p->flight->registered_passengers_count--; //Si le passager était enregistré, il ne l'est plus
  599.                     }
  600.  
  601.                     p->etape = 0; //Annulation de l'enregistrement
  602.  
  603.                     printf("Veuillez choisir un nouveau vol pour %s %s.\n", p->first_name, p->last_name);
  604.                     printf("Entrer l'ID du nouveau vol : ");
  605.                     int flight_id;
  606.                     do {
  607.                         scanf("%d", &flight_id);
  608.                         if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol du passager.\n");
  609.                         else
  610.                         {
  611.                             if(flights[flight_id]->tickets_available - 1 == 0)
  612.                             {
  613.                                 printf("Desole, ce vol est deja plein. Annulation de la modification de passager.\n");
  614.                                 return;
  615.                             }
  616.                             else if (flights[flight_id]->took_off == 1)
  617.                             {
  618.                                 printf("Desole, ce vol a deja decolle. Annulation de la modification de passager.\n");
  619.                                 return;
  620.                             }
  621.                         }
  622.                     } while(flight_id > flights_length-1 ||flight_id < 0);
  623.  
  624.                     getchar();
  625.  
  626.                     p->flight = flights[flight_id]; //On le met sur le nouveau vol
  627.                     flights[flight_id]->tickets_available--; //Le nouveau a donc une place de disponible en moins
  628.                     break;
  629.             }
  630.  
  631.             passengers_size += p->struct_size;
  632.             passengers = (struct Passenger**) realloc(passengers, passengers_size);
  633.  
  634.         } while(0 == 0); //Tête à toto !
  635.     }
  636. }
  637.  
  638. void add_passengers()
  639. {
  640.     if(count == 1) //Pour la grammaire !!
  641.     {
  642.         printf("Generation de 1 passager...\n");
  643.     }
  644.     else if(count > 1)
  645.     {
  646.         printf("Generation de %d passagers...\n", count); //On note le 's' qui fait la différence...
  647.     }
  648.  
  649.     int i;
  650.     for(i=passengers_length;i<passengers_length+count;i++) //Ok, on répète ces instructions pour les count passagers à créer
  651.     {
  652.         char* first_name; char* last_name; int priority; int birthday[3]; char* passport; int flight_id; char* nationality; //Toutes les variables pour créer le passager
  653.  
  654.         printf("Veuillez saisir le prenom du passager : "); //Explicite
  655.         first_name = input_string();
  656.         printf("Veuillez saisir le nom du passager : ");
  657.         last_name = input_string();
  658.         printf("Ce passager est-il un passager prioritaire ? Oui (1) / Non (0)\n");
  659.         scanf("%d", &priority);
  660.         int correct = 0; //Cette variable va permettre de savoir si la date rentrée par la suite sera valide
  661.         do {
  662.             printf("Veuillez saisir la date de naissance du passager.\n"); //Ici c'est un peu piégeux, il faut gérer le calendrier grégorien avec les années bissextiles.
  663.             printf("Jour : ");
  664.             scanf("%d", &birthday[0]); //Jour
  665.             printf("Mois (un nombre) : ");
  666.             scanf("%d", &birthday[1]); //Mois
  667.             printf("Annee : ");
  668.             scanf("%d", &birthday[2]); getchar(); //Année, et on vide le buffer
  669.             if(birthday[2] > 1900 && birthday[2] < 2021 && birthday[0] >= 1 && birthday[1] >= 1 && birthday[1] <= 12) // Si le passager est né avant 1900, c'est sans doute un fantôme. On ne gère pas les passagers fantômes. S'il est né après 2020 (et encore on est sympas...), c'est un voyageur du temps. Cas que l'on ne gère pas non plus. Et puis, s'il peut voyager dans le temps, pourquoi prend-il l'avion dans un premier temps ??? A coup sûr, il a des moyens de transports bien plus avancés.
  670.             {
  671.                 switch(birthday[1]) {
  672.                     case 1:
  673.                     case 3:
  674.                     case 5:
  675.                     case 7:
  676.                     case 8:
  677.                     case 10:
  678.                     case 12: //Mois classiques
  679.                         if(birthday[0] <= 31)
  680.                         {
  681.                             correct = 1; //Oui ! La date entrée est valide.
  682.                         }
  683.                         break;
  684.                     case 2: //Février....
  685.                         if((birthday[2] % 4 == 0 && birthday[2] % 100 != 0) || birthday[2] % 400 == 0) //Si c'est une année bissextile
  686.                         {
  687.                             if(birthday[0] <= 29)
  688.                             {
  689.                                 correct = 1;
  690.                             }
  691.                         }
  692.                         else //Si année classique
  693.                         {
  694.                             if(birthday[0] <= 28)
  695.                             {
  696.                                 correct = 1;
  697.                             }  
  698.                         }
  699.                         break;
  700.                     default: //Mois de 30 jours
  701.                         if(birthday[0] <= 30)
  702.                         {
  703.                             correct = 1;
  704.                         }
  705.                         break;
  706.                 }
  707.             }
  708.             if(correct == 0) //"correct" est toujours à 0, la date rentrée n'est pas valide.
  709.             {
  710.                 printf("La date que vous avez saisie n'est pas valide. Veuillez recommencer.\n");
  711.             }
  712.         } while(correct != 1); //On réessaye
  713.  
  714.         printf("Veuillez entrer le numero de passeport du passager. (2 chiffres, 2 lettres, 5 chiffres)\n"); //Explicite
  715.         passport = input_string();
  716.         printf("Veuillez entrer la nationalite du passager.\n");
  717.         nationality = input_string();
  718.         printf("Voici tous les vols disponibles.\n");
  719.         show_flights(); //On affiche tous les vols disponibles pour le passager.
  720.         printf("Veuillez entrer l'ID du vol du passager.\n"); //L'ID du vol est en fait sa place dans le tableau qui stocke tous les vols.
  721.         do {
  722.             scanf("%d", &flight_id);
  723.             if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol du passager.\n"); //On va bien faire attention à l'ID que l'utilisateur va entrer afin de ne pas accéder à un endroit inconnu dans la mémoire.
  724.             else
  725.             {
  726.                 if(flights[flight_id]->tickets_available-1 == 0) //Si le vol n'a plus de places disponibles
  727.                 {
  728.                     printf("Desole, ce vol est deja plein. Annulation de la creation de passager.\n");
  729.                     return;
  730.                 }
  731.                 else if (flights[flight_id]->took_off == 1) //Si le vol est déjà parti
  732.                 {
  733.                     printf("Desole, ce vol a deja decolle. Annulation de la creation de passager.\n");
  734.                     return;
  735.                 }
  736.             }
  737.         } while(flight_id > flights_length-1 ||flight_id < 0); //Et on réessaye
  738.  
  739.         getchar(); //On vide le buffer
  740.         int ticket = rand() % 1000000000; //On crée un numéro de billet aléatoire
  741.        
  742.         struct Passenger *p = (struct Passenger*) malloc(sizeof(p)); //Dans la fonction create_passenger(...) on utilise realloc et non malloc, il faut donc avoir allouer de la mémoire auparavant. Pour comprendre ce choix, voir la fonction "modify_passenger()" dans le fichier "menu_fonctions.c"
  743.         p = create_passenger(p, flights[flight_id], last_name, first_name, priority, birthday, ticket, passport, nationality); //Et on crée le passager ! On verra dans les commentaires de la fonction "create_passenger()"" ce qu'il se passe exactement
  744.  
  745.         if(i == 0) //Si c'est le TOUT PREMIER passager créé, il faut pour la première fois allouer de la mémoire pour le tableau de pointeurs des passagers
  746.         {
  747.             passengers_size = p->struct_size; //p->struct_size est la taille de l'élément p dans la mémoire. Et passengers_size est la taille totale de tous les éléments stockés dans la variable "passengers" qui est le fameux tableau de tous les passagers.
  748.             passengers = (struct Passenger**) malloc(passengers_size); //Il n'y a que p dans la mémoire, donc on allue pile poil la place pour p
  749.         }
  750.         else
  751.         {
  752.             passengers_size += p->struct_size; //On ajoute la taille de l'élément p à la taille de tous les passagers
  753.             passengers = (struct Passenger**) realloc(passengers, passengers_size); //Et on réalloue la mémoire pour avoir assez de place pour tout le monde !
  754.         }
  755.  
  756.         passengers[i] = p; //Maintenant qu'on a assez de place, on affecte p au tableau, à la bonne place
  757.         flights[flight_id]->tickets_available--; //Et on soustrait une place de disponible sur le vol de p
  758.  
  759.     }
  760. }
  761.  
  762. void add_flights()
  763. {
  764.     if(count == 1) //Pour la grammaire ! (encore)
  765.     {
  766.         printf("Generation de 1 vol...\n");
  767.     }
  768.     else if(count > 1)
  769.     {
  770.         printf("Generation de %d vols...\n", count);
  771.     }
  772.  
  773.     int i;
  774.     for(i=flights_length;i<flights_length+count;i++) //On répète l'opération autant de fois que l'utilisateur souhaite ajouter de vols
  775.     {
  776.         char* destination; int luggage_slots, rows, colums, seats_per_column; //Les variables nécessaires pour créer un vol
  777.  
  778.         printf("Veuillez saisir la destination du vol : "); //Explicite
  779.         destination = input_string();
  780.         printf("Indication : un vol avec 10 rangees, 2 colonnes et 2 places par colonne aura en tout 40 places (10 x 2 x 2 = 40).\n");
  781.         printf("Veuillez saisir le nombre de rangees de ce vol : ");
  782.         scanf("%d", &rows); getchar();
  783.         printf("Veuillez saisir le nombre de colonnes de ce vol : ");
  784.         scanf("%d", &colums); getchar();
  785.         printf("Veuillez saisir la largeur en sieges d'une colonne dans ce vol : ");
  786.         scanf("%d", &seats_per_column); getchar();
  787.         luggage_slots = rows * colums * seats_per_column * 23 * 2; //On calcule le nombre de bagages maximum dans un avion automatiquement. * 23 * 2 car chaque passager peut avoir jusqu'à deux bagages de vingt-trois kilos.
  788.  
  789.         struct Flight *f = (struct Flight*) malloc(sizeof(f));
  790.         f = create_flight(f, rows, colums, seats_per_column, luggage_slots, destination); //Et on crée le vol !
  791.  
  792.         if(i == 0) //Premier vol
  793.         {
  794.             flights_size = f->struct_size; //De manière analogue à la création de passager, flight_size représente la taille de tous les éléments "Flight" stockés dans "flights"
  795.             flights = (struct Flight**) malloc(flights_size); //Faire de la place pour le premier vol
  796.         }
  797.         else
  798.         {
  799.             flights_size += f->struct_size; //On fait de la place pour le nouveau vol
  800.             flights = (struct Flight**) realloc(flights, flights_size); //Et on l'applique
  801.         }
  802.  
  803.         flights[i] = f; //Assez de place, on affecte.
  804.     }
  805. }
  806.  
  807. void register_passenger()
  808. {
  809.     //C'est parti pour l'enregistrement d'un passager !
  810.     printf("Liste de tous les passagers : \n");
  811.     show_passengers(passengers, passengers_length); //Affichage de tous les passagers
  812.  
  813.     printf("Comment voulez-vous identifier le passager a enregistrer ?\n");
  814.     printf("\t- Par son numero de billet (0)\n");
  815.     printf("\t- Par son nom (1)\n");
  816.     int procedure, i, success = 0; //procedure pour la méthode d'identification du passager, i un compteur, et success une variable qui nous permettra de demander des choses simples à l'utilisateur
  817.     struct Passenger *p;
  818.     scanf("%d", &procedure); getchar();
  819.     switch(procedure)
  820.     {
  821.     case 0: //Identification par billet
  822.         printf("Entrer le numero de ticket du passager a enregistrer.\n");
  823.  
  824.         int ticket;
  825.         scanf("%d", &ticket); getchar();
  826.  
  827.         p = find_passenger(NULL, ticket); //On trouve le passager en question grâce au billet, et on le garde dans un pointeur
  828.  
  829.         break;
  830.     case 1: //Identification par nom
  831.         printf("Entrer le nom du passager a enregistrer.\n");
  832.  
  833.         char* nom;
  834.         nom = input_string();
  835.  
  836.         p = find_passenger(nom, -1); //On trouve le passager en question grâce à son nom, et on le garde dans un pointeur
  837.  
  838.         break;
  839.     }
  840.  
  841.     if(p != NULL && p->etape == 0) //On vérifie qu'on a bien trouvé le passager, et qu'il n'a pas encore passer cette étape
  842.     {
  843.         p->etape++; //Il passe à l'étape suivante
  844.         printf("%s %s a ete enregistre(e) sur le vol a destination de %s.\nSon boarding pass a bien ete cree.\n", p->first_name, p->last_name, p->flight->destination);
  845.        
  846.         p->flight->registered_passengers_count += 1; //On incrémente le nombre d'enregistrés sur le vol
  847.         printf("Voulez-vous enregistrer des bagages pour ce passager ? Oui (1) ou Non (0)\n");
  848.         scanf("%d", &success);
  849.         if(success == 1) //L'utilisateur veut-il enregistrer des passagers ?
  850.         {
  851.             register_luggage(p); //On enregistre des bagages pour le passager
  852.         }
  853.  
  854.         printf("Il faut desormais attribuer une place au passager. Choisissez la methode de choix : Automatique (1) ou Manuelle (0)\n");
  855.         scanf("%d", &success);
  856.  
  857.         printf("Affichage du vol.\n");
  858.         show_occupied_seats_on_flight(p->flight); //On affiche la distribution des places dans le vol
  859.         int seat, row, column, seat_on_column; //Entrées utilisateurs (s'il choisit la méthode manuelle)
  860.         if(success == 1)
  861.         {
  862.             do {
  863.                 row = rand() % p->flight->rows; //On choisit un rang aléatoire
  864.                 column = rand() % p->flight->columns; //On choisit une colonne aléatoire
  865.                 seat_on_column = rand() % p->flight->seats_per_column; //Et on choisit une place aléatoire dans la colonne
  866.                 seat = row * p->flight->columns * p->flight->seats_per_column + column * p->flight->seats_per_column + seat_on_column; //On calcule le numéro de la place pour le tableau
  867.             } while(p->flight->occupied_seats[seat] != 0); //Et si la place est déjà prise on recommence !
  868.  
  869.             p->flight->occupied_seats[seat] = 1; //Ok, maintenant la place est occupée.
  870.             p->seat = seat; //On donne au passager son numéro de place
  871.             printf("La place pour le passager se situe est la place %d sur la rangee %d de la colonne %d.\n", seat_on_column+1, row+1, column+1); //Et on lui fait savoir
  872.         }
  873.         else
  874.         {
  875.             printf("Nombre de rangees : %d\n", p->flight->rows); //On fait savoir clairement à l'utilisateur de combien de rangées/colonnes/places par colonne l'avion dispote-t-il.
  876.             printf("Nombre de colonnes : %d\n", p->flight->columns);
  877.             printf("Nombre de places par colonne : %d\n", p->flight->seats_per_column);
  878.  
  879.             do {
  880.                 printf("Entrez la rangee : ");
  881.                 scanf("%d", &row);
  882.                 if(row > p->flight->rows || row < 0)
  883.                 {
  884.                     printf("La rangee demandee n'est pas valide.\n");
  885.                 }
  886.             } while(row > p->flight->rows || row < 0); //On vérifie la validité, sinon le numéro de place généré pourrait nous faire accéder à un endroit inconnu de la mémoire
  887.  
  888.             do {
  889.                 printf("Entrez la colonne : ");
  890.                 scanf("%d", &column);
  891.                 if(column > p->flight->columns || column < 0)
  892.                 {
  893.                     printf("La colonne demandee n'est pas valide.\n");
  894.                 }
  895.             } while(column > p->flight->columns || column < 0);
  896.  
  897.             do {
  898.                 printf("Entrez la rangee : ");
  899.                 scanf("%d", &seat_on_column);
  900.                 if(seat_on_column > p->flight->seats_per_column || seat_on_column < 0)
  901.                 {
  902.                     printf("La place demandee n'est pas valide.\n");
  903.                 }
  904.             } while(seat_on_column > p->flight->seats_per_column || seat_on_column < 0);
  905.  
  906.             row--; //On sait que l'utilisateur n'a pas l'habitude des tableaux en C, et que c'est une personne normale : il va donc commencer à compter à partir de 1 et non de 0
  907.             column--;
  908.             seat_on_column--;
  909.  
  910.  
  911.             seat = row * p->flight->columns * p->flight->seats_per_column + column * p->flight->seats_per_column + seat_on_column; //On calcule le numéro de place demandée par le passager
  912.             p->flight->occupied_seats[seat] = 1; //La place est désormais occupée
  913.             p->seat = seat; //On affecte au passager sa place
  914.         }
  915.         printf("Affichage du vol avec la place nouvellement reservee.\n");
  916.         show_occupied_seats_on_flight(p->flight); //Et on affiche le vol maintenant que le passager à réserver sa place
  917.     }  
  918.     else if(p != NULL && p->etape > 0) //Si le passager avait déjà passé cette étape
  919.     {
  920.         printf("%s %s est deja enregistre(e) sur le vol a destination de %s.\n", p->first_name, p->last_name, p->flight->destination); 
  921.     }
  922. }
  923.  
  924. void register_luggage(struct Passenger *p)
  925. {
  926.     int priority = p->priority; //La priorité du bagage est la même que celle du passager
  927.     float weight; //Poids du bagage
  928.     if(priority == 1) //Si le passager est prioritaire
  929.     {
  930.         printf("%s %s est un passager prioritaire. Il est possible d'enregistrer jusqu'a deux bagages.\n", p->first_name, p->last_name);
  931.         int i, slots;
  932.  
  933.         do {
  934.             printf("Combien de bagages voulez-vous enregistrer ? (2 max)\n");
  935.             scanf("%d", &slots);
  936.         } while(slots > 2 || slots < 1); //L'utilisateur a choisi d'enregistrer des bagages, il est donc obligé d'en enregistrer entre un et deux
  937.  
  938.         for(i=0;i<2;i++) //Les tableaux bagages de chaque passager ont deux cases
  939.         {
  940.             if(i>=slots) //Si on dépasse le nombre de bagages à enregistrer
  941.             {
  942.                 p->luggages[i] = NULL; //Le bagage n'existe pas
  943.             }
  944.             else //Sinon
  945.             {
  946.                 do {
  947.                     printf("Entrer le poids du bagage en kilogrammes (max 23kg).\n");
  948.                     scanf("%f", &weight);
  949.                 } while(weight > 23 && weight < 0); //On demande le poids du bagage, et on vérifie qu'il ne dépasse pas 23kg
  950.                 struct Luggage *l = (struct Luggage*) malloc(sizeof(l));
  951.                 l = create_luggage(l, p, priority, weight); //On crée le bagage !
  952.                 p->luggages[i] = l; //On l'affecte au passager
  953.                 printf("L'ID du ticket bagage prioritaire genere est #%d.\n", l->ticket); //Et on affichage son numéro
  954.             }
  955.         }
  956.     }
  957.     else //Si le passager n'est pas prioritaire
  958.     {
  959.         printf("%s %s n'est pas un passager prioritaire. Il est possible d'enregistrer un bagage.\n", p->first_name, p->last_name);
  960.         printf("Entrer le poids du bagage en kilogrammes (max 23kg).\n");
  961.         do {
  962.             scanf("%f", &weight);
  963.         } while(weight > 23 && weight < 0); //On vérifie que le poids ne dépasse pas 23kg, et qu'il est supérieur à zéro
  964.         struct Luggage *l = (struct Luggage*) malloc(sizeof(l));
  965.         l = create_luggage(l, p, priority, weight);
  966.         p->luggages[0] = l; //On l'affecte au passager non-prioritaire...
  967.         p->luggages[1] = NULL; //... qui n'a le droit qu'à un seul bagage. L'autre n'existe pas
  968.         printf("L'ID du ticket bagage genere est #%d.\n\n", l->ticket); //On affiche le numéro du bagage
  969.     }
  970.  
  971.     printf("L'enregistrement des bagages est termine.\n");
  972. }
  973.  
  974. void borders_passenger()
  975. {   //Notre passager va désormais passer les frontières. On ne recommentera pas les lignes et procédures identiques à celles décrites dans "register_passenger()"
  976.     printf("Liste de tous les passagers : \n");
  977.     show_passengers(passengers, passengers_length);
  978.  
  979.     printf("Comment voulez-vous identifier le passager qui passe les frontieres ?\n");
  980.     printf("\t- Par son numero de billet (0)\n");
  981.     printf("\t- Par son nom (1)\n");
  982.     int procedure, i, success = 0;
  983.     struct Passenger *p;
  984.     scanf("%d", &procedure); getchar();
  985.     switch(procedure)
  986.     {
  987.     case 0:
  988.         printf("Entrer le numero de ticket du passager qui passe les frontieres.\n");
  989.  
  990.         int ticket;
  991.         scanf("%d", &ticket); getchar();
  992.  
  993.         p = find_passenger(NULL, ticket);
  994.  
  995.         break;
  996.     case 1:
  997.         printf("Entrer le nom du passager qui passe les frontieres.\n");
  998.  
  999.         char* nom;
  1000.         nom = input_string();
  1001.  
  1002.         p = find_passenger(nom, -1);
  1003.  
  1004.         break;
  1005.     }
  1006.  
  1007.     if(p != NULL && p->etape == 1) //Si le passager est à la bonne étape
  1008.     {
  1009.         int success = 0, besoin_visa; //besoin_visa stockera si le passager a besoin ou non d'un visa
  1010.  
  1011.         int destination; //Pour répondre aux QCM
  1012.  
  1013.         printf("Nous avons besoin de plusieurs indications vous concernant.\n");
  1014.  
  1015.         do {
  1016.             printf("Veuillez-choisir votre type de destination :\n");
  1017.             printf("\t1 - Europe\n");
  1018.             printf("\t2 - Hors Europe\n");
  1019.             scanf("%d", &destination);
  1020.         } while(destination < 1 || destination > 2); //On distingue deux cas principaux
  1021.  
  1022.         int europeen;
  1023.         do {
  1024.             printf("De quelle nationale etes-vous :\n");
  1025.             printf("\t1 - Europeen\n");
  1026.             printf("\t2 - Non-europeen\n");
  1027.             scanf("%d", &europeen);
  1028.         } while(europeen < 1 || europeen > 2); //On distingue deux cas principaux
  1029.  
  1030.         if(destination == 1 && europeen == 1) //Si le passager est européen et qu'il voyage en Europe, il n'a logiquement pas besoin de Visa
  1031.         {
  1032.             printf("Vous pouvez continuer, vous n'avez pas besoin de Visa.\n");
  1033.             success = 1;
  1034.             besoin_visa = 0;
  1035.         }
  1036.         else if(destination == 1 && europeen == 2) //Si le passager n'est pas européen et qu'il voyage en Europe, il a besoin d'un visa Schengen
  1037.         {
  1038.             besoin_visa = 1; //Oui
  1039.             int schengen; //En possède-t-il un ?
  1040.             do {
  1041.                 printf("Possedez-vous un visa Schengen ?\n");
  1042.                 printf("\t1 - Oui\n");
  1043.                 printf("\t2 - Non\n");
  1044.                 scanf("%d", &schengen);
  1045.             } while(schengen < 1 || schengen > 2);
  1046.  
  1047.             if(schengen == 1) //Super ! Il a son visa, il peut passer les frontières !
  1048.             {
  1049.                 printf("Tres bien, vous pouvez continuer.\n");
  1050.                 success = 1;
  1051.             }
  1052.             else //Mince... Il va devoir trouver un visa avant de pouvoir passer les frontières
  1053.             {
  1054.                 printf("Desole, il vous faut un visa Schengen pour pouvoir continuer.\n");
  1055.             }
  1056.         }
  1057.         else if(destination == 2 && europeen == 1) //Si le passager ne voyage pas en Europe et il est Européen
  1058.         {
  1059.             besoin_visa = 1; //Oui
  1060.             int visa;
  1061.             do {
  1062.                 printf("Possedez-vous un visa pour votre destination ?\n");
  1063.                 printf("\t1 - Oui\n");
  1064.                 printf("\t2 - Non\n");
  1065.                 scanf("%d", &visa);
  1066.             } while(visa < 1 || visa > 2);
  1067.  
  1068.             if(visa == 1) //S'il possède un visa pour sa destination, tout va bien, il peut passer les frontières
  1069.             {
  1070.                 printf("Tres bien, vous pouvez continuer.\n");
  1071.                 success = 1;
  1072.             }
  1073.             else //Sinon, il faut qu'il s'en procure un avant de pouvoir continuer
  1074.             {
  1075.                 printf("Desole, il vous faut un visa pour votre destination pour pouvoir continuer.\n");
  1076.             }
  1077.         }
  1078.         else if(destination == 2 && europeen == 2) //Si le passager n'est pas européen, et il ne voyage pas en Europe
  1079.         {
  1080.             int origine;
  1081.             do {
  1082.                 printf("Retournez-vous dans votre pays d'origine ?\n");
  1083.                 printf("\t1 - Oui\n");
  1084.                 printf("\t2 - Non\n");
  1085.                 scanf("%d", &origine);
  1086.             } while(origine < 1 || origine > 2);
  1087.  
  1088.             if(origine == 1) //S'il retourne dans son pays d'origine, il n'a logiquement pas besoin de Visa
  1089.             {
  1090.                 printf("Vous n'avez pas besoin de visa. Vous pouvez continuer.\n");
  1091.                 besoin_visa = 0;
  1092.                 success = 1;
  1093.             }
  1094.             else //Il a besoin d'un visa
  1095.             {
  1096.                 besoin_visa = 1;
  1097.                 int visa;
  1098.                 do {
  1099.                     printf("Possedez-vous un visa pour votre destination ?\n");
  1100.                     printf("\t1 - Oui\n");
  1101.                     printf("\t2 - Non\n");
  1102.                     scanf("%d", &visa);
  1103.                 } while(visa < 1 || visa > 2);
  1104.  
  1105.                 if(visa == 1) //Il peut passer les frontières
  1106.                 {
  1107.                     printf("Tres bien, vous pouvez continuer.\n");
  1108.                     success = 1;
  1109.                 }
  1110.                 else //Il ne peut pas passer les frontières
  1111.                 {
  1112.                     printf("Desole, il vous faut un visa pour votre destination pour pouvoir continuer.\n");
  1113.                 }
  1114.             }
  1115.         }
  1116.  
  1117.         if(success == 1) //Si le passager peut passer les frontières, on affiche sa destination, sa nationalité et s'il a ou non besoin d'un visa
  1118.         {
  1119.             printf("Infos concernant %s %s :\n", p->first_name, p->last_name);
  1120.             printf("\tDestination : %s\n", p->flight->destination);
  1121.             printf("\tNationalite : %s\n", p->nationality);
  1122.             printf("\tBesoin de Visa : ");
  1123.             if(besoin_visa == 1) printf("oui\n");
  1124.             else printf("non\n");
  1125.             p->etape++; //Le passager passe à l'étape suivante
  1126.         }
  1127.     }
  1128.     else if(p != NULL && p->etape > 1) //Si le passager a déjà passé cette étape
  1129.     {
  1130.         printf("Ce passager a deja passe les frontieres.\n");
  1131.     }
  1132.     else if(p != NULL && p->etape < 1) //Si le passager ne peut pas encore passer cette étape
  1133.     {
  1134.         printf("Ce passager doit d'abord s'enregistrer.\n");
  1135.     }
  1136. }
  1137.  
  1138. void security_passenger()
  1139. { //Notre passager va désormais passer la sécurité
  1140.     printf("Liste de tous les passagers : \n");
  1141.     show_passengers(passengers, passengers_length);
  1142.  
  1143.     printf("Comment voulez-vous identifier le passager qui passe la securite ?\n");
  1144.     printf("\t- Par son numero de billet (0)\n");
  1145.     printf("\t- Par son nom (1)\n");
  1146.     int procedure, i, success = 0;
  1147.     struct Passenger *p;
  1148.     scanf("%d", &procedure); getchar();
  1149.     switch(procedure)
  1150.     {
  1151.     case 0:
  1152.         printf("Entrer le numero de ticket du passager qui passe la securite.\n");
  1153.  
  1154.         int ticket;
  1155.         scanf("%d", &ticket); getchar();
  1156.  
  1157.         p = find_passenger(NULL, ticket);
  1158.  
  1159.         break;
  1160.     case 1:
  1161.         printf("Entrer le nom du passager qui passe la securite.\n");
  1162.  
  1163.         char* nom;
  1164.         nom = input_string();
  1165.  
  1166.         p = find_passenger(nom, -1);
  1167.  
  1168.         break;
  1169.     }
  1170.  
  1171.     if(p != NULL && p->etape == 2) //Le passager en est bien à cette étape...
  1172.     {
  1173.         printf("Vous etes autorise a prendre un bagage en cabine avec vous. Le bagage ne peut contenir de contenants (bouteilles, pommades, fiole, etc.). Il vous sera demande plus tard si vous souhaitez prendre des contenants avec vous.\n");
  1174.  
  1175.         float poids;
  1176.         do {
  1177.             printf("Le poids d'un bagage a main ne peut depasser 12kg. Si votre bagage fait plus de 12kg, veuillez retirer des objets.\n");
  1178.             printf("Quel est le poids de votre bagage ?\n");
  1179.             scanf("%f", &poids);
  1180.         } while(poids > 12 && poids < 0); //Le passager a le droit à un bagage pesant jusque 12kg. Si le bagage pèse 0kg, on part du principe qu'il n'a pas de bagage à main. Le poids ne peut pas malgré tout être négatif. (ou alors le bagage flotte dans les airs)
  1181.  
  1182.         int choix;
  1183.         do {
  1184.             printf("Voulez-vous prendre des contenants avec vous ? Les contenants ne peuvent depasser 100mL chacun, et vous ne pouvez avoir plus d'1L de contenants sur vous.\n");
  1185.             printf("\t1 - Oui\n");
  1186.             printf("\t2 - Non\n");
  1187.             scanf("%d", &choix);
  1188.         } while(choix < 1 || choix > 2);
  1189.  
  1190.         if(choix == 1) //Si le passager prend avec lui des contenants
  1191.         {
  1192.             int nb;
  1193.             int i;
  1194.             float volume;
  1195.             float total; //tout ce dont on a besoin de savoir
  1196.             do {
  1197.                 printf("Combien de contenants voulez-vous prendre avec vous ?\n");
  1198.                 scanf("%d", &nb);
  1199.  
  1200.                 total = 0;
  1201.                 for(i=0;i<nb;i++) //Pour chaque contenant
  1202.                 {
  1203.                     printf("Veuillez entrer le volume du contenant en mL : ");
  1204.                     scanf("%f", &volume);
  1205.                     if(volume > 100) printf("Desole, votre contenant ne peut depasser les 100mL.\n"); //Si le contenant dépasse 100mL, le passager ne peut pas le prendre avec lui.
  1206.                     else total += volume; //Sinon on ajoute le volume au total des volumes
  1207.                 }
  1208.  
  1209.                 if(total > 1000) //Si le total est supérieur à 1L, le passager doit recommencer la procédure pour prendre avec lui des contenants.
  1210.                 {
  1211.                     printf("Le volume total des contenants ne peut depasser 1000mL ! Votre volume : %.2f. Veuillez recommencer.\n", total);
  1212.                 }
  1213.             } while(total > 1000);
  1214.         }
  1215.  
  1216.         printf("Votre bagage a main possede-t-il un des objets parmis les suivants ?\n"); //On s'intéresse à ce que contient le bagage du passager, et on espère surtout qu'il est honnête, car notre aéroport est un peu vieux et n'a pas encore la technologie "Rayons X"
  1217.         printf("\t- Objet tranchant\n");
  1218.         printf("\t- Grande batterie lithium\n");
  1219.  
  1220.         int reponse;
  1221.         do {
  1222.             printf("Choix :\n");
  1223.             printf("\t1 - Oui\n");
  1224.             printf("\t2 - Non\n");
  1225.             scanf("%d", &reponse);
  1226.         } while(reponse < 1 || reponse > 2);
  1227.  
  1228.         if(reponse == 1) //On retire simplement les objets, rien ne se passe
  1229.         {
  1230.             printf("Les objets a caractere dangeureux ont ete retires.\n");
  1231.         }
  1232.  
  1233.         printf("Votre bagage a main possede-t-il un des objets parmis les suivants ?\n");
  1234.         printf("\t- Substances illicites\n");
  1235.         printf("\t- Armes\n");
  1236.         printf("\t- Explosif\n");
  1237.  
  1238.         do {
  1239.             printf("Choix :\n");
  1240.             printf("\t1 - Oui\n");
  1241.             printf("\t2 - Non\n");
  1242.             scanf("%d", &reponse);
  1243.         } while(reponse < 1 || reponse > 2);
  1244.  
  1245.         if(reponse == 1) //Ok, là le passager est dangeureux, et fou puisqu'il déclare de lui-même posséder ces objets
  1246.         {
  1247.             printf("Le passager a ete emmene au poste de police. Il n'apparait plus sur la liste de passagers.\n");
  1248.             struct Passenger *last = passengers[passengers_length-1]; //On va déplacer le passager en dernière position du tableau à la place du passager à supprimer
  1249.             passengers_size -= p->struct_size; //On soustrait la taille de l'élément p que nous allons supprimer à la taille totale dans la mémoire du tableau passengers
  1250.             p->flight->registered_passengers_count--; //On a supprimé un passager enregistré du vol
  1251.             p->flight->tickets_available++; //Et donc une place disponible de plus sur le vol
  1252.             p->flight->occupied_seats[last->seat] = 0;
  1253.             p = create_passenger(p, last->flight, last->last_name, last->first_name, last->priority, last->birthday, last->ticket, last->passport, last->nationality); //On copie (en quelques sortes) le dernier passager à la place de p
  1254.             free(last->luggages); //On libère la mémoire occupée par la dernière case du tableau
  1255.             free(last->last_name);
  1256.             free(last->first_name);
  1257.             free(last->nationality);
  1258.             free(last->passport);
  1259.             free(last);
  1260.             passengers_length--; //Une case en moins dans le tableau passengers
  1261.             passengers = (struct Passenger**) realloc(passengers, passengers_size); //On réalloue la mémoire à la bonne valeur
  1262.         }
  1263.         else //Ca va, le passager est normal il peut embarquer
  1264.         {
  1265.             printf("Tres bien. Vous allez pouvoir proceder a l'embarquement sous peu.\n");
  1266.             p->etape++; //Il passe à l'étape suivante
  1267.         }
  1268.     }
  1269.     else if(p != NULL && p->etape >= 3)
  1270.     {
  1271.         printf("%s %s a deja passe la securite !\n", p->first_name, p->last_name);
  1272.     }
  1273.     else if(p != NULL)
  1274.     {
  1275.         printf("%s %s ne peut pas encore passer la securite.\n", p->first_name, p->last_name);
  1276.     }
  1277. }
  1278.  
  1279. void board_passengers()
  1280. {// On embarque tous les passagers sur un vol
  1281.     printf("Affichage des vols.\n");
  1282.     show_flights(); //Affichage des vols
  1283.  
  1284.     int flight_id;
  1285.     printf("Veuillez entrer l'ID du vol sur lequel embarquer les passagers : ");
  1286.     do {
  1287.         scanf("%d", &flight_id);
  1288.         if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol.\n");
  1289.         else if(flights[flight_id]->took_off == 1) printf("Ce vol a deja decolle ! Annulation.\n");
  1290.     } while(flight_id > flights_length-1 || flight_id < 0);
  1291.  
  1292.     struct Flight *f = flights[flight_id]; //Le vol sur lequel les passagers vont essayer d'être embarqués
  1293.     struct Passenger **registered_passengers = get_registered_passengers_on_flight(flight_id); int registered_passengers_length = f->registered_passengers_count; //Tout ce que l'on a besoin de savoir sur les passagers enregistrés sur le vol
  1294.     struct Passenger **registered_passengers_priority = (struct Passenger**) malloc(0); int registered_passengers_priority_length = 0, registered_passengers_priority_size = 0; //Tout ce que l'on a besoin de savoir sur les passagers enregistrés et priotaires sur le vol
  1295.     struct Passenger **registered_passengers_no_priority = (struct Passenger**) malloc(0); int registered_passengers_no_priority_length = 0, registered_passengers_no_priority_size = 0; //Tout ce que l'on a besoin de savoir sur les passagers enregistrés et non-prioritaires sur le vol
  1296.     int i;
  1297.     for(i=0;i<registered_passengers_length;i++) //Pour chaque passager enregistré
  1298.     {
  1299.         if(registered_passengers[i]->etape == 3) //S'il vient de passer la sécurité
  1300.         {
  1301.             if(registered_passengers[i]->priority == 0) //S'il n'est pas prioritaire
  1302.             {
  1303.                 registered_passengers_no_priority_size += registered_passengers[i]->struct_size;
  1304.                 registered_passengers_no_priority = realloc(registered_passengers_no_priority, registered_passengers_no_priority_size);
  1305.                 registered_passengers_no_priority[registered_passengers_no_priority_length] = registered_passengers[i];
  1306.                 registered_passengers_no_priority_length++;
  1307.                 //On le met dans le tableau des non-prioritaires
  1308.             }
  1309.             else //Sinon
  1310.             {
  1311.                 registered_passengers_priority_size += registered_passengers[i]->struct_size;
  1312.                 registered_passengers_priority = realloc(registered_passengers_priority, registered_passengers_priority_size);
  1313.                 registered_passengers_priority[registered_passengers_priority_length] = registered_passengers[i];
  1314.                 registered_passengers_priority_length++;
  1315.                 //On le met dans le tableau des prioritaires
  1316.             }
  1317.         } //A noter, si le passager n'est pas exactement à l'étape 3, deux cas se distinguent. Soit le passager a déjà embarqué et alors tout va bien. Soit le passager n'a pas encore passé la sécurité et ne peut donc pas encore embarqué. Pour être attendu sur un vol, le passager doit s'être enregistré. Un simple achat du billet ne lui assure aucunement que le vol l'attende pour partir.
  1318.     }
  1319.  
  1320.     printf("Veuillez desormais confirmer l'embarquement de chaque passager sur l'avion. 1 pour confirmer, 0 pour retarder.\n");
  1321.     printf("Tant que tous les passagers n'auront pas embarque, l'avion ne pourra pas decoller.\n");
  1322.     printf("Embarquement des passagers prioritaires...\n");
  1323.  
  1324.     int confirmer;//On regarde si on peut décoller
  1325.     for(i=0;i<registered_passengers_priority_length;i++) //On commence (toujours) par s'occuper des passagers prioritaires qui ont passé la sécurité
  1326.     {
  1327.         struct Passenger* p = registered_passengers_priority[i];
  1328.         do {
  1329.             printf("Confirmer l'embarquement de %s %s : ", p->first_name, p->last_name);
  1330.             scanf("%d", &confirmer); //On demande à l'utilisateur s'il souhaite confirmer l'embarquement du passager
  1331.         } while(confirmer < 0 || confirmer > 1);
  1332.  
  1333.         if(confirmer == 1) //Confirmation
  1334.         {
  1335.             p->etape++; //Le passager est embarqué
  1336.             f->onboard_passengers_count++; //Un passager embarqué en plus sur le vol
  1337.             f->occupied_seats[p->seat] = 2; //Le passager est assis désormais
  1338.         }
  1339.     }
  1340.  
  1341.     if(f->onboard_passengers_count == registered_passengers_priority_length) //Si on a autant de passagers prioritaires dans l'avion que de passagers priotaires enregistrés
  1342.     {
  1343.         printf("Embarquement des passagers non-prioritaires...\n");
  1344.         for(i=0;i<registered_passengers_no_priority_length;i++) //On refait la même chose pour les non-prioritaires !
  1345.         {
  1346.             struct Passenger* p = registered_passengers_no_priority[i];
  1347.             do {
  1348.                 printf("Confirmer l'embarquement de %s %s : ", p->first_name, p->last_name);
  1349.                 scanf("%d", &confirmer);
  1350.             } while(confirmer < 0 || confirmer > 1);
  1351.  
  1352.             if(confirmer == 1)
  1353.             {
  1354.                 p->etape++;
  1355.                 f->onboard_passengers_count++;
  1356.                 f->occupied_seats[p->seat] = 2;
  1357.             }
  1358.         }
  1359.  
  1360.         printf("Affichage du vol avant le decollage...\n");
  1361.         show_occupied_seats_on_flight(f); //Affichage des passagers assis, des places réservées et des places libres dans le vol
  1362.  
  1363.         printf("Affichage de tous les passagers n'ayant pas embarques...\n");
  1364.         for(i=0;i<registered_passengers_length;i++) //On affiche les passagers qui n'ont pas encore embarqué (s'il y en a)
  1365.         {
  1366.             struct Passenger *p = registered_passengers[i];
  1367.             if(p->etape <= 3)
  1368.             {
  1369.                 printf("%s %s n'a pas embarque.\n", p->first_name, p->last_name);
  1370.             }
  1371.         }
  1372.     }
  1373.     else //Tous les passagers priotaires n'ont pas encore embarqué !
  1374.     {
  1375.         printf("Tous les passagers prioritaires n'ont pas encore embarques. L'embarquement des passagers non-prioritaires debutera lorsque tous les passagers prioritaires auront embarques.\n");
  1376.     }
  1377.  
  1378.     printf("Calcul du taux de remplissage de l'avion...\n");
  1379.  
  1380.     float taux = (float)f->onboard_passengers_count/f->seats * 100; //Niveau... 4ème ? 5ème ? Bref on fait un pourcentage
  1381.     printf("L'avion est rempli a %.2f%%\n", taux); //"L'avion est rempli à 20,00%" par exemple
  1382. }
  1383.  
  1384. void board_luggages()
  1385. { //Embarquement des bagages sur un vol
  1386.     printf("Affichage des vols.\n");
  1387.     show_flights();
  1388.  
  1389.     int flight_id;
  1390.     printf("Veuillez entrer l'ID du vol sur lequel charger les bagages : ");
  1391.     do {
  1392.         scanf("%d", &flight_id);
  1393.         if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol.\n");
  1394.         else if(flights[flight_id]->took_off == 1) printf("Ce vol a deja decolle ! Annulation.\n");
  1395.     } while(flight_id > flights_length-1 || flight_id < 0);
  1396.  
  1397.     printf("Chargement des bagages. 1 pour valider, 0 pour refuser.\n");
  1398.     struct Passenger **registered_passengers = get_registered_passengers_on_flight(flight_id); int registered_passengers_count = flights[flight_id]->registered_passengers_count; //On récupère tous les passagers enregistrés sur le vol
  1399.     int i;
  1400.     for(i=0;i<registered_passengers_count;i++) //Pour chaque passager
  1401.     {
  1402.         struct Passenger* p = registered_passengers[i];
  1403.         if(p->priority == 1) //Si le passager est prioritaire il peut avoir jusqu'à deux bagages
  1404.         {
  1405.             for(int j=0;j<2;j++) //Pour chaque bagage
  1406.             {
  1407.                 if(p->luggages[j] != NULL) //S'il possède un bagage
  1408.                 {
  1409.                     if(p->luggages[j]->boarded == 0) //Si le bagage n'est pas encore embarqué
  1410.                     {
  1411.                         int charger;
  1412.                         do {
  1413.                             printf("Charger le bagage #%d de %s %s qui pese %fkg : ", p->luggages[j]->ticket, p->first_name, p->last_name, p->luggages[j]->weight);
  1414.                             scanf("%d", &charger);
  1415.                         } while(charger < 0 || charger > 1);
  1416.  
  1417.                         if(charger == 1) //Il faut charger le bagage
  1418.                         {
  1419.                             p->luggages[j]->boarded = 1; //Le bagage est chargé
  1420.                             p->flight->luggages_weight += p->luggages[j]->weight; //L'avion pèse un peu plus lourd
  1421.                         }
  1422.                     }
  1423.                 }
  1424.             }
  1425.         }
  1426.         else //Si le passager n'est pas priotaire il peut avoir un seul bagage
  1427.         {
  1428.             if(p->luggages[0] != NULL) //Si il possède un bagage
  1429.             {
  1430.                 if(p->luggages[0] != NULL && p->luggages[0]->boarded == 0) //Si le bagage n'est pas chargé
  1431.                 {
  1432.                     int charger;
  1433.                     do {
  1434.                         printf("Charger le bagage #%d de %s %s qui pese %fkg :", p->luggages[0]->ticket, p->first_name, p->last_name, p->luggages[0]->weight);
  1435.                         scanf("%d", &charger);
  1436.                     } while(charger < 0 || charger > 1);
  1437.  
  1438.                     if(charger == 1) //Il faut charger le bagage
  1439.                     {
  1440.                         p->luggages[0]->boarded = 1; //Le bagage est chargé
  1441.                         p->flight->luggages_weight += p->luggages[0]->weight; //L'avion est plus lourd
  1442.                     }
  1443.                 }
  1444.             }
  1445.         }
  1446.     }
  1447. }
  1448.  
  1449. void flight_take_off()
  1450. { //On va (enfin ??!) pouvoir décoller
  1451.     printf("Affichage des vols.\n");
  1452.     show_flights();
  1453.  
  1454.     int flight_id;
  1455.     printf("Veuillez entrer l'ID du vol qui est sur le point de decoller : ");
  1456.     do {
  1457.         scanf("%d", &flight_id);
  1458.         if(flight_id > flights_length-1 || flight_id < 0) printf("Ce vol n'existe pas. Veuillez entrer l'ID du vol.\n");
  1459.         else if(flights[flight_id]->took_off == 1) printf("Ce vol a deja decolle ! Annulation.\n");
  1460.     } while(flight_id > flights_length-1 || flight_id < 0);
  1461.  
  1462.     printf("Verification que tous les passagers ont embarque et que tous leurs bagages sont charges.\n");
  1463.     struct Flight *f = flights[flight_id]; //Vol à faire décoller
  1464.     struct Passenger **registered_passengers = get_registered_passengers_on_flight(flight_id); int registered_passengers_count = f->registered_passengers_count; //Passagers à faire décoller (dans l'avion...)
  1465.     int i;
  1466.     for(i=0;i<registered_passengers_count;i++)
  1467.     {
  1468.         if(registered_passengers[i]->etape < 4) //Si un des passagers enregistré n'est pas à l'étape 4 qui correspond à l'embarquement, l'avion ne peut pas décoller
  1469.         {
  1470.             printf("Tous les passagers n'ont pas encore embarque ! Veuillez proceder a l'embarquement de tous les passagers avant de continuer.\n");
  1471.             return;
  1472.         }
  1473.  
  1474.         for(int j=0;j<2;j++) //Pour chaque bagage
  1475.         {
  1476.             if(registered_passengers[i]->luggages[j] != NULL && registered_passengers[i]->luggages[j]->boarded == 0) //Si le bagage existe, et s'il n'est pas chargé, l'avion ne peut pas décoller
  1477.             {
  1478.                 printf("Tous les bagages n'ont pas encore ete charges ! Veuillez proceder au chargement de tous les bagages avant de continuer.\n");
  1479.                 return;
  1480.             }
  1481.         }
  1482.     }
  1483.  
  1484.     //On est arrivés jusque là ! Cela signifie que tout va bien, l'avion peut décoller.
  1485.  
  1486.     printf("Tous les passagers et tous leurs bagages ont ete embarques. Le vol va desormais decoller.\n");
  1487.     for(i=0;i<registered_passengers_count;i++)
  1488.     {
  1489.         registered_passengers[i]->etape++; //Tous les passagers sont désomais en vol
  1490.     }
  1491.  
  1492.     f->took_off = 1; //Félicitations, l'avion est parvenu à décoller !
  1493. }
  1494.  
  1495. struct Passenger* find_passenger(char* name, int ticket) //On trouve un passager en fonction de son nom ou de son billet
  1496. {
  1497.     if(ticket != -1) //Si on trouve le passager en fonction de son billet
  1498.     {
  1499.         int found = 0; //On ne l'a pas encore trouvé
  1500.  
  1501.         for(i=0;i<passengers_length;i++) //Pour chaque passager
  1502.         {
  1503.             if(passengers[i]->ticket == ticket) //Le billet du passager est le même que celui demandé !
  1504.             {
  1505.                 found = 1; //On a donc trouvé le passager
  1506.                 break; //On peut y aller
  1507.             }
  1508.         }
  1509.  
  1510.         if(found != 1) //Ohoh... Nous ne sommes pas parvenus à trouver un passager avec ce billet
  1511.         {
  1512.             printf("Desole, le passager avec le ticket #%d n'a pas ete trouve.\n", ticket);
  1513.             return NULL; //On renvoie NULL afin de gérer le cas dans les autres fonctions
  1514.         }
  1515.         else //On a trouvé le passager
  1516.         {
  1517.             return passengers[i]; //On renvoie un pointeur vers le passager demandé
  1518.         }
  1519.     }
  1520.     else //On cherche le passager en fonction de son nom
  1521.     {
  1522.         struct Passenger** occ; //Il se peut que plusieurs passagers aient le même nom, donc on prévoit un tableau pour tous les accueillir
  1523.         int occ_size = 0, lastPos; //La taille du tableau et la position du passager à renvoyer si plusieurs portent le même nom
  1524.  
  1525.         occ = (struct Passenger**) malloc(sizeof(struct Passenger*)); //On a une place
  1526.  
  1527.  
  1528.         for(i=0;i<passengers_length;i++) //Pour chaque passager existant
  1529.         {
  1530.             if(strcmp(name, passengers[i]->last_name) == 0) //Si le nom est le même que celui demandé
  1531.             {
  1532.                 occ = (struct Passenger**) realloc(occ, sizeof(occ) + sizeof(struct Passenger*));
  1533.                 occ[occ_size] = passengers[i];
  1534.                 occ_size++; //On ajoute le passager au tableau des passagers avec le nom demandé
  1535.                 lastPos = i; //On se remémore la position de la dernière occurence dans le tableau des passagers
  1536.             }
  1537.         }
  1538.  
  1539.         if(occ_size == 0) //Si le tableau est vide
  1540.         {
  1541.             printf("Aucun passager avec ce nom n'a ete trouve.\n");
  1542.             return NULL; //On a pas trouvé
  1543.         }
  1544.         else if(occ_size == 1) //Si un seul passager a été trouvé
  1545.         {
  1546.             return passengers[lastPos]; //On renvoie un pointeur
  1547.         }
  1548.         else //On en a trouvé plus d'un
  1549.         {
  1550.             printf("Plusieurs passagers avec ce nom ont ete trouves.\n");
  1551.  
  1552.             for(i=0;i<occ_size;i++)
  1553.             {
  1554.                 printf("%d - %s %s\n", i, occ[i]->last_name, occ[i]->first_name); //On affiche tous les passagers avec ce nom
  1555.             }
  1556.  
  1557.             do {
  1558.                 printf("Entrer le numero de la personne a choisir.\n");
  1559.                 scanf("%d", &lastPos); getchar(); //On demande à l'utilisateur de choisir le passager
  1560.             } while(lastPos < 0 || lastPos > occ_size-1);
  1561.  
  1562.             return occ[lastPos]; //Et on renvoie un pointeur vers ce passager
  1563.         }
  1564.     }
  1565. }
  1566.  
  1567. struct Passenger** get_registered_passengers_on_flight(int id) //Renvoie tous les passagers enregistrés sur un vol demandé
  1568. {
  1569.     int i, counter = 0;
  1570.     struct Passenger** registered_passengers;
  1571.     for(i=0;i<passengers_length;i++) //Pour chaque passager existant
  1572.     {
  1573.         if(passengers[i]->etape >= 1 && passengers[i]->flight == flights[id]) //Si le passager est enregistré et que le vol est le même que celui demandé
  1574.         {  
  1575.             if(counter == 0) //Si c'est le premier passager trouvé
  1576.             {
  1577.                 registered_passengers = (struct Passenger**) malloc(sizeof(struct Passenger*)); //On alloue pour la première de la mémoire pour renvoyer nos pointeurs
  1578.             }
  1579.             else
  1580.             {
  1581.                 registered_passengers = (struct Passenger**) realloc(registered_passengers, sizeof(registered_passengers) + sizeof(struct Passenger*)); //On réalloue la mémoire à chaque nouveau passager
  1582.             }
  1583.  
  1584.             registered_passengers[counter] = passengers[i]; //On affecte le nouveau passager au tableau des passagers enregistrés sur le vol
  1585.             counter++;
  1586.             if(counter == flights[id]->registered_passengers_count) break; //Si on a trouvé autant de passagers enregistrés qu'il y en a sur le vol, on peut s'arrêter (et gagner quelques millisecondes !)
  1587.         }
  1588.     }
  1589.  
  1590.     return registered_passengers; //On renvoie les pointeurs vers les passagers enregistrés
  1591. }
  1592.  
  1593. char* input_string() //Fonction faite main pour affecter directement une entrée utilisateur à un pointeur char
  1594. {
  1595.     int n = 0;
  1596.     char *c = (char*) malloc(1);
  1597.     char saisie = getchar();
  1598.     while(saisie != '\n')
  1599.     {
  1600.         c[n] = saisie;
  1601.         saisie = getchar();
  1602.         n++;
  1603.         c = (char*) realloc(c, n+1);
  1604.     }
  1605.  
  1606.     c[n] = '\0';
  1607.  
  1608.     return c;
  1609. }
RAW Paste Data