Amélioration gestion memoire

Serveur/game.c

@@ -50,34 +50,27 @@ void ini_games(){
     }
 }
 
-JsonArray* list_map(){
+void list_map(JsonArray* res){
     char** result;
     int nbResult;
-    JsonArray* ja;
-    //Initialisation json
-    ja = malloc(sizeof(JsonArray));
-    ini_array_encoder(ja);
     //Regarde les fichiers dans le dossier
     result = file_list(MAPDIR, &nbResult);
     for(int i = 0; i < nbResult; i++){
-        add_array_string(ja, result[i]);
+        add_array_string(res, result[i]);
         free(result[i]);
     }
     free(result);
-    return ja;
 }
 
-JsonArray* list_game(){
-    JsonArray* ja;
-    JsonEncoder* je;
+int list_game(JsonArray* res){
+    JsonEncoder gameJson;
     int compteur = 0, i = 0;
     //Si il n' y a aucune game
     if(nbGame == 0){
-        return NULL;
+        return 0;
     }
     //Initialisation json
-    ja = malloc(sizeof(JsonArray));
-    ini_array_encoder(ja);
+    ini_encoder(&gameJson);
     //Ajoute chaque game
     while(compteur < nbGame && i < MAXGAME){
         if(!game[i].active){
@@ -85,21 +78,18 @@ JsonArray* list_game(){
             continue;
         }
         //Creation objet json
-        je = malloc(sizeof(JsonEncoder));
-        ini_encoder(je);
-        add_string(je, "name", game[i].name);
-        add_integer(je, "nbPlayer", game[i].nbPlayer);
-        add_string(je, "map", game[i].mapName);
+        add_string(&gameJson, "name", game[i].name);
+        add_integer(&gameJson, "nbPlayer", game[i].nbPlayer);
+        add_string(&gameJson, "map", game[i].mapName);
         //Ajout dans le tableau
-        add_array_object(ja, je);
-        //Suppr encoder objet
-        clean_json_encoder(je);
-        free(je);
+        add_array_object(res, &gameJson);
+        //Nettoyage encoder objet
+        clean_json_encoder(&gameJson);
         //Incremente
         i++;
         compteur++;
     }
-    return ja;
+    return nbGame;
 }
 
 int* map_size(char* map){
@@ -192,48 +182,44 @@ int add_player(Game* g, int cliId){
     return index;
 }
 
-JsonEncoder* describe_game(Game* g, int playerIndex){
-    JsonEncoder* player;
-    JsonEncoder* desc = malloc(sizeof(JsonEncoder));
-    JsonEncoder* map = malloc(sizeof(JsonEncoder));
-    JsonArray* players = malloc(sizeof(JsonArray));
+void describe_game(Game* g, int playerIndex, JsonEncoder* desc){
+    JsonEncoder player;
+    JsonEncoder map;
+    JsonArray players;
     char* content;
     //Initialisation
-    ini_encoder(desc);
-    ini_encoder(map);
-    ini_array_encoder(players);
+    ini_encoder(&player);
+    ini_encoder(&map);
+    ini_array_encoder(&players);
     //Info map
     content = remove_char(g->mapContent, '\n'); //La map sans \n car interdit en JSON
-    add_integer(map, "width", g->width);
-    add_integer(map, "height", g->height);
-    add_string(map, "content", content);
+    add_integer(&map, "width", g->width);
+    add_integer(&map, "height", g->height);
+    add_string(&map, "content", content);
     free(content);
     //Ajout info
     add_integer(desc, "nbPlayers", g->nbPlayer);
-    add_object(desc, "map", map);
+    add_object(desc, "map", &map);
     //Ajout info courte joueur
     //printf("Add players\n");
     for(int i = 0; i < MAXPLAYER; i++){
         if(g->player[i]->ini){
-            player = describe_short_player(g->player[i]);
-            add_array_object(players, player);
-            clean_json_encoder(player);
-            free(player);
+            describe_short_player(g->player[i], &player);
+            add_array_object(&players, &player);
+            clean_json_encoder(&player);  
         }
     }
     //printf("Fin Add players\n");
-    add_array(desc, "players", players);
+    add_array(desc, "players", &players);
     //Si besoins ajout un joueur
     if(playerIndex >= 0 && playerIndex < MAXPLAYER && g->player[playerIndex]->ini){
-        player = describe_player(g->player[playerIndex]);
-        add_object(desc, "player", player);
-        clean_json_encoder(player);
-        free(player);
+        describe_player(g->player[playerIndex], &player);
+        add_object(desc, "player", &player);
+        clean_json_encoder(&player);
     }
     //Nettoyage
-    clean_json_encoder(map);
-    free(map);
-    return desc;
+    clean_json_encoder(&map);
+    clean_json_array(&players);
 }
 
 boolean notify_player(Game* g, char* method, char* ressource, JsonEncoder* param, int excludePlayerId){
@@ -274,6 +260,8 @@ void stop_game(Game* g){
     free(g->map);
     free(g->mapName);
     free(g->mapContent);
+    //Retire une game
+    nbGame--;
 }
 
 void clean_games(){

Serveur/game.h

@@ -42,15 +42,16 @@ void ini_games();
 
 /**
  * Liste le nom de toutes les maps sous forme de JSON
- * @return JsonArray* Les maps existantes
+ * @param JsonArray* Structure de reponse pour les maps existantes
  */
-JsonArray* list_map();
+void list_map(JsonArray*);
 
 /**
  * Liste les game en cours en JSON
- * @return JsonArray* Les games existantes
+ * @param JsonArray* Structure de reponse pour les games existantes
+ * @return int Le nombre de game active
  */
-JsonArray* list_game();
+int list_game(JsonArray*);
 
 /**
  * Donne les dimension d'une carte
@@ -63,7 +64,7 @@ int create_game(char*, char*);
 
 int add_player(Game*, int);
 
-JsonEncoder* describe_game(Game*, int);
+void describe_game(Game*, int, JsonEncoder*);
 
 boolean notify_player(Game*, char*, char*, JsonEncoder*, int);
 

Serveur/handler.c

@@ -109,25 +109,26 @@ int handler_client_end(int cliId, JsonParser* json){
 
 int handler_game_list(int cliId, JsonParser* json){
     JsonEncoder reponse;
-    JsonArray* game;
-    JsonArray* map;
+    JsonArray game;
+    JsonArray map;
+    int nb;
     //Recup la liste des parties et des cartes
-    game = list_game();
-    map = list_map();
+    ini_array_encoder(&game);
+    ini_array_encoder(&map);
+    nb = list_game(&game);
+    list_map(&map);
     //Creation reponse
     ini_encoder(&reponse);
     add_string(&reponse, "action", "game/list");
     add_string(&reponse, "status", "200");
     add_string(&reponse, "message", "ok");
-    if(game == NULL){
+    if(nb == 0){
         add_integer(&reponse, "numberGameList", 0);
     } else {
-        add_integer(&reponse, "numberGameList", nbGame);
-        add_array(&reponse, "games", game);
-        clean_json_array(game);
-        free(game);
+        add_integer(&reponse, "numberGameList", nb);
+        add_array(&reponse, "games", &game);
     }
-    add_array(&reponse, "maps", map);
+    add_array(&reponse, "maps", &map);
     //Envoi reponse au client
     if(!send_client(cliId, &reponse)){
         adderror("Impossible de répondre au client");
@@ -135,15 +136,15 @@ int handler_game_list(int cliId, JsonParser* json){
     }
     //Nettoyage
     clean_json_encoder(&reponse);
-    clean_json_array(map);
-    free(map);
+    clean_json_array(&map);
+    clean_json_array(&game);
     return SUCCESS;
 }
 
 int handler_game_create(int cliId, JsonParser* json){
     char* map, * name, * msg;
     int index, joueur;
-    JsonEncoder* reponse;
+    JsonEncoder reponse;
     //Verification arguments
     if(get_pos(json, "name") == JSON_ERROR){
         send_err_client(cliId, EREQUEST);
@@ -158,71 +159,59 @@ int handler_game_create(int cliId, JsonParser* json){
     //Recup valeur
     map = get_string(json, "map");
     name = get_string(json, "name");
+    //Initialisation reponse JSON
+    ini_encoder(&reponse);
+    add_string(&reponse, "action", "game/create");
     //Verif nom non existant
     if(search_game(name) != ERR){
-        reponse = malloc(sizeof(JsonEncoder));
-        ini_encoder(reponse);
-        add_string(reponse, "action", "game/create");
-        add_string(reponse, "status", "501");
-        add_string(reponse, "message", "Cannot create game");
-        if(!send_client(cliId, reponse)){
+        add_string(&reponse, "status", "501");
+        add_string(&reponse, "message", "Cannot create game");
+        if(!send_client(cliId, &reponse)){
             adderror("Impossible de répondre au client");
         }
-        clean_json_encoder(reponse);
-        free(reponse);
+        clean_json_encoder(&reponse);
         return FAIL;
     }
     //Creation
     index = create_game(name, map);
     if(index == ERR){
-        reponse = malloc(sizeof(JsonEncoder));
-        ini_encoder(reponse);
-        add_string(reponse, "action", "game/create");
-        add_string(reponse, "status", "501");
-        add_string(reponse, "message", "Cannot create game");
-        if(!send_client(cliId, reponse)){
+        add_string(&reponse, "status", "501");
+        add_string(&reponse, "message", "Cannot create game");
+        if(!send_client(cliId, &reponse)){
             adderror("Impossible de répondre au client");
         }
-        clean_json_encoder(reponse);
-        free(reponse);
+        clean_json_encoder(&reponse);
         return FAIL;
     }
     //Ajout du joueur dans la partie
     joueur = add_player(&game[index], cliId);
     if(joueur == ERR){
         stop_game(&game[index]);
-        reponse = malloc(sizeof(JsonEncoder));
-        ini_encoder(reponse);
-        add_string(reponse, "action", "game/create");
-        add_string(reponse, "status", "501");
-        add_string(reponse, "message", "Cannot create game");
-        if(!send_client(cliId, reponse)){
+        add_string(&reponse, "status", "501");
+        add_string(&reponse, "message", "Cannot create game");
+        if(!send_client(cliId, &reponse)){
             adderror("Impossible de répondre au client");
         }
-        clean_json_encoder(reponse);
-        free(reponse);
+        clean_json_encoder(&reponse);
         return FAIL;
     }
     //Recup info
-    reponse = describe_game(&game[index], joueur);
+    describe_game(&game[index], joueur, &reponse);
     //Ajout infos
     msg = new_string(25 + strlen(map));
     sprintf(msg, "Game created with %s", map);
-    add_string(reponse, "action", "game/create");
-    add_string(reponse, "status", "201");
-    add_string(reponse, "message", msg);
-    add_string(reponse, "startPos", "0,0");
+    add_string(&reponse, "status", "201");
+    add_string(&reponse, "message", msg);
+    add_string(&reponse, "startPos", "0,0");
     free(msg);
     //Envoi
-    if(!send_client(cliId, reponse)){
+    if(!send_client(cliId, &reponse)){
         adderror("Impossible de répondre au client");
-        clean_json_encoder(reponse);
-        free(reponse);
+        clean_json_encoder(&reponse);
         return FAIL;
     }
     //Nettoyage
-    clean_json_encoder(reponse);
-    free(reponse);
+    clean_json_encoder(&reponse);
     free(map);
     free(name);
     return SUCCESS;
@@ -231,7 +220,7 @@ int handler_game_create(int cliId, JsonParser* json){
 int handler_game_join(int cliId, JsonParser* json){
     char* name;
     int index, joueur;
-    JsonEncoder* reponse;
+    JsonEncoder reponse;
     //Verification arguments
     if(get_pos(json, "name") == JSON_ERROR){
         send_err_client(cliId, EREQUEST);
@@ -240,61 +229,50 @@ int handler_game_join(int cliId, JsonParser* json){
     }
     //Recup valeur
     name = get_string(json, "name");
+    //Initialisation json reponse
+    ini_encoder(&reponse);
+    add_string(&reponse, "action", "game/join");
     //Verif nom non existant
     index = search_game(name);
-    if(index == ERR){
-        reponse = malloc(sizeof(JsonEncoder));
-        ini_encoder(reponse);
-        add_string(reponse, "action", "game/join");
-        add_string(reponse, "status", "501");
-        add_string(reponse, "message", "Cannot join the game game");
-        if(!send_client(cliId, reponse)){
+    if(index == ERR){        
+        add_string(&reponse, "status", "501");
+        add_string(&reponse, "message", "Cannot join the game game");
+        if(!send_client(cliId, &reponse)){
             adderror("Impossible de répondre au client");
         }
-        clean_json_encoder(reponse);
-        free(reponse);
+        clean_json_encoder(&reponse);
         return FAIL;
     }
     //Ajout du joueur dans la partie
     joueur = add_player(&game[index], cliId);
     if(joueur == ERR){
-        reponse = malloc(sizeof(JsonEncoder));
-        ini_encoder(reponse);
-        add_string(reponse, "action", "game/join");
-        add_string(reponse, "status", "501");
-        add_string(reponse, "message", "Cannot join the game");
-        if(!send_client(cliId, reponse)){
+        add_string(&reponse, "status", "501");
+        add_string(&reponse, "message", "Cannot join the game");
+        if(!send_client(cliId, &reponse)){
             adderror("Impossible de répondre au client");
         }
-        clean_json_encoder(reponse);
-        free(reponse);
+        clean_json_encoder(&reponse);
         return FAIL;
     }
     //Recup info
-    reponse = describe_game(&game[index], joueur);
+    describe_game(&game[index], joueur, &reponse);
     //Ajout infos
-    add_string(reponse, "action", "game/join");
-    add_string(reponse, "status", "201");
-    add_string(reponse, "startPos", "0,0");
+    add_string(&reponse, "status", "201");
+    add_string(&reponse, "startPos", "0,0");
     //Envoi
-    if(!send_client(cliId, reponse)){
+    if(!send_client(cliId, &reponse)){
         adderror("Impossible de répondre au client");
-        clean_json_encoder(reponse);
-        free(reponse);
+        clean_json_encoder(&reponse);
         return FAIL;
     }
     //Nettoyage
-    clean_json_encoder(reponse);
-    free(reponse);
+    clean_json_encoder(&reponse);
     free(name);
     //Avertit les autres joueurs
-    reponse = malloc(sizeof(JsonEncoder));
-    ini_encoder(reponse);
-    add_integer(reponse, "id", cliId);
-    add_string(reponse, "pos", "0,0");
-    notify_player(&game[index], "POST", "game/newplayer", reponse, cliId);
+    add_integer(&reponse, "id", cliId);
+    add_string(&reponse, "pos", "0,0");
+    notify_player(&game[index], "POST", "game/newplayer", &reponse, cliId);
     //Nettoyage
-    clean_json_encoder(reponse);
-    free(reponse);
+    clean_json_encoder(&reponse);
     return SUCCESS;
 }

Serveur/player.c

@@ -30,52 +30,66 @@ void create_player(Player* p, Client* c){
     p->brokenLeg = 0;
     p->lifeMax = 0;
     p->lifeUp = 0;
-    p->major = false;
+    p->major = 0;
 }
 
-JsonEncoder* describe_player(Player* p){
-    JsonEncoder* desc = malloc(sizeof(JsonEncoder));
+void describe_player(Player* p, JsonEncoder* desc){
+    JsonEncoder* bonus = malloc(sizeof(JsonEncoder));
+    JsonArray* bm = malloc(sizeof(JsonArray));
     /*JsonArray* bonus = malloc(sizeof(JsonArray));
     char buffer[BUFFER_SIZE];*/
     //Initialisation
     ini_encoder(desc);
-    //ini_array_encoder(bonus);
+    ini_encoder(bonus);
+    ini_array_encoder(bm);
     //Calcul bonus malus
-    /*if(p->bombUp > 0){
-        memset(buffer, 0, BUFFER_SIZE);
-        snprintf(buffer, BUFFER_SIZE, "{\"class\": \"bomb_up\", \"number\": %d}", p->bombUp);
-        add_array_value(bonus, buffer);
+    if(p->bombUp > 0){
+        add_string(bonus, "class", "bomb_up");
+        add_integer(bonus, "number", p->bombUp);
+        add_array_object(bm, bonus);
+        clean_json_encoder(bonus);
     }
     if(p->bombDown > 0){
-        memset(buffer, 0, BUFFER_SIZE);
-        snprintf(buffer, BUFFER_SIZE, "{\"class\": \"bomb_down\", \"number\": %d}", p->bombDown);
-        add_array_value(bonus, buffer);
+        add_string(bonus, "class", "bomb_down");
+        add_integer(bonus, "number", p->bombDown);
+        add_array_object(bm, bonus);
     }
     if(p->firePower > 0){
-        memset(buffer, 0, BUFFER_SIZE);
-        snprintf(buffer, BUFFER_SIZE, "{\"class\": \"fire_power\", \"number\": %d}", p->firePower);
-        add_array_value(bonus, buffer);
+        add_string(bonus, "class", "fire_power");
+        add_integer(bonus, "number", p->firePower);
+        add_array_object(bm, bonus);
+        clean_json_encoder(bonus);
     }
     if(p->scooter > 0){
-        memset(buffer, 0, BUFFER_SIZE);
-        snprintf(buffer, BUFFER_SIZE, "{\"class\": \"scooter\", \"number\": %d}", p->scooter);
-        add_array_value(bonus, buffer);
+        add_string(bonus, "class", "scooter");
+        add_integer(bonus, "number", p->scooter);
+        add_array_object(bm, bonus);
+        clean_json_encoder(bonus);
     }
     if(p->brokenLeg > 0){
-        memset(buffer, 0, BUFFER_SIZE);
-        snprintf(buffer, BUFFER_SIZE, "{\"class\": \"broken_leg\", \"number\": %d}", p->brokenLeg);
-        add_array_value(bonus, buffer);
+        add_string(bonus, "class", "broken_leg");
+        add_integer(bonus, "number", p->brokenLeg);
+        add_array_object(bm, bonus);
+        clean_json_encoder(bonus);
     }
     if(p->lifeUp > 0){
-        memset(buffer, 0, BUFFER_SIZE);
-        snprintf(buffer, BUFFER_SIZE, "{\"class\": \"life_up\", \"number\": %d}", p->lifeUp);
-        add_array_value(bonus, buffer);
+        add_string(bonus, "class", "life_up");
+        add_integer(bonus, "number", p->lifeUp);
+        add_array_object(bm, bonus);
+        clean_json_encoder(bonus);
     }
     if(p->lifeMax > 0){
-        memset(buffer, 0, BUFFER_SIZE);
-        snprintf(buffer, BUFFER_SIZE, "{\"class\": \"life_max\", \"number\": %d}", p->lifeMax);
-        add_array_value(bonus, buffer);
-    }*/ //Inutile jamais utilisé
+        add_string(bonus, "class", "life_max");
+        add_integer(bonus, "number", p->lifeMax);
+        add_array_object(bm, bonus);
+        clean_json_encoder(bonus);
+    }
+    if(p->major > 0){
+        add_string(bonus, "class", "major");
+        add_integer(bonus, "number", p->major);
+        add_array_object(bm, bonus);
+        clean_json_encoder(bonus);
+    }
     //Ajout valeur
     add_integer(desc, "id", p->id);
     add_integer(desc, "life", p->life);
@@ -85,16 +99,15 @@ JsonEncoder* describe_player(Player* p){
     add_integer(desc, "currentNbMine", p->mine);
     add_integer(desc, "currentNbRemoteBomb", p->remoteBomb);
     add_integer(desc, "maxNbBomb", p->maxBomb);
-    //add_array(desc, "bonus-malus", bonus);
+    add_array(desc, "bonus-malus", bm);
     //Nettoyage
-    /*clean_json_array(bonus);
-    free(bonus);*/
-    return desc;
+    clean_json_array(bm);
+    free(bonus);
+    free(bm);
 }
 
-JsonEncoder* describe_short_player(Player* p){
+void describe_short_player(Player* p, JsonEncoder* desc){
     char pos[40];
-    JsonEncoder* desc = malloc(sizeof(JsonEncoder));
     //Creation chaine
     memset(pos, 0, 40);
     snprintf(pos, 40, "%d,%d", p->x, p->y);
@@ -102,7 +115,6 @@ JsonEncoder* describe_short_player(Player* p){
     ini_encoder(desc);
     add_integer(desc, "id", p->id);
     add_string(desc, "pos", pos);
-    return desc;
 }
 
 void delete_player(Player* p){

Serveur/player.h

@@ -36,7 +36,7 @@ typedef struct{
     int brokenLeg;
     int lifeMax;
     int lifeUp;
-    boolean major; //Seul exception boolean si actif ou non
+    int major;
 }Player;
 
 /* --- Fonctions --- */
@@ -47,9 +47,9 @@ typedef struct{
  */
 void create_player(Player*, Client*);
 
-JsonEncoder* describe_player(Player*);
+void describe_player(Player*, JsonEncoder*);
 
-JsonEncoder* describe_short_player(Player*);
+void describe_short_player(Player*, JsonEncoder*);
 
 /**
  * Supprime un joueur