diff --git a/CosmicYonder.h b/CosmicYonder.h
index 083830a..4569222 100644
--- a/CosmicYonder.h
+++ b/CosmicYonder.h
@@ -235,8 +235,8 @@ void invBoucle(WINDOW *mainwin, int *touche, InvMenu *invMenu, Inventaire* inven
 
     // SAUVEGARDE
 void sauvegardeBoucle(WINDOW * mainwin, EntreeTexte * sauve, int x, int y, int hauteur, int longueur, int* touche);
-void saveGame(Partie * partie, char * nomFichier);
-Partie * loadGame(char * nomFichier);
+void sauveJeu(Partie * partie, char * nomFichier);
+Partie * chargerJeu(char * nomFichier);
 int verifFichier(char * nomSauvegarde);
     //JEU
 Partie * creerPartie();
diff --git a/json/json.c b/json/json.c
index 9d1549a..825d600 100644
--- a/json/json.c
+++ b/json/json.c
@@ -12,15 +12,15 @@
 #include "../logger.h"
 
 
-char * skipSpaces(char *str) { // ignore les espaces
+char * sauteEspaces(char *str) { // ignore les espaces
     while(isspace(*str)) {
         str++;
     }
     return str;
 }
 
-int chrLookup(char **str, char chr) { // place le caractère recherché en index 0 de la chaine de caractères
-    *str = skipSpaces(*str);
+int chercheChar(char **str, char chr) { // place le caractère recherché en index 0 de la chaine de caractères
+    *str = sauteEspaces(*str);
     if (**str == chr) {
         (*str)++;
         return 1;
@@ -28,7 +28,7 @@ int chrLookup(char **str, char chr) { // place le caractère recherché en index
     return 0;
 }
 
-int intLength(int i) { // retourne la longueur d'un entier, plus rapide que log10()
+int longueurInt(int i) { // retourne la longueur d'un entier, plus rapide que log10()
     if(i < 0) {
         i = -i;
     }
@@ -62,8 +62,8 @@ int intLength(int i) { // retourne la longueur d'un entier, plus rapide que log1
     return 1;
 }
 
-char * parseJSONString(char **str) {
-    *str = skipSpaces(*str);
+char * parserChaineJSON(char **str) {
+    *str = sauteEspaces(*str);
     if (**str != '"') { // pas une chaine de caractères
         return NULL;
     }
@@ -80,7 +80,7 @@ char * parseJSONString(char **str) {
     char * result = NULL;
     result = malloc(length + 1);
     if (result == NULL) {
-        logMessage(CRITICAL, "erreur malloc result parseJSONString");
+        logMessage(CRITICAL, "erreur malloc result parserChaineJSON");
         exit(1);
     }
 
@@ -90,13 +90,13 @@ char * parseJSONString(char **str) {
     return result;
 }
 
-int parseJSONInt(char **str, int sign) {
-    *str = skipSpaces(*str);
+int parserEntierJSON(char **str, int sign) {
+    *str = sauteEspaces(*str);
     int result;
     int verif = -1;
     verif = sscanf(*str, "%d", &result);
     if(verif != 1) {
-        logMessage(CRITICAL, "erreur sscanf parseJSONInt");
+        logMessage(CRITICAL, "erreur sscanf parserEntierJSON");
     }
     while(isdigit(**str)) { // déplace le curseur
         (*str)++;
@@ -107,8 +107,8 @@ int parseJSONInt(char **str, int sign) {
     return result;
 }
 
-int parseJSONBool(char **str) {
-    *str = skipSpaces(*str);
+int parserBooleenJSON(char **str) {
+    *str = sauteEspaces(*str);
     if (strncmp(*str, "true", 4) == 0) {
         *str += 4;
         return 1;
@@ -116,60 +116,60 @@ int parseJSONBool(char **str) {
         *str += 5;
         return 0;
     }
-    logMessage(CRITICAL, "erreur parse parseJSONBool");
+    logMessage(CRITICAL, "erreur parse parserBooleenJSON");
     return -1; // Erreur
 }
 
-JSONArray * parseJSONArray(char **str) {
-    if (!chrLookup(str, '[')) {
-        logMessage(CRITICAL, "erreur parseJSONArray, [ manquant");
+JSONArray * parserTabJSON(char **str) {
+    if (!chercheChar(str, '[')) {
+        logMessage(CRITICAL, "erreur parserTabJSON, [ manquant");
         exit(1); // Erreur
     }
     JSONArray * array = NULL;
     array = malloc(sizeof(JSONArray));
     if(array == NULL) {
-        logMessage(CRITICAL, "erreur malloc array parseJSONArray");
+        logMessage(CRITICAL, "erreur malloc array parserTabJSON");
         exit(1);
     }
     array->values = NULL;
     array->length = 0;
 
-    while (!chrLookup(str, ']')) {
-        JSONKeyValuePair pair; //creation du couple clé-valeur
-        pair.value = parseJSONValue(str);
-        array->values = realloc(array->values, sizeof(JSONKeyValuePair) * (array->length + 1)); // agrandit l'allocation mémoire des valeurs
+    while (!chercheChar(str, ']')) {
+        JSONCleValeurCouple pair; //creation du couple clé-valeur
+        pair.value = parserValeurJSON(str);
+        array->values = realloc(array->values, sizeof(JSONCleValeurCouple) * (array->length + 1)); // agrandit l'allocation mémoire des valeurs
         array->values[array->length++] = pair;
-        chrLookup(str, ','); // avance à la virgule suivante
+        chercheChar(str, ','); // avance à la virgule suivante
     }
 
     return array;
 
 }
 
-JSONValue parseJSONValue(char **str) {
-    *str = skipSpaces(*str);
-    JSONValue v;
+JSONValeur parserValeurJSON(char **str) {
+    *str = sauteEspaces(*str);
+    JSONValeur v;
     if (**str == '"') {
-        v.type = JSON_STRING;
-        v.stringValue = parseJSONString(str);
+        v.type = JSON_CHAINE;
+        v.stringValue = parserChaineJSON(str);
     } else if (**str == '{') {
-        v.type = JSON_OBJECT;
-        v.objectValue = parseJSONObject(str);
+        v.type = JSON_OBJET;
+        v.objectValue = parserObjetJSON(str);
     } else if (**str == '[') {
-        v.type = JSON_ARRAY;
-        v.arrayValue = parseJSONArray(str);
+        v.type = JSON_TABLEAU;
+        v.arrayValue = parserTabJSON(str);
     } else if (**str == '-') {
         (*str)++;
-        v.type = JSON_NUMBER;
-        v.numberValue = parseJSONInt(str, 0);
+        v.type = JSON_NOMBRE;
+        v.numberValue = parserEntierJSON(str, 0);
     } else if (isdigit(**str)) {
-        v.type = JSON_NUMBER;
-        v.numberValue = parseJSONInt(str, 1);
+        v.type = JSON_NOMBRE;
+        v.numberValue = parserEntierJSON(str, 1);
     } else if (strncmp(*str, "true", 4) == 0 || strncmp(*str, "false", 5) == 0) {
         v.type = JSON_BOOL;
-        v.boolValue = parseJSONBool(str);
+        v.boolValue = parserBooleenJSON(str);
     } else {
-        logMessage(CRITICAL, "erreur parseJSONValue");
+        logMessage(CRITICAL, "erreur parserValeurJSON");
         v.type = JSON_NULL; // Erreur
     }
     return v;
@@ -177,63 +177,63 @@ JSONValue parseJSONValue(char **str) {
 
 
 
-JSONObject * parseJSONObject(char ** str) {
-    if (!chrLookup(str, '{')) {
-        logMessage(CRITICAL, "erreur parseJSONObject, { manquant");
+JSONObjet * parserObjetJSON(char ** str) {
+    if (!chercheChar(str, '{')) {
+        logMessage(CRITICAL, "erreur parserObjetJSON, { manquant");
         exit(1); // Erreur
     }
-    JSONObject * object = NULL;
-    object = malloc(sizeof(JSONObject));
+    JSONObjet * object = NULL;
+    object = malloc(sizeof(JSONObjet));
     if(object == NULL) {
-        logMessage(CRITICAL, "erreur malloc object parseJSONObject");
+        logMessage(CRITICAL, "erreur malloc object parserObjetJSON");
         exit(1);
     }
     object->pairs = NULL;
     object->length = 0;
 
-    while (!chrLookup(str, '}')) {
-        JSONKeyValuePair pair;
-        pair.key = parseJSONString(str);
-        if (!pair.key || !chrLookup(str, ':')) {
+    while (!chercheChar(str, '}')) {
+        JSONCleValeurCouple pair;
+        pair.key = parserChaineJSON(str);
+        if (!pair.key || !chercheChar(str, ':')) {
             free(object);
-            logMessage(CRITICAL, "erreur parseJSONObject, : manquant");
+            logMessage(CRITICAL, "erreur parserObjetJSON, : manquant");
             exit(1); // Erreur
         }
-        pair.value = parseJSONValue(str);
-        object->pairs = realloc(object->pairs, sizeof(JSONKeyValuePair) * (object->length + 1)); // agrandit l'allocation mémoire  des couples clé-valeur
+        pair.value = parserValeurJSON(str);
+        object->pairs = realloc(object->pairs, sizeof(JSONCleValeurCouple) * (object->length + 1)); // agrandit l'allocation mémoire  des couples clé-valeur
         object->pairs[object->length++] = pair;
-        chrLookup(str, ','); // avance à la virgule suivante
+        chercheChar(str, ','); // avance à la virgule suivante
     }
     return object;
 }
 
-char * serializeJSONString(JSONValue str) {
+char * serializeChaineJSON(JSONValeur str) {
     char * result = NULL;
     result = malloc(strlen(str.stringValue) + 3);
     if (result == NULL) {
-        logMessage(CRITICAL, "erreur malloc result serializeJSONString");
+        logMessage(CRITICAL, "erreur malloc result serializeChaineJSON");
         exit(1);
     }
     sprintf(result, "\"%s\"", str.stringValue);
     return result;
 }
 
-char * serializeJSONInt(JSONValue i) {
+char * serializeEntierJSON(JSONValeur i) {
     char * result = NULL;
-    result = malloc(sizeof(char) * intLength(i.numberValue) + 1);
+    result = malloc(sizeof(char) * longueurInt(i.numberValue) + 1);
     if (result == NULL) {
-        logMessage(CRITICAL, "erreur malloc result serializeJSONInt");
+        logMessage(CRITICAL, "erreur malloc result serializeEntierJSON");
         exit(1);
     }
     sprintf(result, "%d", i.numberValue);
     return result;
 }
 
-char * serializeJSONBool(JSONValue b) {
+char * serializeBooleenJSON(JSONValeur b) {
     char * result = NULL;
     result = malloc(sizeof(char) * 6);
     if (result == NULL) {
-        logMessage(CRITICAL, "erreur malloc result serializeJSONBool");
+        logMessage(CRITICAL, "erreur malloc result serializeBooleenJSON");
         exit(1);
     }
     if (b.boolValue) {
@@ -244,36 +244,36 @@ char * serializeJSONBool(JSONValue b) {
     return result;
 }
 
-char * serializeJSONArray(JSONArray a) {
+char * serializeTabJSON(JSONArray a) {
     char * result = NULL;
     char * finalString = NULL;
     char * value = NULL;
 
     result = malloc(sizeof(char));
     if (result == NULL) {
-        logMessage(CRITICAL, "erreur malloc result serializeJSONArray");
+        logMessage(CRITICAL, "erreur malloc result serializeTabJSON");
         exit(1);
     }
     result[0] = '\0';
     for (int i = 0; i < a.length; i++) {
         switch (a.values[i].value.type) {
-            case JSON_STRING:
-                value = serializeJSONString(a.values[i].value);
+            case JSON_CHAINE:
+                value = serializeChaineJSON(a.values[i].value);
                 break;
-            case JSON_NUMBER:
-                value = serializeJSONInt(a.values[i].value);
+            case JSON_NOMBRE:
+                value = serializeEntierJSON(a.values[i].value);
                 break;
             case JSON_BOOL:
-                value = serializeJSONBool(a.values[i].value);
+                value = serializeBooleenJSON(a.values[i].value);
                 break;
-            case JSON_OBJECT:
-                value = serializeJSONObject(*a.values[i].value.objectValue);
+            case JSON_OBJET:
+                value = serializeObjetJSON(*a.values[i].value.objectValue);
                 break;
-            case JSON_ARRAY:
-                value = serializeJSONArray(*a.values[i].value.arrayValue);
+            case JSON_TABLEAU:
+                value = serializeTabJSON(*a.values[i].value.arrayValue);
                 break;
             default:
-                logMessage(CRITICAL, "erreur serializeJSONArray");
+                logMessage(CRITICAL, "erreur serializeTabJSON");
                 exit(1);
         }
         result = realloc(result, strlen(result) + strlen(value) + 2);
@@ -286,7 +286,7 @@ char * serializeJSONArray(JSONArray a) {
     }
     finalString = malloc(strlen(result) + 3);
     if (finalString == NULL) {
-        logMessage(CRITICAL, "erreur malloc finalResult serializeJSONArray");
+        logMessage(CRITICAL, "erreur malloc finalResult serializeTabJSON");
         exit(1);
     }
     sprintf(finalString, "[%s]", result);
@@ -294,36 +294,36 @@ char * serializeJSONArray(JSONArray a) {
     return finalString;
 }
 
-char * serializeJSONObject(JSONObject o) {
+char * serializeObjetJSON(JSONObjet o) {
     char * result = NULL;
     char * value = NULL;
     char * finalString = NULL;
 
     result = malloc(sizeof(char));
     if (result == NULL) {
-        logMessage(CRITICAL, "erreur malloc result serializeJSONObject");
+        logMessage(CRITICAL, "erreur malloc result serializeObjetJSON");
         exit(1);
     }
     result[0] = '\0';
     for (int i = 0; i < o.length; i++) {
         switch (o.pairs[i].value.type) {
-            case JSON_STRING:
-                value = serializeJSONString(o.pairs[i].value);
+            case JSON_CHAINE:
+                value = serializeChaineJSON(o.pairs[i].value);
                 break;
-            case JSON_NUMBER:
-                value = serializeJSONInt(o.pairs[i].value);
+            case JSON_NOMBRE:
+                value = serializeEntierJSON(o.pairs[i].value);
                 break;
             case JSON_BOOL:
-                value = serializeJSONBool(o.pairs[i].value);
+                value = serializeBooleenJSON(o.pairs[i].value);
                 break;
-            case JSON_OBJECT:
-                value = serializeJSONObject(*o.pairs[i].value.objectValue);
+            case JSON_OBJET:
+                value = serializeObjetJSON(*o.pairs[i].value.objectValue);
                 break;
-            case JSON_ARRAY:
-                value = serializeJSONArray(*o.pairs[i].value.arrayValue);
+            case JSON_TABLEAU:
+                value = serializeTabJSON(*o.pairs[i].value.arrayValue);
                 break;
             default:
-                logMessage(CRITICAL, "erreur serializeJSONObject");
+                logMessage(CRITICAL, "erreur serializeObjetJSON");
                 exit(1);
         }
         result = realloc(result, strlen(result) + strlen(o.pairs[i].key) + strlen(value) + 5);
@@ -340,7 +340,7 @@ char * serializeJSONObject(JSONObject o) {
 
     finalString = malloc(strlen(result) + 3); // + accolades et \0
     if (finalString == NULL) {
-        logMessage(CRITICAL, "erreur malloc finalString serializeJSONObject");
+        logMessage(CRITICAL, "erreur malloc finalString serializeObjetJSON");
         exit(1);
     }
     sprintf(finalString, "{%s}", result); // ajoute les accolades
diff --git a/json/json.h b/json/json.h
index 041e1f5..51be1b8 100644
--- a/json/json.h
+++ b/json/json.h
@@ -7,10 +7,10 @@
 #define JSON_H
 
 typedef enum {
-    JSON_STRING,
-    JSON_NUMBER,
-    JSON_OBJECT,
-    JSON_ARRAY,
+    JSON_CHAINE,
+    JSON_NOMBRE,
+    JSON_OBJET,
+    JSON_TABLEAU,
     JSON_BOOL,
     JSON_NULL,
 }JSONType;
@@ -22,41 +22,41 @@ typedef struct {
         char *stringValue;
         int numberValue;
         int boolValue;
-        struct JSONObject *objectValue;
+        struct JSONObjet *objectValue;
         struct JSONArray *arrayValue;
     };
-} JSONValue;
+} JSONValeur;
 
 // Structure pour une paire clé-valeur d'un objet JSON
-typedef struct JSONKeyValuePair {
+typedef struct JSONCleValeurCouple {
     char *key;
-    JSONValue value;
-} JSONKeyValuePair;
+    JSONValeur value;
+} JSONCleValeurCouple;
 
 // Structure pour un objet JSON
-typedef struct JSONObject {
-    JSONKeyValuePair *pairs;
+typedef struct JSONObjet {
+    JSONCleValeurCouple *pairs;
     int length;
-} JSONObject;
+} JSONObjet;
 
 // Structure pour un tableau JSON
 typedef struct JSONArray {
-    JSONKeyValuePair *values;
+    JSONCleValeurCouple *values;
     int length;
 } JSONArray;
 
-JSONObject * parseJSONObject(char **str);
-JSONValue parseJSONValue(char **str);
-JSONArray * parseJSONArray(char **str);
-int parseJSONBool(char **str);
-int parseJSONInt(char **str, int sign);
-char * parseJSONString(char **str);
-int chrLookup(char **str, char chr);
-char * skipSpaces(char *str);
-int intLength(int i);
-
-char * serializeJSONObject(JSONObject o);
-char * serializeJSONArray(JSONArray a);
-char * serializeJSONBool(JSONValue b);
-char * serializeJSONInt(JSONValue i);
+JSONObjet * parserObjetJSON(char **str);
+JSONValeur parserValeurJSON(char **str);
+JSONArray * parserTabJSON(char **str);
+int parserBooleenJSON(char **str);
+int parserEntierJSON(char **str, int sign);
+char * parserChaineJSON(char **str);
+int chercheChar(char **str, char chr);
+char * sauteEspaces(char *str);
+int longueurInt(int i);
+
+char * serializeObjetJSON(JSONObjet o);
+char * serializeTabJSON(JSONArray a);
+char * serializeBooleenJSON(JSONValeur b);
+char * serializeEntierJSON(JSONValeur i);
 #endif // JSON_H
diff --git a/main.c b/main.c
index 06cc58c..ede06f6 100644
--- a/main.c
+++ b/main.c
@@ -7,6 +7,19 @@
 int main()
 {
     int hauteur, longueur;
+    int etatPartie = 1; // permet de quitter la partie si besoin
+    int etatSauvegarde = 0; // effectue une sauvegarde si égal à 1
+    Partie * partie = NULL;
+
+    Menu * menu = NULL;
+    MiniMenu * pause = NULL;
+    InvMenu * inventMenu = NULL;
+    EntreeTexte * graineEntree = NULL;
+    EntreeTexte * nomEntree = NULL;
+    EntreeTexte * sauvegardeEntree = NULL;
+    HUD * hud = NULL;
+    Texte * resTxt = NULL;
+
 
     char logBuffer[255];
 
@@ -40,18 +53,18 @@ int main()
 
 	while(etatJeu){
 
-		int etatPartie = 1; // permet de quitter la partie si besoin
-        int etatSauvegarde = 0; // effectue une sauvegarde si égal à 1
-		Partie * partie = creerPartie();
+		etatPartie = 1;
+        etatSauvegarde = 0;
+		partie = creerPartie();
 
 
-		Menu * menu = cosmicMenu(hauteur, longueur); //affiche le menu
-		MiniMenu * parametres = options(longueur / 2, hauteur / 2, hauteur / 2, longueur / 2);
-		MiniMenu * pause = pauseMenu(longueur / 2, hauteur / 2, hauteur / 2, longueur / 2);
-        InvMenu * inventMenu = initInvMenu(longueur / 2, hauteur / 2, hauteur / 2, longueur / 2);
-		EntreeTexte * graineEntree = graineMenu(longueur / 2 - longueur/8, hauteur / 2 - hauteur / 8, hauteur / 3, longueur / 3);
-        EntreeTexte * nomEntree = nomMenu(longueur / 2 - longueur/8, hauteur / 2 - hauteur / 8, hauteur / 3, longueur / 3);
-        EntreeTexte * sauvegardeEntree = sauvegardeMenu(longueur / 2 - longueur/8, hauteur / 2 - hauteur / 8, hauteur / 3, longueur / 3);
+		menu = cosmicMenu(hauteur, longueur); //affiche le menu
+        pause = pauseMenu(longueur / 2, hauteur / 2, hauteur / 2, longueur / 2);
+        inventMenu = initInvMenu(longueur / 2, hauteur / 2, hauteur / 2, longueur / 2);
+		graineEntree = graineMenu(longueur / 2 - longueur/8, hauteur / 2 - hauteur / 8, hauteur / 3, longueur / 3);
+        nomEntree = nomMenu(longueur / 2 - longueur/8, hauteur / 2 - hauteur / 8, hauteur / 3, longueur / 3);
+        sauvegardeEntree = sauvegardeMenu(longueur / 2 - longueur/8, hauteur / 2 - hauteur / 8, hauteur / 3, longueur / 3);
+        resTxt = respawnTexte(longueur/2 - longueur/5, hauteur/2 - hauteur/5, longueur);
 
 		renduFenetreMenu(mainwin, *menu, hauteur, longueur);
 
@@ -107,7 +120,7 @@ int main()
 				wclear(mainwin);
                 do {
                     sauvegardeEntree->valide = 0;
-                    while(sauvegardeEntree->valide == 0) {
+                    while(sauvegardeEntree->valide == 0 && sauvegardeEntree->quitter == 0) {
                         touche = wgetch(mainwin);
                         renduFenetreEntree(mainwin, sauvegardeEntree, longueur / 2 - longueur/8, hauteur / 2 - hauteur / 8, hauteur / 3, longueur / 3);
                         entreeTexte(sauvegardeEntree, touche);
@@ -124,23 +137,14 @@ int main()
                         wattroff(mainwin, COLOR_PAIR(1));
                     }
 
-                } while (!fichier_exists);
-                partie = loadGame(sauvegardeEntree->buffer);
-
+                } while (!fichier_exists && sauvegardeEntree->quitter == 0);
+                if(sauvegardeEntree->quitter == 1) {
+                    endwin();
+                    moveLog();
+                }
+                partie = chargerJeu(sauvegardeEntree->buffer);
                 break;
 			case 2:
-				wclear(mainwin);
-				while(parametres->curseur !=3) {
-					renduFenetreOptions(mainwin, *parametres);
-					touche = wgetch(mainwin);
-					entreeMessage(parametres, touche);
-					wrefresh(mainwin);
-					napms(1000 / IMAGES_PAR_SECONDE);
-
-				}
-				break;
-			case 3:
-				// NOT IMPLEMENTED
 				endwin();//ferme la fenetre
 				moveLog();
 				return 0;
@@ -148,15 +152,11 @@ int main()
 				break;
 		}
 
-		HUD * hud = hudJeu(0, hauteur - hauteur/6, hauteur / 6, longueur, partie->joueur, partie->minuteur);
-		Texte * resTxt = respawnTexte(longueur/2 - longueur/5, hauteur/2 - hauteur/5, longueur);
-
-		
-
 		//positionne le joueur au centre de l ecran
         wattron(mainwin, COLOR_PAIR(3));
         mvwaddch(mainwin,partie->joueur->y,partie->joueur->x, 'o');
         wattroff(mainwin, COLOR_PAIR(3));
+        hud = hudJeu(0, hauteur - hauteur/6, hauteur / 6, longueur, partie->joueur, partie->minuteur);
 
 		touche = wgetch(mainwin);//recupere touche pressee
 
@@ -232,7 +232,7 @@ int main()
 				}
 			}	
 			//efface l'ecran	
-			wclear(mainwin);
+			werase(mainwin);
 			//affiche carte
 			dessineSalles(mainwin, partie->carte, partie->salles_existantes);
 			//affiche ennemis
@@ -280,7 +280,7 @@ int main()
             if(etatSauvegarde) {
                 etatSauvegarde = 0;
                 sauvegardeBoucle(mainwin, sauvegardeEntree, longueur / 2 - longueur/8, hauteur / 2 - hauteur / 8, hauteur, longueur, &touche);
-                saveGame(partie, sauvegardeEntree->buffer);
+                sauveJeu(partie, sauvegardeEntree->buffer);
             }
 		}
 		
@@ -289,6 +289,23 @@ int main()
 		free(partie->carte);
 		freeMenu(menu);
 		werase(mainwin);
+        free(partie);
+        free(pause);
+        free(inventMenu);
+        free(graineEntree);
+        free(nomEntree);
+        free(sauvegardeEntree);
+        freeHUD(hud);
+        free(resTxt);
+        partie = NULL;
+        pause = NULL;
+        inventMenu = NULL;
+        graineEntree = NULL;
+        nomEntree = NULL;
+        sauvegardeEntree = NULL;
+        hud = NULL;
+        resTxt = NULL;
+
 	}
 		endwin();//ferme la fenetre
 		moveLog();
diff --git a/partie.c b/partie.c
index e1dcd1b..9dd50c8 100644
--- a/partie.c
+++ b/partie.c
@@ -11,16 +11,21 @@ Partie * creerPartie() {
 		logMessage(CRITICAL, "erreur malloc partie");
 		exit(1);
 	}
+    partie->joueur = NULL;
 	partie->joueur = malloc(sizeof(Joueur));
 	if(partie->joueur == NULL) {
 		logMessage(CRITICAL, "erreur malloc joueur");
 		exit(1);
 	}
-	partie->carte = malloc(MAX_SALLES * sizeof(Salle));
+    partie->carte = NULL;
+	partie->carte = malloc(MAX_SALLES * sizeof(Salle*));
 	if(partie->carte == NULL) {
 		logMessage(CRITICAL, "erreur malloc carte");
 		exit(1);
 	}
+    for(int i = 0; i < MAX_SALLES; i++) {
+        partie->carte[i] = NULL;
+    }
 	partie->salles_existantes = 0; 	//compteur de salles existantes
 	partie->objets_speciaux_apparus = 0;  //Compteur des objets à récupérer pour gagner apparus
 	partie->portesNonOuvertes = 0;//Compte les portes non ouvertes sur la carte
diff --git a/sauvegarde.c b/sauvegarde.c
index 2c99415..2cb7f79 100644
--- a/sauvegarde.c
+++ b/sauvegarde.c
@@ -8,35 +8,36 @@
 #include "logger.h"
 #include "CosmicYonder.h"
 
-JSONObject * objetToJSONObj(Objet objet) {
-    JSONObject * objetJSON = NULL;
-    objetJSON = malloc(sizeof(JSONObject));
+JSONObjet * objetVersJSON(Objet objet) {
+    JSONObjet * objetJSON = NULL;
+    objetJSON = malloc(sizeof(JSONObjet));
     if(objetJSON == NULL){
-        logMessage(ERROR, "erreur malloc objetToJSONObj objetJSON");
+        logMessage(ERROR, "erreur malloc objetVersJSON objetJSON");
         exit(1);
     }
-    objetJSON->length = 3;
-    objetJSON->pairs = malloc(sizeof(JSONKeyValuePair) * objetJSON->length);
+    objetJSON->length = 3; // trois attributs
+    objetJSON->pairs = malloc(sizeof(JSONCleValeurCouple) * objetJSON->length);
     if(objetJSON->pairs == NULL){
-        logMessage(ERROR, "erreur malloc objetToJSONObj objetJSON->pairs");
+        logMessage(ERROR, "erreur malloc objetVersJSON objetJSON->pairs");
         exit(1);
     }
+
     objetJSON->pairs[0].key = "x";
-    objetJSON->pairs[0].value.type = JSON_NUMBER;
+    objetJSON->pairs[0].value.type = JSON_NOMBRE;
     objetJSON->pairs[0].value.numberValue = objet.x;
 
     objetJSON->pairs[1].key = "y";
-    objetJSON->pairs[1].value.type = JSON_NUMBER;
+    objetJSON->pairs[1].value.type = JSON_NOMBRE;
     objetJSON->pairs[1].value.numberValue = objet.y;
 
     objetJSON->pairs[2].key = "id";
-    objetJSON->pairs[2].value.type = JSON_NUMBER;
+    objetJSON->pairs[2].value.type = JSON_NOMBRE;
     objetJSON->pairs[2].value.numberValue = objet.id;
 
     return objetJSON;
 }
 
-Objet objetFromJSONObj(JSONObject objetJSON) {
+Objet objetDepuisJSON(JSONObjet objetJSON) {
     Objet objet;
     objet.x = objetJSON.pairs[0].value.numberValue;
     objet.y = objetJSON.pairs[1].value.numberValue;
@@ -44,19 +45,19 @@ Objet objetFromJSONObj(JSONObject objetJSON) {
     return objet;
 }
 
-Inventaire inventFromJSONArr(JSONArray invJSON) {
+Inventaire inventDepuisJSON(JSONArray invJSON) {
     Inventaire inv;
     for(int i = 0; i < invJSON.length; i++) {
-        inv.obTab[i] = objetFromJSONObj(*invJSON.values[i].value.objectValue);
+        inv.obTab[i] = objetDepuisJSON(*invJSON.values[i].value.objectValue);
     }
     return inv;
 }
 
-Joueur * joueurFromJSONObj(JSONObject joueurJSON) {
+Joueur * joueurVersJSON(JSONObjet joueurJSON) {
     Joueur * joueur;
     joueur = malloc(sizeof(Joueur));
     if(joueur == NULL) {
-        logMessage(ERROR, "erreur malloc joueurFromJSONObj joueur");
+        logMessage(ERROR, "erreur malloc joueurVersJSON joueur");
         exit(1);
     }
     joueur->nom = NULL;
@@ -69,11 +70,11 @@ Joueur * joueurFromJSONObj(JSONObject joueurJSON) {
     joueur->def = joueurJSON.pairs[5].value.numberValue;
     joueur->niv = joueurJSON.pairs[6].value.numberValue;
     joueur->xp = joueurJSON.pairs[7].value.numberValue;
-    joueur->inventaire = inventFromJSONArr(*joueurJSON.pairs[8].value.arrayValue);
+    joueur->inventaire = inventDepuisJSON(*joueurJSON.pairs[8].value.arrayValue);
     return joueur;
 }
 
-Porte porteFromJSONObj(JSONObject porteJSON) {
+Porte porteDepuisJSON(JSONObjet porteJSON) {
     Porte porte;
     porte.x = porteJSON.pairs[0].value.numberValue;
     porte.y = porteJSON.pairs[1].value.numberValue;
@@ -81,11 +82,11 @@ Porte porteFromJSONObj(JSONObject porteJSON) {
     return porte;
 }
 
-Ennemi * ennemiFromJSONObj(JSONObject ennemiJSON) {
+Ennemi * ennemiDepuisJSON(JSONObjet ennemiJSON) {
     Ennemi * ennemi = NULL;
     ennemi = malloc(sizeof(Ennemi));
     if(ennemi == NULL){
-        logMessage(ERROR, "erreur malloc ennemiFromJSONObj ennemi");
+        logMessage(ERROR, "erreur malloc ennemiDepuisJSON ennemi");
         exit(1);
     }
     ennemi->xGlobal = ennemiJSON.pairs[0].value.numberValue;
@@ -99,58 +100,58 @@ Ennemi * ennemiFromJSONObj(JSONObject ennemiJSON) {
 
 }
 
-JSONObject * ennemiToJSONObj(Ennemi * ennemi) {
-    JSONObject * ennemiJSON = NULL;
-    ennemiJSON = malloc(sizeof(JSONObject));
+JSONObjet * ennemiVersJSONObj(Ennemi * ennemi) {
+    JSONObjet * ennemiJSON = NULL;
+    ennemiJSON = malloc(sizeof(JSONObjet));
     // allocation de l'objet JSON
     if(ennemiJSON == NULL){
-        logMessage(ERROR, "erreur malloc ennemiToJSONObj ennemiJSON");
+        logMessage(ERROR, "erreur malloc ennemiVersJSONObj ennemiJSON");
         exit(1);
     }
     // Allocation des attributs de l'objet json
     ennemiJSON->length = 7;
-    ennemiJSON->pairs = malloc(sizeof(JSONKeyValuePair) * ennemiJSON->length);
+    ennemiJSON->pairs = malloc(sizeof(JSONCleValeurCouple) * ennemiJSON->length);
     if(ennemiJSON->pairs == NULL){
-        logMessage(ERROR, "erreur malloc ennemiToJSONObj ennemiJSON->pairs");
+        logMessage(ERROR, "erreur malloc ennemiVersJSONObj ennemiJSON->pairs");
         exit(1);
     }
     ennemiJSON->pairs[0].key = "xGlobal";
-    ennemiJSON->pairs[0].value.type = JSON_NUMBER;
+    ennemiJSON->pairs[0].value.type = JSON_NOMBRE;
     ennemiJSON->pairs[0].value.numberValue = ennemi->xGlobal;
 
     ennemiJSON->pairs[1].key = "yGlobal";
-    ennemiJSON->pairs[1].value.type = JSON_NUMBER;
+    ennemiJSON->pairs[1].value.type = JSON_NOMBRE;
     ennemiJSON->pairs[1].value.numberValue = ennemi->yGlobal;
 
     ennemiJSON->pairs[2].key = "xRelatif";
-    ennemiJSON->pairs[2].value.type = JSON_NUMBER;
+    ennemiJSON->pairs[2].value.type = JSON_NOMBRE;
     ennemiJSON->pairs[2].value.numberValue = ennemi->xRelatif;
 
     ennemiJSON->pairs[3].key = "yRelatif";
-    ennemiJSON->pairs[3].value.type = JSON_NUMBER;
+    ennemiJSON->pairs[3].value.type = JSON_NOMBRE;
     ennemiJSON->pairs[3].value.numberValue = ennemi->yRelatif;
 
     ennemiJSON->pairs[4].key = "pv";
-    ennemiJSON->pairs[4].value.type = JSON_NUMBER;
+    ennemiJSON->pairs[4].value.type = JSON_NOMBRE;
     ennemiJSON->pairs[4].value.numberValue = ennemi->pv;
 
     ennemiJSON->pairs[5].key = "att";
-    ennemiJSON->pairs[5].value.type = JSON_NUMBER;
+    ennemiJSON->pairs[5].value.type = JSON_NOMBRE;
     ennemiJSON->pairs[5].value.numberValue = ennemi->att;
 
     ennemiJSON->pairs[6].key = "def";
-    ennemiJSON->pairs[6].value.type = JSON_NUMBER;
+    ennemiJSON->pairs[6].value.type = JSON_NOMBRE;
     ennemiJSON->pairs[6].value.numberValue = ennemi->def;
 
     return ennemiJSON;
 }
 
 
-Salle * salleFromJSONObj(JSONObject salleJSON) {
+Salle * salleDepuisJSON(JSONObjet salleJSON) {
     Salle * salle = NULL;
     salle = malloc(sizeof(Salle));
     if(salle == NULL){
-        logMessage(ERROR, "erreur malloc salleFromJSONObj salle");
+        logMessage(ERROR, "erreur malloc salleDepuisJSON salle");
         exit(1);
     }
     salle->x = salleJSON.pairs[0].value.numberValue;
@@ -161,24 +162,24 @@ Salle * salleFromJSONObj(JSONObject salleJSON) {
     salle->decouvert = salleJSON.pairs[8].value.boolValue;
     salle->portes = malloc(sizeof(Porte) * salle->nportes);
     if(salle->portes == NULL){
-        logMessage(ERROR, "erreur malloc salleFromJSONObj salle.portes");
+        logMessage(ERROR, "erreur malloc salleDepuisJSON salle.portes");
         exit(1);
     }
     for(int i = 0; i < salle->nportes; i++) {
-        salle->portes[i] = porteFromJSONObj(*salleJSON.pairs[4].value.arrayValue->values[i].value.objectValue);
+        salle->portes[i] = porteDepuisJSON(*salleJSON.pairs[4].value.arrayValue->values[i].value.objectValue);
     }
     for(int i = 0; i < 3; i++) {
-        salle->objets[i] = objetFromJSONObj(*salleJSON.pairs[5].value.arrayValue->values[i].value.objectValue);
+        salle->objets[i] = objetDepuisJSON(*salleJSON.pairs[5].value.arrayValue->values[i].value.objectValue);
     }
     salle->disp = malloc(sizeof(int *) * salle->hauteur);
     if(salle->disp == NULL){
-        logMessage(ERROR, "erreur malloc salleFromJSONObj salle.disp");
+        logMessage(ERROR, "erreur malloc salleDepuisJSON salle.disp");
         exit(1);
     }
     for(int i = 0; i < salle->hauteur; i++) {
         salle->disp[i] = malloc(sizeof(int) * salle->longueur);
         if(salle->disp[i] == NULL){
-            logMessage(ERROR, "erreur malloc salleFromJSONObj salle.disp[i]");
+            logMessage(ERROR, "erreur malloc salleDepuisJSON salle.disp[i]");
             exit(1);
         }
         for(int j = 0; j < salle->longueur; j++) {
@@ -188,42 +189,41 @@ Salle * salleFromJSONObj(JSONObject salleJSON) {
     if(salleJSON.pairs[9].value.objectValue->length == 0) {
         salle->ennemi = NULL;
     } else {
-        salle->ennemi = ennemiFromJSONObj(*salleJSON.pairs[9].value.objectValue);
+        salle->ennemi = ennemiDepuisJSON(*salleJSON.pairs[9].value.objectValue);
     }
     return salle;
 }
 
-Salle ** carteFromJSONArr(JSONArray carteJSON) {
+Salle ** carteDepuisJSON(JSONArray carteJSON) {
+    int i = 0;
     Salle ** carte = NULL;
     carte = malloc(sizeof(Salle *) * MAX_SALLES);
     if(carte == NULL){
-        logMessage(ERROR, "erreur malloc carteFromJSONArr carte");
+        logMessage(ERROR, "erreur malloc carteDepuisJSON carte");
         exit(1);
     }
-    for(int i = 0; i < carteJSON.length; i++) {
-        carte[i] = salleFromJSONObj(*carteJSON.values[i].value.objectValue);
+    for(i = 0; i < MAX_SALLES; i++) {
+        carte[i] = NULL;
     }
-
-    for(int j = carteJSON.length; j < MAX_SALLES; j++) {
-        carte[j] = NULL;
+    for(i = 0; i < carteJSON.length; i++) {
+        carte[i] = salleDepuisJSON(*carteJSON.values[i].value.objectValue);
     }
+
+
     return carte;
 }
 
-Partie * partieFromJSONObj(JSONObject partieJSON) {
+Partie * partieDepuisJSON(JSONObjet partieJSON) {
     Partie * partie = NULL;
     partie = malloc(sizeof(Partie));
     if(partie == NULL){
-        logMessage(ERROR, "erreur malloc partieFromJSONObj partie");
-        exit(1);
-    }
-    partie->joueur = malloc(sizeof(Joueur));
-    if(partie->joueur == NULL){
-        logMessage(ERROR, "erreur malloc partieFromJSONObj partie.joueur");
+        logMessage(ERROR, "erreur malloc partieDepuisJSON partie");
         exit(1);
     }
-    partie->joueur = joueurFromJSONObj(*partieJSON.pairs[0].value.objectValue);
-    partie->carte = carteFromJSONArr(*partieJSON.pairs[1].value.arrayValue);
+    partie->joueur = NULL;
+    partie->carte = NULL;
+    partie->joueur = joueurVersJSON(*partieJSON.pairs[0].value.objectValue);
+    partie->carte = carteDepuisJSON(*partieJSON.pairs[1].value.arrayValue);
     partie->graine = partieJSON.pairs[2].value.numberValue;
     partie->portesNonOuvertes = partieJSON.pairs[3].value.numberValue;
     partie->objets_speciaux_apparus = partieJSON.pairs[4].value.numberValue;
@@ -238,107 +238,102 @@ Partie * partieFromJSONObj(JSONObject partieJSON) {
     return partie;
 }
 
-JSONArray * inventToJSONArr(Inventaire inv) {
-    int nobj = 0;
+JSONArray * inventVersTabJSON(Inventaire inv) {
     JSONArray * invJSON = NULL;
     invJSON = malloc(sizeof(JSONArray));
     if(invJSON == NULL){
-        logMessage(ERROR, "erreur malloc inventToJSONArr invJSON");
+        logMessage(ERROR, "erreur malloc inventVersTabJSON invJSON");
         exit(1);
     }
-    while(inv.obTab[nobj].id != 0) {
-        nobj++;
-    }
-    invJSON->length = nobj;
-
-    invJSON->values = malloc(sizeof(JSONKeyValuePair) * invJSON->length);
+    invJSON->length = INV_TAILLE;
+    invJSON->values = malloc(sizeof(JSONCleValeurCouple) * invJSON->length);
     if(invJSON->values == NULL){
-        logMessage(ERROR, "erreur malloc inventToJSONArr invJSON->values");
+        logMessage(ERROR, "erreur malloc inventVersTabJSON invJSON->values");
         exit(1);
     }
-    for(int i = 0; i < nobj; i++) {
-        invJSON->values[nobj].value.type = JSON_OBJECT;
-        invJSON->values[nobj].value.objectValue = objetToJSONObj(inv.obTab[nobj]);
+    for(int i = 0; i < INV_TAILLE; i++) {
+        invJSON->values[i].value.type = JSON_OBJET;
+        invJSON->values[i].value.objectValue = objetVersJSON(inv.obTab[i]);
     }
     return invJSON;
 }
 
-JSONObject * joueurToJSONObj(Joueur * joueur) {
-    JSONObject * joueurJSON = NULL;
-    joueurJSON = malloc(sizeof(JSONObject));
+JSONObjet * joueurVersObjJSON(Joueur * joueur) {
+    JSONObjet * joueurJSON = NULL;
+    joueurJSON = malloc(sizeof(JSONObjet));
     if(joueurJSON == NULL){
-        logMessage(ERROR, "erreur malloc joueurToJSONObj joueurJSON");
+        logMessage(ERROR, "erreur malloc joueurVersObjJSON joueurJSON");
         exit(1);
     }
     joueurJSON->length = 9;
-    joueurJSON->pairs = malloc(sizeof(JSONKeyValuePair) * joueurJSON->length);
+    joueurJSON->pairs = malloc(sizeof(JSONCleValeurCouple) * joueurJSON->length);
     if(joueurJSON->pairs == NULL){
-        logMessage(ERROR, "erreur malloc joueurToJSONObj joueurJSON->pairs");
+        logMessage(ERROR, "erreur malloc joueurVersObjJSON joueurJSON->pairs");
         exit(1);
     }
     joueurJSON->pairs[0].key = "nom";
-    joueurJSON->pairs[0].value.type = JSON_STRING;
+    joueurJSON->pairs[0].value.type = JSON_CHAINE;
     joueurJSON->pairs[0].value.stringValue = malloc(sizeof(char) * strlen(joueur->nom) + 1);
     if(joueurJSON->pairs[0].value.stringValue == NULL){
-        logMessage(ERROR, "erreur malloc joueurToJSONObj joueurJSON->pairs[0].value.stringValue");
+        logMessage(ERROR, "erreur malloc joueurVersObjJSON joueurJSON->pairs[0].value.stringValue");
         exit(1);
     }
     joueurJSON->pairs[0].value.stringValue = strcpy(joueurJSON->pairs[0].value.stringValue, joueur->nom);
 
     joueurJSON->pairs[1].key = "x";
-    joueurJSON->pairs[1].value.type = JSON_NUMBER;
+    joueurJSON->pairs[1].value.type = JSON_NOMBRE;
     joueurJSON->pairs[1].value.numberValue = joueur->x;
 
     joueurJSON->pairs[2].key = "y";
-    joueurJSON->pairs[2].value.type = JSON_NUMBER;
+    joueurJSON->pairs[2].value.type = JSON_NOMBRE;
     joueurJSON->pairs[2].value.numberValue = joueur->y;
 
     joueurJSON->pairs[3].key = "pv";
-    joueurJSON->pairs[3].value.type = JSON_NUMBER;
+    joueurJSON->pairs[3].value.type = JSON_NOMBRE;
     joueurJSON->pairs[3].value.numberValue = joueur->pv;
 
     joueurJSON->pairs[4].key = "att";
-    joueurJSON->pairs[4].value.type = JSON_NUMBER;
+    joueurJSON->pairs[4].value.type = JSON_NOMBRE;
     joueurJSON->pairs[4].value.numberValue = joueur->att;
 
     joueurJSON->pairs[5].key = "def";
-    joueurJSON->pairs[5].value.type = JSON_NUMBER;
+    joueurJSON->pairs[5].value.type = JSON_NOMBRE;
     joueurJSON->pairs[5].value.numberValue = joueur->def;
 
     joueurJSON->pairs[6].key = "niv";
-    joueurJSON->pairs[6].value.type = JSON_NUMBER;
+    joueurJSON->pairs[6].value.type = JSON_NOMBRE;
     joueurJSON->pairs[6].value.numberValue = joueur->niv;
 
     joueurJSON->pairs[7].key = "xp";
-    joueurJSON->pairs[7].value.type = JSON_NUMBER;
+    joueurJSON->pairs[7].value.type = JSON_NOMBRE;
     joueurJSON->pairs[7].value.numberValue = joueur->xp;
 
     joueurJSON->pairs[8].key = "inventaire";
-    joueurJSON->pairs[8].value.type = JSON_ARRAY;
-    joueurJSON->pairs[8].value.arrayValue = inventToJSONArr(joueur->inventaire);
+    joueurJSON->pairs[8].value.type = JSON_TABLEAU;
+    joueurJSON->pairs[8].value.arrayValue = inventVersTabJSON(joueur->inventaire);
 
     return joueurJSON;
 }
 
-JSONObject * porteToJSONObj(Porte porte) {
-    JSONObject * porteJSON = NULL;
-    porteJSON = malloc(sizeof(JSONObject));
+JSONObjet * porteVersObjJSON(Porte porte) {
+    JSONObjet * porteJSON = NULL;
+    porteJSON = malloc(sizeof(JSONObjet));
     if(porteJSON == NULL){
-        logMessage(ERROR, "erreur malloc porteToJSONObj porteJSON");
+        logMessage(ERROR, "erreur malloc porteVersObjJSON porteJSON");
         exit(1);
     }
     porteJSON->length = 3;
-    porteJSON->pairs = malloc(sizeof(JSONKeyValuePair) * porteJSON->length);
+    porteJSON->pairs = malloc(sizeof(JSONCleValeurCouple) * porteJSON->length);
     if(porteJSON->pairs == NULL){
-        logMessage(ERROR, "erreur malloc porteToJSONObj porteJSON->pairs");
+        logMessage(ERROR, "erreur malloc porteVersObjJSON porteJSON->pairs");
         exit(1);
     }
     porteJSON->pairs[0].key = "x";
-    porteJSON->pairs[0].value.type = JSON_NUMBER;
+    porteJSON->pairs[0].value.type = JSON_NOMBRE;
     porteJSON->pairs[0].value.numberValue = porte.x;
 
     porteJSON->pairs[1].key = "y";
-    porteJSON->pairs[1].value.type = JSON_NUMBER;
+    porteJSON->pairs[1].value.type = JSON_NOMBRE;
     porteJSON->pairs[1].value.numberValue = porte.y;
 
     porteJSON->pairs[2].key = "ouvert";
@@ -348,107 +343,107 @@ JSONObject * porteToJSONObj(Porte porte) {
     return porteJSON;
 }
 
-JSONObject * salleToJSONObj(Salle salle) {
-    JSONObject * salleJSON = NULL;
-    salleJSON = malloc(sizeof(JSONObject));
+JSONObjet * salleVersObjJSON(Salle salle) {
+    JSONObjet * salleJSON = NULL;
+    salleJSON = malloc(sizeof(JSONObjet));
     if(salleJSON == NULL){
-        logMessage(ERROR, "erreur malloc salleToJSONObj salleJSON");
+        logMessage(ERROR, "erreur malloc salleVersObjJSON salleJSON");
         exit(1);
     }
     salleJSON->length = 10;
-    salleJSON->pairs = malloc(sizeof(JSONKeyValuePair) * salleJSON->length);
+    salleJSON->pairs = malloc(sizeof(JSONCleValeurCouple) * salleJSON->length);
     if(salleJSON->pairs == NULL){
-        logMessage(ERROR, "erreur malloc salleToJSONObj salleJSON->pairs");
+        logMessage(ERROR, "erreur malloc salleVersObjJSON salleJSON->pairs");
         exit(1);
     }
     salleJSON->pairs[0].key = "x";
-    salleJSON->pairs[0].value.type = JSON_NUMBER;
+    salleJSON->pairs[0].value.type = JSON_NOMBRE;
     salleJSON->pairs[0].value.numberValue = salle.x;
 
     salleJSON->pairs[1].key = "y";
-    salleJSON->pairs[1].value.type = JSON_NUMBER;
+    salleJSON->pairs[1].value.type = JSON_NOMBRE;
     salleJSON->pairs[1].value.numberValue = salle.y;
 
     salleJSON->pairs[2].key = "longueur";
-    salleJSON->pairs[2].value.type = JSON_NUMBER;
+    salleJSON->pairs[2].value.type = JSON_NOMBRE;
     salleJSON->pairs[2].value.numberValue = salle.longueur;
 
     salleJSON->pairs[3].key = "hauteur";
-    salleJSON->pairs[3].value.type = JSON_NUMBER;
+    salleJSON->pairs[3].value.type = JSON_NOMBRE;
     salleJSON->pairs[3].value.numberValue = salle.hauteur;
 
     salleJSON->pairs[4].key = "portes";
-    salleJSON->pairs[4].value.type = JSON_ARRAY;
+    salleJSON->pairs[4].value.type = JSON_TABLEAU;
     salleJSON->pairs[4].value.arrayValue = malloc(sizeof(JSONArray));
     if(salleJSON->pairs[4].value.arrayValue == NULL){
-        logMessage(ERROR, "erreur malloc salleToJSONObj salleJSON->pairs[4].value.arrayValue");
+        logMessage(ERROR, "erreur malloc salleVersObjJSON salleJSON->pairs[4].value.arrayValue");
         exit(1);
     }
     salleJSON->pairs[4].value.arrayValue->length = salle.nportes;
-    salleJSON->pairs[4].value.arrayValue->values = malloc(sizeof(JSONKeyValuePair) * salleJSON->pairs[4].value.arrayValue->length);
+    salleJSON->pairs[4].value.arrayValue->values = malloc(sizeof(JSONCleValeurCouple) * salleJSON->pairs[4].value.arrayValue->length);
     if(salleJSON->pairs[4].value.arrayValue->values == NULL){
-        logMessage(ERROR, "erreur malloc salleToJSONObj salleJSON->pairs[4].value.arrayValue->values");
+        logMessage(ERROR, "erreur malloc salleVersObjJSON salleJSON->pairs[4].value.arrayValue->values");
         exit(1);
     }
     for(int i = 0; i < salle.nportes; i++) {
-        salleJSON->pairs[4].value.arrayValue->values[i].value.type = JSON_OBJECT;
-        salleJSON->pairs[4].value.arrayValue->values[i].value.objectValue = porteToJSONObj(salle.portes[i]);
+        salleJSON->pairs[4].value.arrayValue->values[i].value.type = JSON_OBJET;
+        salleJSON->pairs[4].value.arrayValue->values[i].value.objectValue = porteVersObjJSON(salle.portes[i]);
     }
 
     salleJSON->pairs[5].key = "objets";
-    salleJSON->pairs[5].value.type = JSON_ARRAY;
+    salleJSON->pairs[5].value.type = JSON_TABLEAU;
     salleJSON->pairs[5].value.arrayValue = malloc(sizeof(JSONArray));
     if(salleJSON->pairs[5].value.arrayValue == NULL){
-        logMessage(ERROR, "erreur malloc salleToJSONObj salleJSON->pairs[5].value.arrayValue");
+        logMessage(ERROR, "erreur malloc salleVersObjJSON salleJSON->pairs[5].value.arrayValue");
         exit(1);
     }
     salleJSON->pairs[5].value.arrayValue->length = 3; // 3 objets max par salle
-    salleJSON->pairs[5].value.arrayValue->values = malloc(sizeof(JSONKeyValuePair) * salleJSON->pairs[5].value.arrayValue->length);
+    salleJSON->pairs[5].value.arrayValue->values = malloc(sizeof(JSONCleValeurCouple) * salleJSON->pairs[5].value.arrayValue->length);
     if(salleJSON->pairs[5].value.arrayValue->values == NULL){
-        logMessage(ERROR, "erreur malloc salleToJSONObj salleJSON->pairs[5].value.arrayValue->values");
+        logMessage(ERROR, "erreur malloc salleVersObjJSON salleJSON->pairs[5].value.arrayValue->values");
         exit(1);
     }
 
     for(int i = 0; i < 3; i++) {
-        salleJSON->pairs[5].value.arrayValue->values[i].value.type = JSON_OBJECT;
-        salleJSON->pairs[5].value.arrayValue->values[i].value.objectValue = objetToJSONObj(salle.objets[i]);
+        salleJSON->pairs[5].value.arrayValue->values[i].value.type = JSON_OBJET;
+        salleJSON->pairs[5].value.arrayValue->values[i].value.objectValue = objetVersJSON(salle.objets[i]);
     }
 
     salleJSON->pairs[6].key = "disp";
-    salleJSON->pairs[6].value.type = JSON_ARRAY;
+    salleJSON->pairs[6].value.type = JSON_TABLEAU;
     salleJSON->pairs[6].value.arrayValue = malloc(sizeof(JSONArray));
     if(salleJSON->pairs[6].value.arrayValue == NULL){
-        logMessage(ERROR, "erreur malloc salleToJSONObj salleJSON->pairs[6].value.arrayValue");
+        logMessage(ERROR, "erreur malloc salleVersObjJSON salleJSON->pairs[6].value.arrayValue");
         exit(1);
     }
     salleJSON->pairs[6].value.arrayValue->length = salle.hauteur;
-    salleJSON->pairs[6].value.arrayValue->values = malloc(sizeof(JSONKeyValuePair) * salleJSON->pairs[6].value.arrayValue->length);
+    salleJSON->pairs[6].value.arrayValue->values = malloc(sizeof(JSONCleValeurCouple) * salleJSON->pairs[6].value.arrayValue->length);
     if(salleJSON->pairs[6].value.arrayValue->values == NULL){
-        logMessage(ERROR, "erreur malloc salleToJSONObj salleJSON->pairs[6].value.arrayValue->values");
+        logMessage(ERROR, "erreur malloc salleVersObjJSON salleJSON->pairs[6].value.arrayValue->values");
         exit(1);
     }
     // vive les salle->disp aaaaaaaa
     for(int i = 0; i < salle.hauteur; i++) {
-        salleJSON->pairs[6].value.arrayValue->values[i].value.type = JSON_ARRAY;
+        salleJSON->pairs[6].value.arrayValue->values[i].value.type = JSON_TABLEAU;
         salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue = malloc(sizeof(JSONArray));
         if(salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue == NULL){
-            logMessage(ERROR, "erreur malloc salleToJSONObj salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue");
+            logMessage(ERROR, "erreur malloc salleVersObjJSON salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue");
             exit(1);
         }
         salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue->length = salle.longueur;
-        salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue->values = malloc(sizeof(JSONKeyValuePair) * salle.longueur);
+        salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue->values = malloc(sizeof(JSONCleValeurCouple) * salle.longueur);
         if(salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue->values == NULL){
-            logMessage(ERROR, "erreur malloc salleToJSONObj salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue->values");
+            logMessage(ERROR, "erreur malloc salleVersObjJSON salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue->values");
             exit(1);
         }
         for(int j = 0; j < salle.longueur; j++) {
-            salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue->values[j].value.type = JSON_NUMBER;
+            salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue->values[j].value.type = JSON_NOMBRE;
             salleJSON->pairs[6].value.arrayValue->values[i].value.arrayValue->values[j].value.numberValue = salle.disp[i][j];
         }
     }
 
     salleJSON->pairs[7].key = "nportes";
-    salleJSON->pairs[7].value.type = JSON_NUMBER;
+    salleJSON->pairs[7].value.type = JSON_NOMBRE;
     salleJSON->pairs[7].value.numberValue = salle.nportes;
 
     salleJSON->pairs[8].key = "decouvert";
@@ -456,137 +451,137 @@ JSONObject * salleToJSONObj(Salle salle) {
     salleJSON->pairs[8].value.boolValue = salle.decouvert;
 
     salleJSON->pairs[9].key = "ennemi";
-    salleJSON->pairs[9].value.type = JSON_OBJECT;
+    salleJSON->pairs[9].value.type = JSON_OBJET;
 
     if(salle.ennemi == NULL) {
-        salleJSON->pairs[9].value.objectValue = malloc(sizeof(JSONObject));
+        salleJSON->pairs[9].value.objectValue = malloc(sizeof(JSONObjet));
         if(salleJSON->pairs[9].value.objectValue == NULL){
-            logMessage(ERROR, "erreur malloc salleToJSONObj salleJSON->pairs[9].value.objectValue");
+            logMessage(ERROR, "erreur malloc salleVersObjJSON salleJSON->pairs[9].value.objectValue");
             exit(1);
         }
         salleJSON->pairs[9].value.objectValue->length = 0;
         salleJSON->pairs[9].value.objectValue->pairs = NULL;
     } else {
-        salleJSON->pairs[9].value.objectValue = ennemiToJSONObj(salle.ennemi);
+        salleJSON->pairs[9].value.objectValue = ennemiVersJSONObj(salle.ennemi);
     }
 
     return salleJSON;
 
 }
 
-JSONArray * carteToJSONArr(Salle ** carte, int nsalles) {
+JSONArray * carteVersTabJSON(Salle ** carte, int nsalles) {
     JSONArray * carteJSON = NULL;
     carteJSON = malloc(sizeof(JSONArray));
     if(carteJSON == NULL){
-        logMessage(ERROR, "erreur malloc carteToJSONArr carteJSON");
+        logMessage(ERROR, "erreur malloc carteVersTabJSON carteJSON");
         exit(1);
     }
     carteJSON->length = nsalles;
-    carteJSON->values = malloc(sizeof(JSONKeyValuePair) * carteJSON->length);
+    carteJSON->values = malloc(sizeof(JSONCleValeurCouple) * carteJSON->length);
     if(carteJSON->values == NULL){
-        logMessage(ERROR, "erreur malloc carteToJSONArr carteJSON->values");
+        logMessage(ERROR, "erreur malloc carteVersTabJSON carteJSON->values");
         exit(1);
     }
     for(int i = 0; i < nsalles; i++) {
-        carteJSON->values[i].value.type = JSON_OBJECT;
-        carteJSON->values[i].value.objectValue = salleToJSONObj(*carte[i]);
+        carteJSON->values[i].value.type = JSON_OBJET;
+        carteJSON->values[i].value.objectValue = salleVersObjJSON(*carte[i]);
     }
     return carteJSON;
 }
 
-JSONObject * partieToJSONObj(Partie * partie) {
-    JSONObject * partieJSON = NULL;
-    partieJSON = malloc(sizeof(JSONObject));
+JSONObjet * partieVersObjJSON(Partie * partie) {
+    JSONObjet * partieJSON = NULL;
+    partieJSON = malloc(sizeof(JSONObjet));
     if(partieJSON == NULL){
-        logMessage(ERROR, "erreur malloc partieToJSONObj partieJSON");
+        logMessage(ERROR, "erreur malloc partieVersObjJSON partieJSON");
         exit(1);
     }
     partieJSON->length = 12;
-    partieJSON->pairs = malloc(sizeof(JSONKeyValuePair) * partieJSON->length);
+    partieJSON->pairs = malloc(sizeof(JSONCleValeurCouple) * partieJSON->length);
     if(partieJSON->pairs == NULL){
-        logMessage(ERROR, "erreur malloc partieToJSONObj partieJSON->pairs");
+        logMessage(ERROR, "erreur malloc partieVersObjJSON partieJSON->pairs");
         exit(1);
     }
     partieJSON->pairs[0].key = "joueur";
-    partieJSON->pairs[0].value.type = JSON_OBJECT;
-    partieJSON->pairs[0].value.objectValue = joueurToJSONObj(partie->joueur);
+    partieJSON->pairs[0].value.type = JSON_OBJET;
+    partieJSON->pairs[0].value.objectValue = joueurVersObjJSON(partie->joueur);
 
     partieJSON->pairs[1].key = "carte";
-    partieJSON->pairs[1].value.type = JSON_ARRAY;
-    partieJSON->pairs[1].value.arrayValue = carteToJSONArr(partie->carte, partie->salles_existantes);
+    partieJSON->pairs[1].value.type = JSON_TABLEAU;
+    partieJSON->pairs[1].value.arrayValue = carteVersTabJSON(partie->carte, partie->salles_existantes);
 
     partieJSON->pairs[2].key = "graine";
-    partieJSON->pairs[2].value.type = JSON_NUMBER;
+    partieJSON->pairs[2].value.type = JSON_NOMBRE;
     partieJSON->pairs[2].value.numberValue = partie->graine;
 
     partieJSON->pairs[3].key = "portesNonOuvertes";
-    partieJSON->pairs[3].value.type = JSON_NUMBER;
+    partieJSON->pairs[3].value.type = JSON_NOMBRE;
     partieJSON->pairs[3].value.numberValue = partie->portesNonOuvertes;
 
     partieJSON->pairs[4].key = "objets_speciaux_apparus";
-    partieJSON->pairs[4].value.type = JSON_NUMBER;
+    partieJSON->pairs[4].value.type = JSON_NOMBRE;
     partieJSON->pairs[4].value.numberValue = partie->objets_speciaux_apparus;
 
     partieJSON->pairs[5].key = "salles_existantes";
-    partieJSON->pairs[5].value.type = JSON_NUMBER;
+    partieJSON->pairs[5].value.type = JSON_NOMBRE;
     partieJSON->pairs[5].value.numberValue = partie->salles_existantes;
 
     partieJSON->pairs[6].key = "mvEnnemic";
-    partieJSON->pairs[6].value.type = JSON_NUMBER;
+    partieJSON->pairs[6].value.type = JSON_NOMBRE;
     partieJSON->pairs[6].value.numberValue = partie->mvEnnemic;
 
     partieJSON->pairs[7].key = "nb_obj_inv";
-    partieJSON->pairs[7].value.type = JSON_NUMBER;
+    partieJSON->pairs[7].value.type = JSON_NOMBRE;
     partieJSON->pairs[7].value.numberValue = partie->nb_obj_inv;
 
     partieJSON->pairs[8].key = "nb_obj_spe_inv";
-    partieJSON->pairs[8].value.type = JSON_NUMBER;
+    partieJSON->pairs[8].value.type = JSON_NOMBRE;
     partieJSON->pairs[8].value.numberValue = partie->nb_obj_spe_inv;
 
     partieJSON->pairs[9].key = "nsalles";
-    partieJSON->pairs[9].value.type = JSON_NUMBER;
+    partieJSON->pairs[9].value.type = JSON_NOMBRE;
     partieJSON->pairs[9].value.numberValue = partie->nsalles;
 
     partieJSON->pairs[10].key = "minuteur";
-    partieJSON->pairs[10].value.type = JSON_NUMBER;
+    partieJSON->pairs[10].value.type = JSON_NOMBRE;
     partieJSON->pairs[10].value.numberValue = partie->minuteur;
 
     partieJSON->pairs[11].key = "decr_minuteur";
-    partieJSON->pairs[11].value.type = JSON_NUMBER;
+    partieJSON->pairs[11].value.type = JSON_NOMBRE;
     partieJSON->pairs[11].value.numberValue = partie->decr_minuteur;
 
     return partieJSON;
 }
 
-void freeJSONObject(JSONObject * obj) { // fonction récursive pour se débarasser de tous les mallocs
+void freeObjetJSON(JSONObjet * obj) { // fonction récursive pour se débarasser de tous les mallocs
     for(int i = 0; i < obj->length; i++) {
-        if(obj->pairs[i].value.type == JSON_ARRAY) {
+        if(obj->pairs[i].value.type == JSON_TABLEAU) {
             for(int j = 0; j < obj->pairs[i].value.arrayValue->length; j++) {
-                if(obj->pairs[i].value.arrayValue->values[j].value.type == JSON_OBJECT) {
-                    freeJSONObject(obj->pairs[i].value.arrayValue->values[j].value.objectValue);
+                if(obj->pairs[i].value.arrayValue->values[j].value.type == JSON_OBJET) {
+                    freeObjetJSON(obj->pairs[i].value.arrayValue->values[j].value.objectValue);
                 }
             }
             free(obj->pairs[i].value.arrayValue->values);
             free(obj->pairs[i].value.arrayValue);
         }
-        if(obj->pairs[i].value.type == JSON_OBJECT) {
-            freeJSONObject(obj->pairs[i].value.objectValue);
+        if(obj->pairs[i].value.type == JSON_OBJET) {
+            freeObjetJSON(obj->pairs[i].value.objectValue);
         }
     }
     free(obj->pairs);
     free(obj);
 }
 
-void saveGame(Partie * partie, char * nomFichier) {
+void sauveJeu(Partie * partie, char * nomFichier) {
     char * chemin = malloc(sizeof(char) * strlen(nomFichier) + 6); // 5 pour le .json et le \0
     if(chemin == NULL) {
-        logMessage(ERROR, "erreur malloc path saveGame");
+        logMessage(ERROR, "erreur malloc path sauveJeu");
         exit(1);
     }
     chemin = strcpy(chemin, nomFichier);
     chemin = strcat(chemin, ".json");
-    JSONObject * partieJSON = partieToJSONObj(partie);
-    char * serialized = serializeJSONObject(*partieJSON);
+    JSONObjet * partieJSON = partieVersObjJSON(partie);
+    char * serialized = serializeObjetJSON(*partieJSON);
     FILE * save = fopen(chemin, "w");
     if(save == NULL) {
         logMessage(ERROR, "erreur ouverture fichier save.json");
@@ -595,13 +590,13 @@ void saveGame(Partie * partie, char * nomFichier) {
     fprintf(save, "%s", serialized);
     fclose(save);
     free(serialized);
-    freeJSONObject(partieJSON);
+    freeObjetJSON(partieJSON);
 }
 
-Partie * loadGame(char * nomFichier) {
+Partie * chargerJeu(char * nomFichier) {
     char * chemin = malloc(sizeof(char) * strlen(nomFichier) + 6); // 5 pour le .json et le \0
     if(chemin == NULL) {
-        logMessage(ERROR, "erreur malloc path loadGame");
+        logMessage(ERROR, "erreur malloc path chargerJeu");
         exit(1);
     }
     chemin = strcpy(chemin, nomFichier);
@@ -621,25 +616,20 @@ Partie * loadGame(char * nomFichier) {
     char * bufferPtr = buffer;
 
     if(buffer == NULL) {
-        logMessage(ERROR, "erreur malloc buffer loadGame");
+        logMessage(ERROR, "erreur malloc buffer chargerJeu");
         exit(1);
     }
     // lecture du fichier
     fread(buffer, 1, fsize, save);
     fclose(save);
     buffer[fsize] = '\0'; // ajout du caractère de fin de chaine
-    // creation JSONObject
-    JSONObject * partieJSON = parseJSONObject(&buffer);
-    Partie * partie = malloc(sizeof(Partie));
-    if(partie == NULL) {
-        logMessage(ERROR, "erreur malloc partie loadGame");
-        exit(1);
-    }
-
-    partie = partieFromJSONObj(*partieJSON);
+    // creation JSONObjet
+    JSONObjet * partieJSON = parserObjetJSON(&buffer);
+    Partie * partie = NULL;
+    partie = partieDepuisJSON(*partieJSON);
     // libération de la mémoire
     free(bufferPtr);
-    freeJSONObject(partieJSON);
+    freeObjetJSON(partieJSON);
     return partie;
 }
 
@@ -647,7 +637,7 @@ int verifFichier(char * nomSauvegarde) {
     // vérification si le fichier existe
     char * chemin = malloc(sizeof(char) * strlen(nomSauvegarde) + 6); // 6 pour le .json et le \0
     if(chemin == NULL) {
-        logMessage(ERROR, "erreur malloc path loadGame");
+        logMessage(ERROR, "erreur malloc path chargerJeu");
         exit(1);
     }
     chemin = strcpy(chemin, nomSauvegarde);
diff --git a/ui/hud.c b/ui/hud.c
index 6b6fac1..efdf8ee 100644
--- a/ui/hud.c
+++ b/ui/hud.c
@@ -393,11 +393,6 @@ void renduInvMenu(WINDOW * win, InvMenu * invMenu, Inventaire inventaire) {
     wattroff(win, COLOR_PAIR(7));
 
     renduTexte(win, *invMenu->titre);
-    if(invMenu->selRetour) {
-        renduBouton(win, *invMenu->reprendre, 1);
-    } else {
-        renduBouton(win, *invMenu->reprendre, 0);
-    }
     for(int i = 0; i < invMenu->nbBoutLig; i++) {
         for(int j = 0; j < invMenu->nbBoutCol; j++) {
             switch(inventaire.obTab[k].id) {
@@ -420,7 +415,7 @@ void renduInvMenu(WINDOW * win, InvMenu * invMenu, Inventaire inventaire) {
                     invMenu->boutons[j][i]->texte = "Reacteur 2";
                     break;
                 case PC:
-                    invMenu->boutons[j][i]->texte = "PC";
+                    invMenu->boutons[j][i]->texte = "Un PC portable";
                     break;
                 case VIDE_OBJ:
                     invMenu->boutons[j][i]->texte = "Vide";
diff --git a/ui/menu.c b/ui/menu.c
index 578022f..4449695 100644
--- a/ui/menu.c
+++ b/ui/menu.c
@@ -14,7 +14,6 @@ Menu *cosmicMenu(int thauteur, int tlargeur) {
 
     Bouton *commencer;
     Bouton *charger;
-    Bouton *parametres;
     Bouton *quitter;
     char **titreTexte = NULL;
 
@@ -25,7 +24,7 @@ Menu *cosmicMenu(int thauteur, int tlargeur) {
         titreX = tlargeur / 2 - 65;
         titreY = thauteur / 2 - 10;
     } else {
-        titreTexte = (char **) malloc(sizeof(char) * 2 * 24);
+        titreTexte = (char **) malloc(sizeof(char) * 2 * 54);
         titreLignes = 2;
         titreX = tlargeur / 2 - 11;
         titreY = thauteur / 2 - 2;
@@ -48,22 +47,20 @@ Menu *cosmicMenu(int thauteur, int tlargeur) {
         titreTexte[7] = R"(                       \|_________|                                 \|___|/)";
     } else {
         titreTexte[0] = "Cosmic Yonder";
-        titreTexte[1] = "Agrandis ton terminal!";
+        titreTexte[1] = "Active le plein-écran pour ne pas rencontrer de bugs!";
     }
 
     //Création éléments menu
     titre = creerTexte(titreX, titreY, titreTexte, titreLignes, 6);
     commencer = creerBouton(tlargeur / 2 - 2, thauteur / 2 + 2, 5, 2, "Nouvelle partie");
     charger = creerBouton(tlargeur / 2 - 2, thauteur / 2 + 4, 5, 2, "Charger sauvegarde");
-    parametres = creerBouton(tlargeur / 2 - 2, thauteur / 2 + 6, 5, 2, "Options");
-    quitter = creerBouton(tlargeur / 2 - 2, thauteur / 2 + 8, 5, 2, "Quitter");
+    quitter = creerBouton(tlargeur / 2 - 2, thauteur / 2 + 6, 5, 2, "Quitter");
 
     //Création menu et assignation des éléments au menu
-    menu = creerMenu(thauteur, tlargeur, titre, 4, 1, 6);
+    menu = creerMenu(thauteur, tlargeur, titre, 3, 1, 6);
     menu->boutons[0] = commencer;
     menu->boutons[1] = charger;
-    menu->boutons[2] = parametres;
-    menu->boutons[3] = quitter;
+    menu->boutons[2] = quitter;
 
 
     return menu;
@@ -213,7 +210,6 @@ InvMenu *initInvMenu(int x, int y, int hauteur, int largeur) {
     //Initialisation
     InvMenu * invMenu1;
 
-    Bouton *reprendre;
     Bouton ** col1;
     Bouton ** col2;
     col1 = malloc(sizeof(Bouton*) * 5);
@@ -228,8 +224,8 @@ InvMenu *initInvMenu(int x, int y, int hauteur, int largeur) {
     }
 
     for(int i = 0; i < 5; i++) {
-        col1[i] = creerBouton(x - 7, y - 8 + i * 2, 5, 2, "Vide");
-        col2[i] = creerBouton(x + 2, y - 8 + i * 2, 5, 2, "Vide");
+        col1[i] = creerBouton(x - 11, y - 8 + i * 2, 5, 2, "Vide");
+        col2[i] = creerBouton(x + 5, y - 8 + i * 2, 5, 2, "Vide");
     }
     col1[0]->couleur = 1;
     col2[0]->couleur = 1;
@@ -260,7 +256,6 @@ InvMenu *initInvMenu(int x, int y, int hauteur, int largeur) {
     //Assignation des boutons au menu
     invMenu1->boutons[0] = col1;
     invMenu1->boutons[1] = col2;
-    invMenu1->reprendre = creerBouton(x - 5, y + 6, 5, 2, "Reprendre");
     invMenu1->message = creerMessage(largeur / 2 + largeur/4, hauteur / 2 + hauteur/4, hauteur/2, largeur/2, 6, titreMsg, 3, NULL);
     invMenu1->message->boutons[0] = creerBouton(x - 4, y - 1, 5, 2, "Utiliser");
     invMenu1->message->boutons[1] = creerBouton(x - 4, y + 1, 5, 2, "Jeter");
@@ -430,8 +425,10 @@ void entreeTexte(EntreeTexte *entree, int touche) {
                 entree->curseur--;
             }
             break;
-
-        case 10:
+        case 27: // échap
+            entree->quitter = 1;
+            break;
+        case 10: // entrée
             //L'entrée est valide
             entree->valide = 1;
             break;
@@ -565,8 +562,6 @@ void entreeInv(InvMenu *invMenu, int* touche) {
         case KEY_DOWN:
             if (invMenu->curseurLig != invMenu->nbBoutLig - 1) {
                 invMenu->curseurLig++;
-            } else {
-                invMenu->selRetour = 1;
             }
             break;
         case KEY_LEFT:
@@ -581,6 +576,9 @@ void entreeInv(InvMenu *invMenu, int* touche) {
             break;
         case 27:
             invMenu->selEtat = 1;
+            invMenu->montrerMsg = 0;
+            invMenu->curseurLig = 0;
+            invMenu->curseurCol = 0;
             break;
         case 10:
             invMenu->montrerMsg = 1;
diff --git a/ui/ui.c b/ui/ui.c
index 87e8faa..53ecc3f 100644
--- a/ui/ui.c
+++ b/ui/ui.c
@@ -203,7 +203,6 @@ InvMenu * creerInvMenu(int x, int y, int hauteur, int largeur, int couleur, Text
         logMessage(CRITICAL, "erreur malloc boutons initInvMenu");
         exit(1);
     }
-    invMenu->reprendre = NULL;
     invMenu->message = NULL;
     invMenu->curseurCol = 0;
     invMenu->curseurLig = 0;
@@ -271,6 +270,7 @@ EntreeTexte * creerEntreeTexte(int x, int y, int taille, int couleur, Texte * ti
     entree->titre = titre;
     entree->couleur = couleur;
     entree->valide = 0; //Sert à savoir si l'entrée est valide
+    entree->quitter = 0; //Sert à savoir si on doit quitter l'entrée
     return entree;
 }
 
@@ -358,6 +358,19 @@ HUD * creerHUD(int x, int y, int hauteur, int largeur, int outlineColor, int nbT
     return hud;
 }
 
+void freeHUD(HUD * hud) {
+    /* Fonction permettant de libérer l'espace mémoire pris par la HUD*/
+    for(int i = 0; i < hud->nbText; i++) {
+        free(hud->textWidgets[i]);
+    }
+    free(hud->textWidgets);
+    for(int i = 0; i < hud->nbStatBar; i++) {
+        free(hud->statBarWidgets[i]);
+    }
+    free(hud->statBarWidgets);
+    free(hud);
+}
+
 void freeEntreeTexte(EntreeTexte * entree) {
     /* Fonction permettant de libérer l'espace mémoire pris par l'affichage de l'entrée texte
     quand le menu se ferme*/
diff --git a/ui/ui.h b/ui/ui.h
index 583a1e3..27983ec 100644
--- a/ui/ui.h
+++ b/ui/ui.h
@@ -62,7 +62,6 @@ typedef struct {
     int nbBoutCol;
     int nbBoutLig;
     Bouton *** boutons;
-    Bouton * reprendre;
     int curseurCol;
     int curseurLig;
     short curseurObj;
@@ -95,6 +94,7 @@ typedef struct {
     int couleur;
     int curseur;
     Texte * titre;
+    int quitter;
 }EntreeTexte;
 
 typedef struct {
@@ -163,6 +163,6 @@ void pauseBoucle(WINDOW *mainwin, int *touche, MiniMenu *pause, int *jeuEtat, in
 // free
 void freeEntreeTexte(EntreeTexte * entree); //Libère les espaces d'entrée de texte du terminal
 void freeTexte(Texte * texte); //Libère le texte du terminal
-
+void freeHUD(HUD * hud); //Libère la HUD
 
 #endif
\ No newline at end of file