Implémentation de la structure de base du jeu.

jeu.c

@@ -0,0 +1,166 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <graph.h>
+#include "jeu.h"
+
+#define TAILLE_FENETRE 800
+#define MARGE 100
+#define TAILLE_MAX_GRILLE 400
+
+struct EtatJeu initialiserJeu(int tailleGrille, int mode) {
+    struct EtatJeu etatJeu;
+    int i, j;
+
+    etatJeu.tailleGrille = tailleGrille;
+    etatJeu.mode = mode;
+    etatJeu.tourJoueur = 1;
+    etatJeu.phase = 0;
+    etatJeu.positionSourisJoueur1x = -1;
+    etatJeu.positionSourisJoueur1y = -1;
+    etatJeu.positionSourisJoueur2x = -1;
+    etatJeu.positionSourisJoueur2y = -1;
+
+    etatJeu.grille = (int**)malloc(tailleGrille * sizeof(int*));
+    if (etatJeu.grille == NULL) {
+        fprintf(stderr, "Erreur d'allocation mémoire\n");
+        exit(1);
+    }
+
+    for (i = 0; i < tailleGrille; i++) {
+        etatJeu.grille[i] = (int*)malloc(tailleGrille * sizeof(int));
+        if (etatJeu.grille[i] == NULL) {
+            for (j = 0; j < i; j++) {
+                free(etatJeu.grille[j]);
+            }
+            free(etatJeu.grille);
+            fprintf(stderr, "Erreur d'allocation mémoire\n");
+            exit(1);
+        }
+        for (j = 0; j < tailleGrille; j++) {
+            etatJeu.grille[i][j] = 0;  
+        }
+    }
+
+    return etatJeu;
+}
+
+int obtenirCaseGrille(int pos, int taille_case, int offset) {
+    int caseGrille = (pos - offset) / taille_case;
+    if (caseGrille >= 0 && caseGrille < taille_case) {
+        return caseGrille;
+    }
+    return -1;
+}
+
+void dessinerGrille(struct EtatJeu etatJeu) {
+    int taille_case = TAILLE_MAX_GRILLE / etatJeu.tailleGrille;
+    int offset_x = (TAILLE_FENETRE - TAILLE_MAX_GRILLE) / 2;
+    int offset_y = MARGE;
+    int i, j, x, y;
+    int marge = 5;
+    char message[50];
+
+    ChoisirCouleurDessin(CouleurParNom("white"));
+    RemplirRectangle(offset_x, offset_y, TAILLE_MAX_GRILLE, TAILLE_MAX_GRILLE);
+
+    ChoisirCouleurDessin(CouleurParNom("black"));
+    for (i = 0; i <= etatJeu.tailleGrille; i++) {
+        DessinerSegment(offset_x, offset_y + i*taille_case,
+                        offset_x + TAILLE_MAX_GRILLE, offset_y + i*taille_case);
+        DessinerSegment(offset_x + i*taille_case, offset_y,
+                        offset_x + i*taille_case, offset_y + TAILLE_MAX_GRILLE);
+    }
+
+    for (i = 0; i < etatJeu.tailleGrille; i++) {
+        for (j = 0; j < etatJeu.tailleGrille; j++) {
+            x = offset_x + j*taille_case;
+            y = offset_y + i*taille_case;
+
+            switch(etatJeu.grille[i][j]) {
+                case 1: /* Joueur 1 */
+                    ChoisirCouleurDessin(CouleurParNom("blue"));
+                    RemplirArc(x + marge, y + marge, taille_case - 2*marge, taille_case - 2*marge, 0, 360);
+                    break;
+                case 2: /* Joueur 2 */
+                    ChoisirCouleurDessin(CouleurParNom("red"));
+                    RemplirArc(x + marge, y + marge, taille_case - 2*marge, taille_case - 2*marge, 0, 360);
+                    break;
+                case -1: /* Case bloquée */
+                    ChoisirCouleurDessin(CouleurParNom("grey"));
+                    RemplirRectangle(x + marge, y + marge, taille_case - 2*marge, taille_case - 2*marge);
+                    break;
+            }
+        }
+    }
+
+    /* Afficher les informations du tour */
+    ChoisirCouleurDessin(CouleurParNom("black"));
+    if (etatJeu.phase == 0) {
+        sprintf(message, "Joueur %d : Placez votre pion", etatJeu.tourJoueur);
+    } else {
+        sprintf(message, "Tour du joueur %d", etatJeu.tourJoueur);
+    }   
+    EcrireTexte(MARGE, 50, message, 2);
+}
+
+int estDeplacementValide(struct EtatJeu etatJeu, int x, int y, int joueur) {
+    int posX = (joueur == 1) ? etatJeu.positionSourisJoueur1x : etatJeu.positionSourisJoueur2x;
+    int posY = (joueur == 1) ? etatJeu.positionSourisJoueur1y : etatJeu.positionSourisJoueur2y;
+
+    if (etatJeu.grille[y][x] != 0) {
+        return 0;
+    }
+    if (etatJeu.phase == 0) {
+        return 1;
+    }
+    int dx = abs(x - posX);
+    int dy = abs(y - posY);
+    return (dx <= 1 && dy <= 1 && !(dx == 0 && dy == 0));
+}
+
+void jouerPartie(int tailleGrille, int mode) {
+    struct EtatJeu etatJeu = initialiserJeu(tailleGrille, mode);
+    int continuer = 1;
+    int tailleCase = TAILLE_MAX_GRILLE / tailleGrille;
+    int offsetX = (TAILLE_FENETRE - TAILLE_MAX_GRILLE) / 2;
+    int offsetY = MARGE;
+    int x, y; 
+
+    while (continuer) {
+        dessinerGrille(etatJeu);
+
+        if (SourisCliquee()) {
+            x = obtenirCaseGrille(_X, tailleCase, offsetX);
+            y = obtenirCaseGrille(_Y, tailleCase, offsetY);
+            
+            if (x >= 0 && x < tailleGrille && y >= 0 && y < tailleGrille) {
+                if (estDeplacementValide(etatJeu, x, y, etatJeu.tourJoueur)) {
+                    if (etatJeu.phase == 0) {
+                        etatJeu.grille[y][x] = etatJeu.tourJoueur;
+                        if (etatJeu.tourJoueur == 1) {
+                            etatJeu.positionSourisJoueur1x = x;
+                            etatJeu.positionSourisJoueur1y = y;
+                        } else {
+                            etatJeu.positionSourisJoueur2x = x;
+                            etatJeu.positionSourisJoueur2y = y;
+                        }
+                        etatJeu.phase = 1;
+                        etatJeu.tourJoueur = (etatJeu.tourJoueur == 1) ? 2 : 1;
+                    } else {
+                        /*Logique pour le déplacement et le blocage des cases
+                     à plémenter*/
+                    }
+                }
+            }
+        }
+        
+        /*Ajouter une condition pour terminer la partie*/
+      
+    }
+
+    /*Libérer la mémoire allouée pour la grille*/
+    for (int i = 0; i < tailleGrille; i++) {
+        free(etatJeu.grille[i]);
+    }
+    free(etatJeu.grille);
+}