fixes mouse hover nodes + edges color + choose nb of dice when attack

src/controlpanel.c

@@ -32,8 +32,8 @@ void Panel_initialize(Panel * self, NetWorld * world, const int screenWidth, con
     self->world= world;
     self->camera.x= 0.f;
     self->camera.y= 0.f;
-    self->screenCenter.x= 400.f;
-    self->screenCenter.y= 300.f;
+    self->screenCenter.x= screenWidth/2;
+    self->screenCenter.y= screenHeight/2;
     self->scale= 10.f; //pixel per meters
     self->screenWidth = screenWidth;
     self->screenHeight = screenHeight;
@@ -66,7 +66,7 @@ void Panel_drawMainMenu(Panel * self, Main_Menu * menu){
 // Rendering
 void Panel_drawGame(Panel * self)
 {
-    BeginDrawing();
+    //BeginDrawing();
     ClearBackground(RAYWHITE);
     
     // Draw the edges for each nodes:
@@ -83,7 +83,7 @@ void Panel_drawGame(Panel * self)
         Panel_drawNode( self, &(self->world->nodes[i]) );
     }
     //Panel_drawBasis(self);
-    EndDrawing(); 
+    //EndDrawing(); 
 }
 
 void Panel_drawBasis(Panel * self)

src/graphical-aspect.c

@@ -88,7 +88,7 @@ void Graphic_MouseHoverNodeRecrutement(Player * player, Vector2 mousePosition, P
         if(CheckCollisionPointRec(mousePosition, currentNode->collisionHitbox)){
             //printf("collision noeud !\n");
             Vector2 screenPosition= Panel_pixelFromPosition(panel, &(currentNode->position) );        
-            DrawCircleV(screenPosition, 29, MAGENTA);
+            DrawRing(screenPosition, 24.0, 28.0, 0.0, 360.0, 0.1, MAGENTA);
             //DrawCircleV(screenPosition, 45, RAYWHITE);
             if(player->soldiers > 0){
                 DrawText("+1", (int)screenPosition.x + 30 , (int)screenPosition.y, 20, MAGENTA);
@@ -103,7 +103,7 @@ void Graphic_MouseHoverNodeChooseAttacker(Player * player, Vector2 mousePosition
         Node* currentNode = player->nodes[nodeIndex];
         if(CheckCollisionPointRec(mousePosition, currentNode->collisionHitbox)){
             Vector2 screenPosition= Panel_pixelFromPosition(panel, &(currentNode->position) );
-            DrawCircleV(screenPosition, 29, GOLD);
+            DrawRing(screenPosition, 24.0, 28.0, 0.0, 360.0, 0.1, GOLD);
             //DrawCircleV(screenPosition, 45, RAYWHITE);
             if(!player->hasSelectedNode){
                 DrawText("attacker", (int)screenPosition.x + 30 , (int)screenPosition.y, 20, GOLD);
@@ -112,16 +112,19 @@ void Graphic_MouseHoverNodeChooseAttacker(Player * player, Vector2 mousePosition
     }
     if(player->hasSelectedNode){
         Vector2 screenPosition= Panel_pixelFromPosition(panel, &(player->selectedNode->position) );
-        DrawCircleV(screenPosition, 29, GOLD);
+        DrawRing(screenPosition, 24.0, 28.0, 0.0, 360.0, 0.1, GOLD);
         DrawText("attacker", (int)screenPosition.x + 30 , (int)screenPosition.y, 20, GOLD);
     }
 }
 void Graphic_MouseHoverNodeChooseTarget(Node * originNode, Vector2 mousePosition, Panel * panel){
     for(int neighbourIndex = 0; neighbourIndex < originNode->card; neighbourIndex++){
         Vector2 screenPosition = Panel_pixelFromPosition(panel, &(originNode->edges[neighbourIndex]._target->position) );
-        /* if( &(originNode->edges[neighbourIndex]._target->color) = &(originNode->color)){          
-            DrawCircleV(screenPosition, 29, GREEN);
-        } */
+        if( &(originNode->edges[neighbourIndex]._target->color) != &(originNode->color)){          
+            DrawRing(screenPosition, 24.0, 30.0, 0.0, 360.0, 0.1, GREEN);
+        } 
+        if(CheckCollisionPointRec(mousePosition, originNode->edges[neighbourIndex]._target->collisionHitbox) && &(originNode->edges[neighbourIndex]._target->color) != &(originNode->color)){
+            DrawRing(screenPosition, 30.0, 33.0, 0.0, 360.0, 0.1, MAROON);
+        }
     }
 }
 
@@ -129,40 +132,127 @@ void Graphic_MouseHoverNodeChooseTarget(Node * originNode, Vector2 mousePosition
 
 
 
+
+
 #define MAX_FRAME_SPEED     15
 #define MIN_FRAME_SPEED      1
 
-void diceRolling()
-{   printf("dice rolling begin\n");    // Initialization
+int Graphic_ChooseNumberOfAttackers(Player * attacker, Player * defender, Node * originNode, Node * targetNode, Font font)
+{      
+
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 1700;
+    const int screenHeight = 800;
+    bool endAnimation = false;
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
+
+    Rectangle * nbAttackerRectangle = malloc(10*sizeof(Rectangle));
+    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));
+    sprintf(whoseTurnToAttack, "Player %d attacks ", attacker->ID);
+    char * whoseTurnToDefend = malloc(20*sizeof(char));
+    sprintf(whoseTurnToDefend, "Player %d", defender->ID);
+   
+
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!endAnimation )    // Detect window close button or ESC key
+    {
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+            Vector2 mousePosition = GetMousePosition(); 
+
+            DrawTextEx(font, whoseTurnToAttack, (Vector2){screenWidth/2 - (MeasureTextEx(font, whoseTurnToAttack, 50.0, 3.0).x) + 50 , 70}  , 50.0, 3.0, attacker->color);
+            DrawTextEx(font, whoseTurnToDefend, (Vector2){screenWidth/2 + 50 , 70}, 50.0, 3.0, defender->color);
+            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));
+                sprintf(str_i, "%d", i);
+                DrawTextEx(font, str_i, (Vector2){nbAttackerRectangle[i].x + 55, nbAttackerRectangle[i].y + 5 }, 70.0, 3.0, WHITE);
+                if(CheckCollisionPointRec(mousePosition, nbAttackerRectangle[i])){
+                        DrawRectangleLinesEx(nbAttackerRectangle[i], 5, GREEN);
+                    }
+                if(IsMouseButtonPressed(MOUSE_LEFT_BUTTON)){
+                    if(CheckCollisionPointRec(mousePosition, nbAttackerRectangle[i])){
+                        printf("colision dés choix %d \n", i);
+                        return i;
+                    }
+                } 
+            }
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    // Texture unloading
+    free(whoseTurnToAttack);
+    free(whoseTurnToDefend);
+    free(nbAttackerRectangle);
     //--------------------------------------------------------------------------------------
-    const int screenWidth1 = 800;
-    const int screenHeight1 = 450;
     
-    InitWindow(screenWidth1, screenHeight1, "raylib [texture] example - texture rectangle");
+}
+void diceRolling(Player * attacker, Player * defender, Node * originNode, Node * targetNode, int nbOfAttackers, Font font)
+{   
+    printf("dice rolling begin\n");    
+
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 1700;
+    const int screenHeight = 800;
 
     // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
-    Texture2D diceTexture = LoadTexture("diceRolling.png");        // Texture loading
+    Image texture =  LoadImage("diceRolling.png"); 
+    ImageResize(&(texture), 100, 800);  
+    //Texture2D diceTexture = LoadTexture("diceRolling.png");        // Texture loading
+    Texture2D diceTexture = LoadTextureFromImage(texture);
+    
 
-    Vector2 position = { 350.0f, 100.0f };
     Rectangle frameRec = { 0.0f, 0.0f, (float)diceTexture.width, (float)diceTexture.height/9 };
     int currentFrame = 0;
 
     int framesCounter = 0;
-    int framesSpeed = 10;  
+    int framesSpeed = 7;  
     int frameExit =  0;        // Number of spritesheet frames shown by second
     bool endAnimation = false;
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
+
     //--------------------------------------------------------------------------------------
+    char * whoseTurnToAttack = malloc(20*sizeof(char));
+    sprintf(whoseTurnToAttack, "Player %d ", attacker->ID);
+    char * whoseTurnToDefend = malloc(20*sizeof(char));
+    sprintf(whoseTurnToDefend, "Player %d ", defender->ID);
+
+    Vector2 * positionDiceAttacker = malloc(20 * sizeof(Vector2));
+    Vector2 * positionDiceDefender = malloc(20 * sizeof(Vector2));
+    for(int i = 0 ; i < nbOfAttackers ; i++){
+        positionDiceAttacker[i] = (Vector2){200 + (i)*250, screenHeight - 500};
+    }
+    for(int i = 0 ; i < targetNode->soldiers + targetNode->soldiersToAdd ; i++){
+        positionDiceDefender[i] = (Vector2){1000 + (i)*250, screenHeight - 500};
+    }
 
     // Main game loop
-    while (!WindowShouldClose() )    // Detect window close button or ESC key
+    while (!endAnimation )    // Detect window close button or ESC key
     {
         // Update
         //----------------------------------------------------------------------------------
         framesCounter++;
-        frameExit++;
-        printf("%d frameExit \n", frameExit);
-        if(frameExit == 100) endAnimation = true;
+        //frameExit++;
+        //printf("%d frame before Exit \n", frameExit);
+        if(frameExit == 200) endAnimation = true;
         if (framesCounter >= (60/framesSpeed))
         {
             framesCounter = 0;
@@ -179,11 +269,17 @@ void diceRolling()
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
-            //Vector2 * positionDiceAttacker = malloc(sizeof(Vector2)*attackerNbDice) ;
-            /* for(int attackerDice = 0; attackerDice < attackerNbDice ; attackerDice++){
             
-            } */
-            DrawTextureRec(diceTexture, frameRec, position, WHITE);  // Draw part of the texture
+            DrawTextEx(font, whoseTurnToAttack, (Vector2){250 , 200}  , 30.0, 3.0, attacker->color);
+            DrawTextEx(font, whoseTurnToDefend, (Vector2){screenWidth-700, 200}, 30.0, 3.0, defender->color);
+            DrawTextEx(font, " attacker", (Vector2){250 + MeasureTextEx(font, "Player X ", 30.0, 3.0).x , 210}  , 15.0, 3.0, attacker->color);
+            DrawTextEx(font, " defender", (Vector2){screenWidth-700 + MeasureTextEx(font, "Player X ", 30.0, 3.0).x, 210}, 15.0, 3.0, defender->color);
+            for(int i = 0 ; i < nbOfAttackers ; i++){
+                DrawTextureRec(diceTexture, frameRec, positionDiceAttacker[i], WHITE);
+            }
+            for(int i = 0 ; i < targetNode->soldiers + targetNode->soldiersToAdd ; i++){
+                DrawTextureRec(diceTexture, frameRec, positionDiceDefender[i], WHITE);
+            }
 
         EndDrawing();
         //----------------------------------------------------------------------------------
@@ -193,10 +289,11 @@ void diceRolling()
     //--------------------------------------------------------------------------------------
            // Texture unloading
 
-    CloseWindow();                // Close window and OpenGL context
+    //CloseWindow();        
+    free(positionDiceAttacker);
+    free(positionDiceDefender);        // Close window and OpenGL context
     UnloadTexture(diceTexture);
     //--------------------------------------------------------------------------------------
 
     
 }
-

src/graphical-aspect.h

@@ -17,7 +17,9 @@ Rectangle Graphic_ConfirmButton(Font font);
 void Graphic_MouseHoverNodeRecrutement(Player * self, Vector2 mousePosition, Panel * panel);
 void Graphic_MouseHoverNodeChooseAttacker(Player * player, Vector2 mousePosition, Panel * panel);
 void Graphic_MouseHoverNodeChooseTarget(Node * originNode, Vector2 mousePosition, Panel * panel);
-void diceRolling();
+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, Font font);
 
 
 

src/main-viewer.c

@@ -50,6 +50,7 @@ int main(int nbArg, char ** arg)
     for(int index = 0; index < world->size; index++){
         Player_add_Node(&(players[index % playerCount]), &(world->nodes[index]));
     }
+
     // Raylib Initialization
     //----------------------
     InitWindow(screenWidth, screenHeight, "NetWorld basic viewer");
@@ -82,7 +83,9 @@ int main(int nbArg, char ** arg)
             }
             break;
         case game_ui:
+            BeginDrawing();
             game_update(world, players, font, panel);
+            EndDrawing();
         default:
             break;
         }
@@ -107,7 +110,7 @@ void game_update(NetWorld * world, Player * players, Font font, Panel * panel)
     Graphic_ShowPlayerInfo(currentPlayer, screenWidth, screenHeight, font);
     Graphic_WhoseTurnIsIt(currentPlayer, screenWidth, screenHeight, font);
     int playerCount = world->playerCount;
-    Player * newPlayers = malloc(sizeof(Player)); 
+    //Player * newPlayers = malloc(sizeof(Player)); 
 
     switch(currentPlayer->turnPhase){            
         case recruitment:
@@ -155,8 +158,10 @@ 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");
-                                Player_attack_Node(currentPlayer, &(players[nodePlayerID]), originNode, currentNode);
-                                diceRolling();
+                                int nbOfAttackers = Graphic_ChooseNumberOfAttackers(currentPlayer, &(players[nodePlayerID]), originNode, currentNode, font);
+                                Player_attack_Node(currentPlayer, &(players[nodePlayerID]), originNode, currentNode, nbOfAttackers);
+                                //diceRolling(currentPlayer, &(players[nodePlayerID]), originNode, currentNode, nbOfAttackers ,font);
+                                
                             }else{
                                 printf("Failed to attack target : Origin has already attacked, nodes aren't connected or origin node has too few soldiers\n");
                             }

src/player.c

@@ -155,8 +155,8 @@ void Player_confirm_recrutement(Player * self){
 };
 
 
-void Player_attack_Node(Player * self, Player * defender, Node * originNode, Node * targetNode){
-    int attackersCount = fmin(3, (originNode->soldiers-1));
+void Player_attack_Node(Player * self, Player * defender, Node * originNode, Node * targetNode, int numberOfAttackers){
+    int attackersCount = numberOfAttackers;
     int defendersCount = targetNode->soldiers >= 3? 2:1;
     int attDiceRolls[attackersCount];
     int defDiceRolls[defendersCount];

src/player.h

@@ -87,7 +87,7 @@ void Player_select_Node(Player * self, Vector2 mousePos);
 
 void Player_unselect_Node(Player * self, Vector2 mousePos);
 
-void Player_attack_Node(Player * self, Player * defender, Node * originNode, Node * targetNode);
+void Player_attack_Node(Player * self, Player * defender, Node * originNode, Node * targetNode, int numberOfAttackers);
 
 void Player_confirm_recrutement(Player * self);