Menu v3

2025-11-30 15:56:48 +01:00
parent 0939e7369d
commit 99cb83582a
16 changed files with 433 additions and 37 deletions
@@ -0,0 +1,165 @@
+/* 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 */
+
+    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;
+    int i;
+    
+    state->rows = rows;
+    state->cols = cols;
+    state->moves = 0UL;
+    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) {
+        fprintf(stderr, "Erreur: Allocation permutation echouee.\n");
+        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;
+    int r_empty, c_empty;
+    
+    if (index_to_move == state->empty_index) return 0;
+    if (index_to_move < 0 || index_to_move >= state->rows * state->cols) return 0;
+
+    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;
+
+    if (!game_can_move(state, 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;
+        }
+    }
+    
+    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; 
+    int choices[4];
+    int n_choices;
+    int pick_index;
+    int i;
+    
+    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; 
+    }
+
+    state->moves = 0UL;
+    state->is_solved = 0;
+}