fix memory leaks et nb of defenders

src/controlpanel.c

@@ -125,6 +125,7 @@ void Panel_drawNode(Panel * self, Node * n)
     char * soldierText = malloc(20*sizeof(char));
     sprintf(soldierText, "%d", n->soldiers + n->soldiersToAdd);
     DrawText(soldierText, (int)screenPosition.x - MeasureText(soldierText, 20)/2, (int)screenPosition.y, 20, n->color);
+    free(soldierText);
 }
 
 void Panel_drawEdge(Panel * self, Edge * e)

src/graphical-aspect.c

@@ -148,16 +148,19 @@ int Graphic_ChooseNumberOfAttackers(Player * attacker, Player * defender, Node *
     bool endAnimation = false;
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
 
-    Rectangle * nbAttackerRectangle = malloc(10*sizeof(Rectangle));
+    Rectangle nbAttackerRectangle[10];
     printf("number dice avail %d \n", originNode->soldiersToAdd + originNode->soldiers );
     for(int i = 0 ; i <  originNode->soldiersToAdd + originNode->soldiers ; i ++){
         nbAttackerRectangle[i] = (Rectangle){200 + (i-1)*250, screenHeight - 500, 150, 70};
         printf("rectangle %d position : %f %f \n", i, nbAttackerRectangle[i].x, nbAttackerRectangle[i].y);
     }
-    char * whoseTurnToAttack = malloc(20*sizeof(char));
+     //char * whoseTurnToAttack = malloc(20*sizeof(char));
+     char whoseTurnToAttack[20];
     sprintf(whoseTurnToAttack, "Player %d attacks ", attacker->ID);
-    char * whoseTurnToDefend = malloc(20*sizeof(char));
-    sprintf(whoseTurnToDefend, "Player %d", defender->ID);
+    //char * whoseTurnToDefend = malloc(20*sizeof(char));
+    char whoseTurnToDefend[20];
+    sprintf(whoseTurnToDefend, "Player %d", defender->ID); 
+    
    
 
     //--------------------------------------------------------------------------------------
@@ -178,10 +181,9 @@ int Graphic_ChooseNumberOfAttackers(Player * attacker, Player * defender, Node *
             DrawText("How many dices do you want to involve in the fight ?", screenWidth/2 - (MeasureTextEx(font, "How many dice do you want to involve in the fight ?", 30.0, 3.0).x)/2 + 50 , 150 , 30, attacker->color);
             for(int i = 1 ; i < originNode->soldiersToAdd + originNode->soldiers ; i ++){
                 DrawRectangleRec(nbAttackerRectangle[i], BLACK);
-                char * str_i = malloc(sizeof(int));
+                char str_i[5];
                 sprintf(str_i, "%d", i);
                 DrawTextEx(font, str_i, (Vector2){nbAttackerRectangle[i].x + 55, nbAttackerRectangle[i].y + 5 }, 70.0, 3.0, WHITE);
-                free(str_i);
                 if(CheckCollisionPointRec(mousePosition, nbAttackerRectangle[i])){
                         DrawRectangleLinesEx(nbAttackerRectangle[i], 5, GREEN);
                     }
@@ -200,13 +202,13 @@ int Graphic_ChooseNumberOfAttackers(Player * attacker, Player * defender, Node *
     // De-Initialization
     //--------------------------------------------------------------------------------------
     // Texture unloading
-    free(whoseTurnToAttack);
-    free(whoseTurnToDefend);
-    free(nbAttackerRectangle);
+    //free(whoseTurnToAttack);
+    //free(whoseTurnToDefend);
+    //free(nbAttackerRectangle);
     //--------------------------------------------------------------------------------------
     
 }
-void diceRolling(Player * attacker, Player * defender, Node * originNode, Node * targetNode, int nbOfAttackers, int * listOfDices, Font font)
+void diceRolling(Player * attacker, Player * defender, Node * originNode, Node * targetNode, int nbOfAttackers,int nbOfDefenders, int * listOfDices, Font font)
 {   
     printf("dice rolling begin\n");    
 
@@ -221,7 +223,11 @@ void diceRolling(Player * attacker, Player * defender, Node * originNode, Node *
     //Texture2D diceTexture = LoadTexture("diceRolling.png");        // Texture loading
     Texture2D diceTexture = LoadTextureFromImage(texture);
     
-    int defendersCount = targetNode->soldiers >= 3? 2:1;
+    int defendersCount = nbOfDefenders;
+    printf("defender nbofsoldiers : %d \n", defendersCount);
+    for(int  i = 0; i< defendersCount+nbOfAttackers; i++){
+        printf("listOfdices [%d] : %d \n",i,listOfDices[i]);
+    }
     int attackersCount = nbOfAttackers;
 
     Rectangle frameRec = { 0.0f, 0.0f, (float)diceTexture.width, (float)diceTexture.height/9 };
@@ -245,7 +251,7 @@ void diceRolling(Player * attacker, Player * defender, Node * originNode, Node *
     for(int i = 0 ; i < nbOfAttackers ; i++){
         positionDiceAttacker[i] = (Vector2){200 + (i)*150, screenHeight - 500};
     }
-    for(int i = 0 ; i < defendersCount + 1 ; i++){
+    for(int i = 0 ; i < defendersCount  ; i++){
         positionDiceDefender[i] = (Vector2){1000 + (i)*150, screenHeight - 500};
     }
 
@@ -302,7 +308,7 @@ void diceRolling(Player * attacker, Player * defender, Node * originNode, Node *
         framesCounter++;
         frameExit++;
         //printf("%d frame before Exit1 \n", frameExit);
-        if(frameExit == 450) endDisplayResult = true;
+        if(frameExit == 350) endDisplayResult = true;
         if (framesCounter >= (60/framesSpeed))
         {
             framesCounter = 0;
@@ -363,7 +369,7 @@ void diceRolling(Player * attacker, Player * defender, Node * originNode, Node *
                 }
                 //DrawTextureRec(diceTexture, frameRec, positionDiceAttacker[i], WHITE);
             }
-            for(int i = nbOfAttackers ; i <  nbOfAttackers + defendersCount +1; i++){
+            for(int i = nbOfAttackers ; i <  nbOfAttackers + defendersCount ; i++){
                 switch (listOfDices[i])
                 {
                 case 1:
@@ -419,7 +425,7 @@ void diceRolling(Player * attacker, Player * defender, Node * originNode, Node *
             
             if(targetNode->soldiers <= 0){
                 //printf("Node has been conquered\n");
-                DrawTextEx(font, "Node has been conquered", (Vector2){screenWidth/2 - MeasureTextEx(font, "Node has been conquered",50.0, 3.0 ).x/2 , 700}, 50.0, 3.0, BLACK);
+                DrawTextEx(font, "Node has been conquered", (Vector2){screenWidth/2 - MeasureTextEx(font, "Node has been conquered",50.0, 3.0 ).x/2 -50 , 700}, 50.0, 3.0, BLACK);
                 //Player_remove_Node(defender, targetNode);
                 //Player_add_Node(self, targetNode);
                 //targetNode->soldiers = attackersCount;
@@ -438,7 +444,8 @@ void diceRolling(Player * attacker, Player * defender, Node * originNode, Node *
     free(whoseTurnToAttack);
     free(whoseTurnToDefend);
     free(positionDiceAttacker);
-    free(positionDiceDefender);        // Close window and OpenGL context
+    free(positionDiceDefender);   
+    UnloadImage(texture);     // Close window and OpenGL context
     UnloadTexture(diceTexture);
     //--------------------------------------------------------------------------------------
 

src/graphical-aspect.h

@@ -19,7 +19,7 @@ void Graphic_MouseHoverNodeChooseAttacker(Player * player, Vector2 mousePosition
 void Graphic_MouseHoverNodeChooseTarget(Node * originNode, Vector2 mousePosition, Panel * panel);
 void Graphic_RectuementBeginTurn(int screenWidth, int screenHeight, Font font);
 int Graphic_ChooseNumberOfAttackers(Player * attacker, Player * defender, Node * originNode, Node * targetNode, Font font);
-void diceRolling(Player * attacker, Player * defender, Node * originNode, Node * targetNode, int nbOfAttackers, int * listOfDices, Font font);
+void diceRolling(Player * attacker, Player * defender, Node * originNode, Node * targetNode, int nbOfAttackers, int nbOfDefenders, int * listOfDices, Font font);
 
 
 

src/int-input.c

@@ -17,6 +17,7 @@ Int_Input * Int_Input_init(char* name, int * targetInt, Rectangle inputBox){
 }
 
 void Int_Input_delete(Int_Input * self){
+    free(self->value);
     free(self);
 }
 

src/main-menu.c

@@ -41,6 +41,7 @@ void Main_Menu_delete(Main_Menu * self){
     for(int index = 0; index < self->buttonCount; index++){
         Menu_Button_delete(self->buttons[index]);
     }
+    free(self->buttons);
     free(self);
 }
 

src/main-viewer.c

@@ -36,11 +36,14 @@ int main(int nbArg, char ** arg)
 {
     int nodeCount = 10;
     int playerCount = 3;
-    NetWorld * world = malloc(sizeof(NetWorld));
-    Player * players = malloc(sizeof(Player));
 
     // Game Initialization
     //--------------------
+    //Initialising a new game with inputted parameters 
+    Color colors[] = {BLACK, RED, BLUE, GREEN, PURPLE, PINK, YELLOW};
+    Player * players = Player_newArray(playerCount, colors);
+    NetWorld * world = NetWorld_new(nodeCount, playerCount);
+    Random_map(world);
     Panel * panel= Panel_new();
     Panel_initialize(panel, world, screenWidth, screenHeight);
 
@@ -69,11 +72,6 @@ int main(int nbArg, char ** arg)
                 Vector2 mousePos = GetMousePosition();
                 manager->display = Main_Menu_detect_click(menu, &mousePos);
                 if(manager->display == game_ui){
-                    //Initialising a new game with inputted parameters 
-                    *world = *NetWorld_new(nodeCount, playerCount);
-                    Random_map(world);
-                    Color colors[] = {BLACK, RED, BLUE, GREEN, PURPLE, PINK, YELLOW};
-                    players = Player_newArray(playerCount, colors);
                     //Distribute nodes to players evenly
                     for(int index = 0; index < world->size; index++){
                         Player_add_Node(&(players[index % playerCount]), &(world->nodes[index]));
@@ -132,10 +130,11 @@ int main(int nbArg, char ** arg)
     //---------------
     
     NetWorld_delete(world);
-    Player_delete(players);
+    Players_delete(players, playerCount);
     Main_Menu_delete(menu);
     Options_Menu_delete(optionsMenu);
     Window_Manager_delete(manager);
+    Panel_delete(panel);
     UnloadFont(gameFont); 
     CloseWindow();   // Close window and OpenGL context
  
@@ -195,9 +194,14 @@ void game_update(NetWorld * world, Player * players, Font font, Panel * panel)
                             else if(Node_are_connected(originNode, currentNode) && (originNode->soldiers > 1) && originNode->canAttack){
                                 printf("Engagine attack on target Node\n");
                                 int nbOfAttackers = Graphic_ChooseNumberOfAttackers(currentPlayer, &(players[nodePlayerID]), originNode, currentNode, font);
-                                int * listOfDices = Player_attack_Node(currentPlayer, &(players[nodePlayerID]), originNode, currentNode, nbOfAttackers);
-                                int defendersCount = currentNode->soldiers >= 3? 2:1;
-                                diceRolling(currentPlayer, &(players[nodePlayerID]), originNode, currentNode, nbOfAttackers , listOfDices ,font);
+                                int nbOfDefenders = currentNode->soldiers;
+                                printf("nbOfAtackers %d \n", nbOfAttackers);
+                                printf("nbOfdefenders %d \n", nbOfDefenders);
+                                int * listOfDices = Player_attack_Node(currentPlayer, &(players[nodePlayerID]), originNode, currentNode, nbOfAttackers);           
+                                for(int  i = 0; i< nbOfDefenders+nbOfAttackers; i++){
+                                    printf("listOfdices3 [%d] : %d \n",i,listOfDices[i]);
+                                     }
+                                diceRolling(currentPlayer, &(players[nodePlayerID]), originNode, currentNode, nbOfAttackers ,nbOfDefenders, listOfDices ,font);
                                 currentPlayer->hasSelectedNode = false;
                                 free(listOfDices);
                             }else{

src/networld.c

@@ -22,8 +22,8 @@ void Node_construct(Node * self)
     self->playerID = -1;
     Rectangle tmp = {0,0,48,48};
     self->collisionHitbox = tmp;
-    strcpy(self->continent, "None");
-    strcpy( self->name, "Node" );
+    self->continent =  "None";
+    self->name = "Node" ;
     self->canAttack = true;
 }
 
@@ -47,6 +47,8 @@ Node * Node_newArray(int size)
 
 void Node_delete( Node * node )
 {
+    free(node->continent);
+    free(node->name);
     Edge_deleteArray( node->card, node->edges );
     free( node );
 }
@@ -57,7 +59,8 @@ void Node_delete( Node * node )
 void Node_deleteArray( int n, Node * array )
 {
     for(int i= 0 ; i < n ; ++i )
-        Edge_deleteArray( array[i].card, array[i].edges );
+        Node_delete((array+i));
+        //Edge_deleteArray( array[i].card, array[i].edges );
     free( array );
 }
 

src/options-menu.c

@@ -41,5 +41,6 @@ void Options_Menu_delete(Options_Menu * self){
     for(int index = 0; index < self->inputCount; index++){
         Int_Input_delete(self->inputs[index]);
     }
+    free(self->inputs);
     free(self);
 }
\ No newline at end of file

src/player.c

@@ -33,9 +33,14 @@ Player * Player_newArray(int size, Color color[])
     return p;
 }
 
-void Player_delete( Player * player )
-{
-    free( player );
+void Players_delete(Player * player, int size)
+{   
+    for(int i = 0 ; i < size ; i++){
+        free((player+i)->nodes);
+        free((player+i)->selectedNode);
+        free((player+i));
+    }
+    free(player);
 }
 
 void Player_add_Node( Player * self, Node * node )
@@ -153,7 +158,7 @@ void Player_confirm_recrutement(Player * self){
 int * Player_attack_Node(Player * self, Player * defender, Node * originNode, Node * targetNode, int numberOfAttackers){
     int * listOfDices = malloc(20*sizeof(int));
     int attackersCount = numberOfAttackers;
-    int defendersCount = targetNode->soldiers >= 3? 2:1;
+    int defendersCount = targetNode->soldiers;
     int attDiceRolls[attackersCount];
     int defDiceRolls[defendersCount];
 
@@ -226,6 +231,9 @@ int * Player_attack_Node(Player * self, Player * defender, Node * originNode, No
     }
 
     originNode->canAttack = false;
+    for(int  i = 0; i< defendersCount+attackersCount; i++){
+        printf("listOfdices2 [%d] : %d \n",i,listOfDices[i]);
+    }
     return listOfDices;
 }
 

src/player.h

@@ -49,9 +49,11 @@ Player * Player_newArray(int size, Color colors[]);
 /**
  * @brief    Destructor.
  */
-void Player_delete(
-    //! the Player to delete
-    Player * self
+void Players_delete(
+    //! the Player list to delete
+    Player * self,
+    //! the Player list size to delete
+    int size
 );
 
 /**