ein5-proj1-27151

Files changed (9) hide show

color_mode.c +33 -0
color_mode.h +13 -0
main.c +5 -1
src/action.c +77 -1
src/action.h +4 -0
src/game_loop.c +207 -1
src/game_loop.h +1 -0
src/tile.c +18 -6
src/tile.h +1 -0

color_mode.c ADDED Viewed

	@@ -0,0 +1,33 @@

+#include<stlib.h>
+#include<stdio.h>
+#include"stlib.h"
+void aff_tab(char * T1, int indx, char *T2){
+    T1[0]=T1[indx-1];
+    T1[0]=T1[indx];
+}
+int test(char * T1, char * T2){
+    for (int i = 0; i<15 ; ++i){
+        if !strcmp(T1, T2[i])
+            T2[i]="00";
+            return 1;
+    }
+    return 0;
+}
+int count(char * T_final)
+{
+    int c = 0;
+    int i = 1;
+    char * T_prov = "aa";
+    char * T_verif[]={"BG","BO","BV","GB","GO","GV","GG","OB","OO","OV","VB","VG","VO","VV"};
+    while (T_final[i]!=0) {
+        aff_tab(T_prov, i, T_final);
+        if test(T_prov, T_verif)
+            ++c;
+    ++i;
+    }
+}

color_mode.h ADDED Viewed

	@@ -0,0 +1,13 @@

+#ifndef __DEDALE_DIR_H__
+#define __DEDALE_DIR_H__
+int count(char * T_final);
+void aff_tab(char * T1, int indx, char * T2);
+int test(char * T1, char * T2);
+#endif //__DEDALE_DIR_H__

main.c CHANGED Viewed

