Bientot fini manque seulement les images

src/game_logic.c

@@ -1,38 +1,31 @@
-/* src/game_logic.c */
-
 #include "game_logic.h"
 #include "utils.h" 
 #include <stdlib.h>
 #include <stdio.h> 
 
-/* --- Utilitaires de positionnement --- */
 
-/* Convertit un index 1D en coordonnées 2D */
 static void index_to_coords(int index, int cols, int *r, int *c)
 {
     *r = index / cols;
     *c = index % cols;
 }
 
-/* Trouve les indices des tuiles adjacentes à la case vide */
 static int find_adjacent_indices(int idx, int rows, int cols, int *out_indices)
 {
     int r = idx / cols;
     int c = idx % cols;
     int n = 0;
 
-    if (r > 0) out_indices[n++] = (r - 1) * cols + c;    /* Haut */
-    if (r < rows - 1) out_indices[n++] = (r + 1) * cols + c;  /* Bas */
-    if (c > 0) out_indices[n++] = r * cols + (c - 1);    /* Gauche */
-    if (c < cols - 1) out_indices[n++] = r * cols + (c + 1);  /* Droite */
+    if (r > 0) out_indices[n++] = (r - 1) * cols + c;    
+    if (r < rows - 1) out_indices[n++] = (r + 1) * cols + c;  
+    if (c > 0) out_indices[n++] = r * cols + (c - 1);   
+    if (c < cols - 1) out_indices[n++] = r * cols + (c + 1);  
 
     return n;
 }
 
 
-/* --- Fonctions publiques --- */
 
-/* Initialise le jeu à l'état résolu et alloue la mémoire */
 void game_init(game_state_t *state, int rows, int cols, tile_t **tiles)
 {
     int num_tiles = rows * cols;
@@ -44,7 +37,6 @@ void game_init(game_state_t *state, int rows, int cols, tile_t **tiles)
     state->is_solved = 1;
     state->all_tiles = tiles;
 
-    /* Allocation dynamique de la permutation (malloc) */
     state->permutation = (int *)malloc(num_tiles * sizeof(int));
     
     if (state->permutation == NULL) {
@@ -52,27 +44,22 @@ void game_init(game_state_t *state, int rows, int cols, tile_t **tiles)
         return; 
     }
     
-    /* Remplissage à l'état résolu : IDs 0, 1, 2, ... N-2 */
     for (i = 0; i < num_tiles - 1; i++) {
         state->permutation[i] = i; 
     }
     
-    /* La dernière case est la case vide (-1) */
     state->permutation[num_tiles - 1] = -1;
     state->empty_index = num_tiles - 1; 
 }
 
-/* Libère la mémoire allouée par game_init */
 void game_free(game_state_t *state)
 {
     if (state->permutation != NULL) {
         free(state->permutation);
         state->permutation = NULL;
     }
-    /* Note: tiles sont libérés par images_free_tiles dans main.c */
 }
 
-/* Vérifie si la tuile peut bouger (adjacence) */
 int game_can_move(const game_state_t *state, int index_to_move)
 {
     int r_tile, c_tile;
@@ -84,14 +71,12 @@ int game_can_move(const game_state_t *state, int index_to_move)
     index_to_coords(index_to_move, state->cols, &r_tile, &c_tile);
     index_to_coords(state->empty_index, state->cols, &r_empty, &c_empty);
     
-    /* Test d'adjacence géographique (manhattan distance = 1) */
     if (abs_val(r_tile - r_empty) + abs_val(c_tile - c_empty) == 1) {
         return 1;
     }
     return 0;
 }
 
-/* Déplace la tuile vers la case vide si possible */
 int game_move_tile(game_state_t *state, int index_to_move)
 {
     int temp_tile_id;
@@ -100,33 +85,27 @@ int game_move_tile(game_state_t *state, int index_to_move)
         return 0;
     }
 
-    /* Échange des valeurs (swap) */
     temp_tile_id = state->permutation[index_to_move];
     state->permutation[index_to_move] = state->permutation[state->empty_index]; 
     state->permutation[state->empty_index] = temp_tile_id; 
 
-    /* Mise à jour de la nouvelle position de la case vide */
     state->empty_index = index_to_move;
 
-    /* Mise à jour des compteurs */
     state->moves++;
     state->is_solved = game_is_solved(state);
 
     return 1; 
 }
 
-/* Vérifie si le plateau est dans l'état résolu */
 int game_is_solved(const game_state_t *state)
 {
     int num_tiles = state->rows * state->cols;
     int i;
     
-    /* La case vide doit être en dernière position (-1) */
     if (state->permutation[num_tiles - 1] != -1) {
         return 0;
     }
     
-    /* Toutes les autres tuiles doivent être dans l'ordre (ID = Position) */
     for (i = 0; i < num_tiles - 1; i++) {
         if (state->permutation[i] != i) {
             return 0;
@@ -136,7 +115,6 @@ int game_is_solved(const game_state_t *state)
     return 1; 
 }
 
-/* Mélange garanti solvable par N mouvements aléatoires */
 void game_shuffle_safe(game_state_t *state, int steps)
 {
     int prev_move = -1; 
@@ -148,15 +126,14 @@ void game_shuffle_safe(game_state_t *state, int steps)
     for (i = 0; i < steps; i++) {
         n_choices = find_adjacent_indices(state->empty_index, state->rows, state->cols, choices);
 
-        /* Choisir une tuile adjacente au hasard, sans revenir en arrière immédiatement */
+        
         do {
             pick_index = choices[random_int(n_choices)];
         } while (n_choices > 1 && pick_index == prev_move);
 
-        /* Déplacer la tuile (utilise la logique de déplacement) */
         game_move_tile(state, pick_index); 
         
-        /* L'ancienne position vide est la tuile qui vient d'être déplacée (pour la prochaine itération) */
+       
         prev_move = pick_index; 
     }