@@ -10,6 +10,7 @@
 void print_usage(const char *program_name) {
     printf("Usage: %s [options]\n", program_name);
     printf("Options:\n");
     printf("  -g           Mode graphique \n");
     printf("  -T           Mode texte simplifié \n");
     printf("  -s SEED      Initialiser la graine aléatoire\n");
@@ -29,8 +30,11 @@ void parse_arguments(int argc, char *argv[], struct game_options_t *options){
     // Réinitialiser optind au cas où getopt a déjà été utilisé
     optind = 0;
-    while((opt= getopt(argc, argv, "gTs:t:n:h"))!= -1){
         switch(opt){
             case 'g':  // AJOUTÉ: mode graphique
                 options->use_got = 1;
                 break;

 void print_usage(const char *program_name) {
     printf("Usage: %s [options]\n", program_name);
     printf("Options:\n");
+    printf("  -c           color mode");
     printf("  -g           Mode graphique \n");
     printf("  -T           Mode texte simplifié \n");
     printf("  -s SEED      Initialiser la graine aléatoire\n");
     // Réinitialiser optind au cas où getopt a déjà été utilisé
     optind = 0;
+    while((opt= getopt(argc, argv, "gTcs:t:n:h"))!= -1){
         switch(opt){
+            case 'c':
+                options->color_mode=1;
+                break;
             case 'g':  // AJOUTÉ: mode graphique
                 options->use_got = 1;
                 break;

src/action.c CHANGED Viewed

@@ -182,7 +182,44 @@ int perform_player_movement(struct game_t* game,struct location_t new_loc){
     printf("to (%d,%d) ", new_loc.x, new_loc.y);
     printf("via %s ", dir_to_string(dir));
     if(dest_tile && !tile_is_empty(dest_tile)){
-        printf("(%s)",tile_name(dest_tile));
     }
     printf("\n");
@@ -233,6 +270,45 @@ int choose_and_perform_action(struct game_t* game){
     }
 }
 //Displays the victory message when player reaches the exit.

     printf("to (%d,%d) ", new_loc.x, new_loc.y);
     printf("via %s ", dir_to_string(dir));
     if(dest_tile && !tile_is_empty(dest_tile)){
+        printf("(%s)\n",tile_name(dest_tile));
+    }
+    printf("\n");
+    // execute
+    if(game_move_player(game, new_loc)){
+        printf(GREEN"  Success\n"RESET);
+        return 1;
+    }
+    check_movement_failure(game, new_loc);
+    return 0;
+}
+int perform_player_movement_c(struct game_t* game,struct location_t new_loc, char* buffer){
+    if(!game) return 0;
+    enum dir_t dir;
+    if(new_loc.y > game->p_location.y) dir=NORTH;
+    else if(new_loc.y < game->p_location.y) dir=SOUTH;
+    else if(new_loc.x > game->p_location.x) dir=EAST;
+    else dir=WEST;
+    struct tile_t* dest_tile=manor_get_tile(&game->p_manor,new_loc);
+    //display action
+    // Display action
+    printf(BLUE "▶" RESET " ");
+    printf(CYAN "Move" RESET " ");
+    printf("to (%d,%d) ", new_loc.x, new_loc.y);
+    printf("via %s ", dir_to_string(dir));
+    if(dest_tile && !tile_is_empty(dest_tile)){
+        printf("(%s)\n",tile_name(dest_tile));
+        printf("COLOR -%s\n", tile_color(dest_tile));
+        buffer = tile_color(dest_tile);
+        //printf("%s", buffer);
     }
     printf("\n");
     }
+}
+int choose_and_perform_action_colors(struct game_t* game, char* path){
+    if(!game) return 0;
+    // get empty adjacent locations
+    struct location_t empty_locs[4];
+    int empty_count=game_empty_adjacent_locations(game, empty_locs);
+    // get open adjacent locations
+    struct location_t open_locs[4];
+    int open_count=game_get_open_adjacent_locations(game, open_locs);
+    // calculate total available action
+    unsigned int total_actions= empty_count + open_count;
+    if(total_actions==0){
+        printf(RED"  No possible actions\n"RESET);
+        return 0;
+    }
+    char* buffer;
+    // get player random choice
+    int choice=get_random_choice(total_actions);
+    if (choice<=empty_count){
+        // tile placement action
+        struct location_t selected_loc=empty_locs[choice-1];
+        return perform_tile_placement(game, selected_loc);
+    }else{
+        //movement action
+        int move_index = choice - empty_count -1 ;
+        struct location_t selected_loc= open_locs[move_index];
+        return perform_player_movement_c(game, selected_loc, buffer);
+        path = buffer;
+    }
 }
 //Displays the victory message when player reaches the exit.

src/action.h CHANGED Viewed

@@ -12,6 +12,7 @@
 //Performs the action of placing a new tile at the specified location.
 //Handles tile drafting, selection, placement, and cost payment.
 int perform_tile_placement(struct game_t* game,struct location_t loc);
@@ -20,10 +21,13 @@ int perform_tile_placement(struct game_t* game,struct location_t loc);
 //Handles direction calculation, cost payment, and position update.
 int perform_player_movement(struct game_t* game,struct location_t new_loc);
 // Allows the player to choose and perform an action.
 //Displays available actions, gets player choice, and executes it.
 int choose_and_perform_action(struct game_t* game);
 //Displays the victory message when player reaches the exit.
 void show_victory_message();

 //Performs the action of placing a new tile at the specified location.
 //Handles tile drafting, selection, placement, and cost payment.
 int perform_tile_placement(struct game_t* game,struct location_t loc);
 //Handles direction calculation, cost payment, and position update.
 int perform_player_movement(struct game_t* game,struct location_t new_loc);
+int perform_player_movement_c(struct game_t* game,struct location_t new_loc,char* buffer);
 // Allows the player to choose and perform an action.
 //Displays available actions, gets player choice, and executes it.
 int choose_and_perform_action(struct game_t* game);
+int choose_and_perform_action_colors(struct game_t* game, char* path);
 //Displays the victory message when player reaches the exit.
 void show_victory_message();

src/game_loop.c CHANGED Viewed

@@ -77,7 +77,7 @@ void game_loop_text(struct game_t *game,unsigned int max_turns){
     printf("=== DÉBUT DE LA PARTIE ===\n");
     printf("Manoir: %dx%d, \n", BOARD_WIDTH, BOARD_HEIGHT);
     printf("Position départ: (%d,%d)\n", manor_get_startloc().x, manor_get_startloc().y);
-    printf("Position sortie: (%d,%d)\n\n", manor_get_exitloc().x, manor_get_exitloc().y);
     while (1) {
         printf("=== TOUR %d/%d ===\n", game->current_turn + 1, max_turns);
@@ -100,6 +100,7 @@ void game_loop_text(struct game_t *game,unsigned int max_turns){
         if (exit_reached(game)) {
             printf("\n=== VICTOIRE ===\n");
             printf("Le joueur a atteint la sortie en %d tours!\n", game->current_turn);
             break;
         }
@@ -260,6 +261,208 @@ void game_loop_text(struct game_t *game,unsigned int max_turns){
     // Légende
     printf("\nLégende P=YOU S=START E=EXIT C=CLOISTER T=TERRACE NS=CORRIDOR_NS WE=CORRIDOR_WE .=EMPTY\n");
 }
 void game_loop(struct game_options_t options){
     // initialiser le générateur aléatoire
@@ -274,6 +477,9 @@ void game_loop(struct game_options_t options){
     if (options.use_got){
         game_loop_g(&game, options.max_turns);
     }else{
         game_loop_text(&game, options.max_turns);
     }

     printf("=== DÉBUT DE LA PARTIE ===\n");
     printf("Manoir: %dx%d, \n", BOARD_WIDTH, BOARD_HEIGHT);
     printf("Position départ: (%d,%d)\n", manor_get_startloc().x, manor_get_startloc().y);
+    printf("Position sortie: (%d,%d)\n", manor_get_exitloc().x, manor_get_exitloc().y);
     while (1) {
         printf("=== TOUR %d/%d ===\n", game->current_turn + 1, max_turns);
         if (exit_reached(game)) {
             printf("\n=== VICTOIRE ===\n");
             printf("Le joueur a atteint la sortie en %d tours!\n", game->current_turn);
             break;
         }
     // Légende
     printf("\nLégende P=YOU S=START E=EXIT C=CLOISTER T=TERRACE NS=CORRIDOR_NS WE=CORRIDOR_WE .=EMPTY\n");
 }
+// version avec couleurs
+void game_loop_text_colors(struct game_t *game,unsigned int max_turns){
+    /*char buffer[max_turns];
+    buffer[0]='B';
+    int i=1;*/
+    printf("=== DÉBUT DE LA PARTIE ===\n");
+    printf("Manoir: %dx%d, \n", BOARD_WIDTH, BOARD_HEIGHT);
+    printf("Position départ: (%d,%d)\n", manor_get_startloc().x, manor_get_startloc().y);
+    printf("Position sortie: (%d,%d)\n", manor_get_exitloc().x, manor_get_exitloc().y);
+    printf("COLOR -B\n");
+    while (1) {
+        printf("=== TOUR %d/%d ===\n", game->current_turn + 1, max_turns);
+        printf("Position joueur: (%d,%d)\n", game->p_location.x, game->p_location.y);
+        // Afficher les ressources
+        printf("Ressources: ");
+        int first = 1;
+        for (int i = STEP; i <= NUM_RESOURCES; i++) {
+            if (game->p_stash.r[i] > 0 && game->p_stash.r[i] != UINT_MAX) {
+                if (!first) printf(", ");
+                printf("%s:%u", resource_to_string(i), game->p_stash.r[i]);
+                first = 0;
+            }
+        }
+        if (first) printf("aucune");
+        printf("\n");
+        // Vérifier la victoire
+        if (exit_reached(game)) {
+            printf("\n=== VICTOIRE ===\n");
+            printf("Le joueur a atteint la sortie en %d tours!\n", game->current_turn);
+            printf("COLOR -B\n\n");
+            break;
+        }
+        // Vérifier la défaite
+        if (game->current_turn >= max_turns) {
+            printf("\n=== DÉFAITE ===\n");
+            printf("Limite de tours atteinte (%d)\n", max_turns);
+            break;
+        }
+        // Vérifier les ressources
+        int has_resources = 0;
+        for (int i = STEP; i <= NUM_RESOURCES; i++) {
+            if (game->p_stash.r[i] > 0) {
+                has_resources = 1;
+                break;
+            }
+        }
+        if (!has_resources) {
+            printf("\n=== DÉFAITE ===\n");
+            printf("Plus de ressources disponibles\n");
+            break;
+        }
+        char* path;
+        // Effectuer une action
+        printf("\nAction: ");
+        if (!choose_and_perform_action_colors(game, path)){
+            printf("\n=== DÉFAITE ===\n");
+            printf("Aucune action possible\n");
+            break;
+        }
+        /*buffer[i] = *path;
+        printf("%s", buffer[i]);
+        i++;*/
+        game->current_turn++;
+        printf("\n");
+    }
+    // Afficher le manoir final (identique à la version graphique)
+    printf("\n=== ÉTAT FINAL DU MANOIR ===\n");
+    // coordonnées x
+    printf("     ");
+    for(int x=0; x<BOARD_WIDTH; x++){
+        printf("  %d   ", x);
+    }
+    printf("\n");
+    // bordure supérieure
+    printf("    ┌");
+    for (int x = 0; x < BOARD_WIDTH; x++) {
+        printf("─────");
+        if (x < BOARD_WIDTH - 1) printf("┬");
+    }
+    printf("┐\n");
+    //Grille
+    for (int y=BOARD_HEIGHT-1; y>=0; y-- ){
+        printf("%2d  │", y);  // Row number with left border
+        for(int x=0;x<BOARD_WIDTH;x++){
+            struct location_t loc={x, y};
+            struct tile_t* tile=manor_get_tile(&game->p_manor, loc);
+            // POUR LES SYMBOLES DE 3 CARATÈRES (N_S ET W_E)
+            char symbol[4];
+            symbol[0] = ' ';
+            symbol[1] = ' ';
+            symbol[2] = ' ';
+            symbol[3] = '\0';  // Default empty symbol
+            if(location_equal(loc,game->p_location)){
+                symbol[0] = ' ';
+                symbol[1]= 'P';
+                symbol[2] = ' ';
+                symbol[3] = '\0';
+            } else if (location_equal(loc, manor_get_startloc())) {
+                symbol[0] = ' ';
+                symbol[1]= 'S';
+                symbol[2] = ' ';
+                symbol[3] = '\0';
+            } else if (location_equal(loc, manor_get_exitloc())) {
+                symbol[0] = ' ';
+                symbol[1]= 'E';
+                symbol[2] = ' ';
+                symbol[3] = '\0';
+            } else if (tile && !tile_is_empty(tile)) {
+                const char* name = tile_name(tile);
+                if (name){
+                    if(strcmp(name,"Cloister")==0){
+                        symbol[0] = ' ';
+                        symbol[1]= 'C';
+                        symbol[2] = ' ';
+                        symbol[3] = '\0';
+                    }else if (strcmp(name,"Terrace")==0){
+                        symbol[0] = ' ';
+                        symbol[1]= 'T';
+                        symbol[2] = ' ';
+                        symbol[3] = '\0';
+                    }else if (strcmp(name,"Corridor_NS")==0){
+                        symbol[0]= 'N';
+                        symbol[1]= 'S';
+                        symbol[2]= ' ';
+                        symbol[3] = '\0';
+                    }else if (strcmp(name,"Corridor_WE")==0){
+                        symbol[0]= 'W';
+                        symbol[1]= 'E';
+                        symbol[2]= ' ';
+                        symbol[3] = '\0';
+                    }else if (strcmp(name,"start")==0){
+                        symbol[0] = ' ';
+                        symbol[1]= 'S';
+                        symbol[2] = ' ';
+                        symbol[3] = '\0';
+                    }else if (strcmp(name,"exit")==0){
+                        symbol[0] = ' ';
+                        symbol[1]= 'E';
+                        symbol[2] = ' ';
+                        symbol[3] = '\0';
+                    }else{
+                        symbol[0] = ' ';
+                        symbol[1] = name[0];
+                        symbol[2] = ' ';
+                        symbol[3] = '\0';
+                    }
+                }
+            } else {
+                symbol[0] = ' ';
+                symbol[1] = '.';
+                symbol[2] = ' ';
+                symbol[3] = '\0';
+            }
+            // Print the cell without colors
+            printf("%s", symbol);
+            if (x < BOARD_WIDTH - 1) printf("  │");  // Column separator
+        }
+        printf("  │\n");  // Right border
+        // Draw horizontal separators between rows (except after last row)
+        if (y > 0) {
+        printf("    ├");
+        for (int x = 0; x < BOARD_WIDTH; x++) {
+            printf("─────");
+            if (x < BOARD_WIDTH - 1) printf("┼");
+            }
+        printf("┤\n");
+        }
+    }
+    // Draw bottom border of the grid
+    printf("    └");
+    for (int x = 0; x < BOARD_WIDTH; x++) {
+        printf("─────");
+        if (x < BOARD_WIDTH - 1) printf("┴");
+    }
+    printf("┘\n");
+    printf("COLOR : score=");
+    // Légende
+    printf("\nLégende P=YOU S=START E=EXIT C=CLOISTER T=TERRACE NS=CORRIDOR_NS WE=CORRIDOR_WE .=EMPTY\n");
+}
 void game_loop(struct game_options_t options){
     // initialiser le générateur aléatoire
     if (options.use_got){
         game_loop_g(&game, options.max_turns);
     }else{
+        if(options.color_mode){
+            game_loop_text_colors(&game,options.max_turns);
+        }
         game_loop_text(&game, options.max_turns);
     }

src/game_loop.h CHANGED Viewed

@@ -10,6 +10,7 @@ struct game_options_t{
     unsigned int seed; // graine aléatoire
     unsigned int tile_seed; // grine pour init_tiles
     unsigned int max_turns; // nombre maximum de turns
 };
 void game_loop(struct game_options_t);

     unsigned int seed; // graine aléatoire
     unsigned int tile_seed; // grine pour init_tiles
     unsigned int max_turns; // nombre maximum de turns
+    int color_mode;
 };
 void game_loop(struct game_options_t);

src/tile.c CHANGED Viewed

@@ -14,6 +14,7 @@ struct tile_t {
     struct stash_t cost_thrgh;
     struct stash_t cost_op[4];
     int weight;
 };
 static struct tile_t empty_tile ={
@@ -27,14 +28,16 @@ static struct tile_t start_tile ={
     .name = "start",
     .cost_thrgh= ONE_STEP_STASH ,
     .cost_op = {[NORTH]=ONE_STEP_STASH , [EAST]=ONE_STEP_STASH ,[SOUTH]=ONE_STEP_STASH , [WEST]=ONE_STEP_STASH },
-    .weight=0
 };
 static struct tile_t exit_tile ={
     .name = "exit",
     .cost_thrgh= ONE_STEP_STASH ,
     .cost_op = {[NORTH]=ONE_STEP_STASH , [EAST]=ONE_STEP_STASH ,[SOUTH]=ONE_STEP_STASH , [WEST]=ONE_STEP_STASH },
-    .weight=0
 };
@@ -42,28 +45,32 @@ static struct tile_t Corridor_NS={
     .name = "Corridor_NS",
     .cost_thrgh = ONE_STEP_STASH,
     .cost_op = {[NORTH]=ONE_STEP_STASH , [EAST]=INFINITE_STEP_STASH, [SOUTH]=ONE_STEP_STASH , [WEST]=INFINITE_STEP_STASH },
-    .weight=1
 };
 static struct tile_t Corridor_WE={
     .name = "Corridor_WE",
     .cost_thrgh = ONE_STEP_STASH,
     .cost_op = {[NORTH]=INFINITE_STEP_STASH, [EAST]=ONE_STEP_STASH ,[SOUTH]=INFINITE_STEP_STASH , [WEST]=ONE_STEP_STASH },
-    .weight=1
 };
 static struct tile_t Terrace={
     .name = "Terrace",
     .cost_thrgh = ONE_STEP_STASH,
     .cost_op = {[NORTH]=ONE_STEP_STASH , [EAST]=INFINITE_STEP_STASH ,[SOUTH]=INFINITE_STEP_STASH , [WEST]=INFINITE_STEP_STASH },
-    .weight=1
 };
 static struct tile_t Cloister={
     .name = "Cloister",
     .cost_thrgh = ONE_STEP_STASH,
     .cost_op = {[NORTH]=ONE_STEP_STASH , [EAST]=ONE_STEP_STASH ,[SOUTH]=ONE_STEP_STASH , [WEST]=ONE_STEP_STASH },
-    .weight=2
 };
 static struct tile_t  * available_tiles[]={
@@ -243,3 +250,8 @@ int tile_can_open(const struct tile_t* tile, enum dir_t d){
     struct stash_t empty = EMPTY_STASH;
     return !stash_contains(&empty,&cost);
 }

     struct stash_t cost_thrgh;
     struct stash_t cost_op[4];
     int weight;
+    char color[4];
 };
 static struct tile_t empty_tile ={
     .name = "start",
     .cost_thrgh= ONE_STEP_STASH ,
     .cost_op = {[NORTH]=ONE_STEP_STASH , [EAST]=ONE_STEP_STASH ,[SOUTH]=ONE_STEP_STASH , [WEST]=ONE_STEP_STASH },
+    .weight=0,
+    .color="B"
 };
 static struct tile_t exit_tile ={
     .name = "exit",
     .cost_thrgh= ONE_STEP_STASH ,
     .cost_op = {[NORTH]=ONE_STEP_STASH , [EAST]=ONE_STEP_STASH ,[SOUTH]=ONE_STEP_STASH , [WEST]=ONE_STEP_STASH },
+    .weight=0,
+    .color="B"
 };
     .name = "Corridor_NS",
     .cost_thrgh = ONE_STEP_STASH,
     .cost_op = {[NORTH]=ONE_STEP_STASH , [EAST]=INFINITE_STEP_STASH, [SOUTH]=ONE_STEP_STASH , [WEST]=INFINITE_STEP_STASH },
+    .weight=1,
+    .color="V"
 };
 static struct tile_t Corridor_WE={
     .name = "Corridor_WE",
     .cost_thrgh = ONE_STEP_STASH,
     .cost_op = {[NORTH]=INFINITE_STEP_STASH, [EAST]=ONE_STEP_STASH ,[SOUTH]=INFINITE_STEP_STASH , [WEST]=ONE_STEP_STASH },
+    .weight=1,
+    .color="V"
 };
 static struct tile_t Terrace={
     .name = "Terrace",
     .cost_thrgh = ONE_STEP_STASH,
     .cost_op = {[NORTH]=ONE_STEP_STASH , [EAST]=INFINITE_STEP_STASH ,[SOUTH]=INFINITE_STEP_STASH , [WEST]=INFINITE_STEP_STASH },
+    .weight=1,
+    .color="G"
 };
 static struct tile_t Cloister={
     .name = "Cloister",
     .cost_thrgh = ONE_STEP_STASH,
     .cost_op = {[NORTH]=ONE_STEP_STASH , [EAST]=ONE_STEP_STASH ,[SOUTH]=ONE_STEP_STASH , [WEST]=ONE_STEP_STASH },
+    .weight=2,
+    .color="O"
 };
 static struct tile_t  * available_tiles[]={
     struct stash_t empty = EMPTY_STASH;
     return !stash_contains(&empty,&cost);
 }
+char* tile_color(struct tile_t *tile){
+    if (tile==NULL) return "NULL";
+    return tile->color;
+}

src/tile.h CHANGED Viewed

@@ -69,4 +69,5 @@ int tile_is_empty(const struct tile_t* tile);
  * opening cost in the direction `d`. */
 int tile_can_open(const struct tile_t* tile, enum dir_t d);
 #endif  // __DEDALE_TILE_H__

  * opening cost in the direction `d`. */
 int tile_can_open(const struct tile_t* tile, enum dir_t d);
+char* tile_color(struct tile_t *tile);
 #endif  // __DEDALE_TILE_H__