bakhouch/SAE11_2024
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Ajuster le positionnement et l'échelle de la grille pour respecter les limites de la fenêtre

Browse Source
This commit is contained in:
Haffa BAKHOUCHE
2024-11-16 11:24:19 +01:00
parent 514849a823
commit f23e6aa354
4 changed files with 201 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
blocus
View File

Binary file not shown.

185
jeu.c
View File

@@ -1,119 +1,162 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "jeu.h" #include "jeu.h"
#include <graph.h> /* Assurez-vous d'inclure la bibliothèque graphique */ #include <graph.h>
/* Fonction pour dessiner un cercle */
void DessinerCercle(int x, int y, int rayon) { void DessinerCercle(int x, int y, int rayon) {
DessinerArc(x - rayon, y - rayon, 2 * rayon, 2 * rayon, 0, 360); DessinerArc(x - rayon, y - rayon, 2 * rayon, 2 * rayon, 0, 360);
} }
/* Fonction pour dessiner la grille */
void dessinerGrille(struct EtatJeu etatJeu) { void dessinerGrille(struct EtatJeu etatJeu) {
int i, j; int i, j;
int largeurFenetre = 800; /* Largeur de la fenêtre */ int largeurFenetre = 800;
int hauteurFenetre = 600; /* Hauteur de la fenêtre */ int hauteurFenetre = 600;
int marge = 50; /* Marge pour éviter les bords */
/* Calculer la taille de chaque case pour remplir complètement la fenêtre */ /* Calculer la taille de case en prenant le minimum entre largeur et hauteur */
int tailleCase = (largeurFenetre < hauteurFenetre) ? (largeurFenetre / etatJeu.tailleGrille) : (hauteurFenetre / etatJeu.tailleGrille); int tailleCase = (largeurFenetre - 2 * marge) / etatJeu.tailleGrille;
if (tailleCase * etatJeu.tailleGrille > (hauteurFenetre - 2 * marge)) {
/* Ajuster la taille de la case pour qu'elle prenne tout l'espace */ tailleCase = (hauteurFenetre - 2 * marge) / etatJeu.tailleGrille;
if (tailleCase * etatJeu.tailleGrille > hauteurFenetre) {
tailleCase = hauteurFenetre / etatJeu.tailleGrille;
} }
/* Dessiner la grille */ /* Calculer les positions de départ pour centrer la grille */
int startX = (largeurFenetre - (tailleCase * etatJeu.tailleGrille)) / 2;
int startY = (hauteurFenetre - (tailleCase * etatJeu.tailleGrille)) / 2;
EffacerEcran(CouleurParNom("white"));
for (i = 0; i < etatJeu.tailleGrille; i++) { for (i = 0; i < etatJeu.tailleGrille; i++) {
for (j = 0; j < etatJeu.tailleGrille; j++) { for (j = 0; j < etatJeu.tailleGrille; j++) {
int x = j * tailleCase; /* Calculer la position x */ int x = startX + (j * tailleCase);
int y = i * tailleCase; /* Calculer la position y */ int y = startY + (i * tailleCase);
ChoisirCouleurDessin(CouleurParNom("black")); /* Couleur de la grille */
DessinerRectangle(x, y, tailleCase, tailleCase); /* Dessiner le rectangle pour la case */
/* Dessiner les pièces bloquées */ ChoisirCouleurDessin(CouleurParNom("black"));
if (etatJeu.grille[i][j] == 1) { /* 1 pour l'humain */ DessinerRectangle(x, y, tailleCase, tailleCase);
if (etatJeu.grille[i][j] == 1) {
ChoisirCouleurDessin(CouleurParNom("blue")); ChoisirCouleurDessin(CouleurParNom("blue"));
DessinerCercle(x + tailleCase / 2, y + tailleCase / 2, tailleCase / 4); /* Dessiner un cercle bleu */ RemplirRectangle(x + 5, y + 5, tailleCase - 10, tailleCase - 10);
} else if (etatJeu.grille[i][j] == 2) { /* 2 pour l'IA */ } else if (etatJeu.grille[i][j] == 2) {
ChoisirCouleurDessin(CouleurParNom("red")); ChoisirCouleurDessin(CouleurParNom("red"));
DessinerCercle(x + tailleCase / 2, y + tailleCase / 2, tailleCase / 4); /* Dessiner un cercle rouge */ RemplirRectangle(x + 5, y + 5, tailleCase - 10, tailleCase - 10);
} }
} }
} }
} }
void gererClicSouris(struct EtatJeu *etatJeu) { void gererClicSouris(struct EtatJeu *etatJeu) {
int x, y; int x = _X;
int tailleCase; int y = _Y;
int i, j; int largeurFenetre = 800;
int hauteurFenetre = 600;
if (SourisCliquee()) { int marge = 50;
x = _X; /* Position X du clic */
y = _Y; /* Position Y du clic */ int tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
if (tailleCase * etatJeu->tailleGrille > (hauteurFenetre - 2 * marge)) {
tailleCase = 800 / etatJeu->tailleGrille; /* Taille de chaque case */ tailleCase = (hauteurFenetre - 2 * marge) / etatJeu->tailleGrille;
i = y / tailleCase; /* Ligne cliquée */ }
j = x / tailleCase; /* Colonne cliquée */
int startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
/* Vérifier si la case est libre */ int startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
if (i < etatJeu->tailleGrille && j < etatJeu->tailleGrille && etatJeu->grille[i][j] == 0) {
etatJeu->grille[i][j] = 1; /* Marquer la case comme bloquée par l'humain */ /* Ajuster les coordonnées du clic en fonction du décalage de la grille */
dessinerGrille(*etatJeu); /* Redessiner la grille */ x -= startX;
jouerAvecIA(*etatJeu); /* Appeler la fonction de l'IA pour bloquer une case */ y -= startY;
}
/* Calculer les indices de la grille */
int i = y / tailleCase;
int j = x / tailleCase;
printf("Processing click at: (%d, %d) -> Grid position: (%d, %d)\n", x, y, i, j);
if (i >= 0 && i < etatJeu->tailleGrille &&
j >= 0 && j < etatJeu->tailleGrille &&
etatJeu->grille[i][j] == 0) {
etatJeu->grille[i][j] = etatJeu->tourJoueur;
printf("Placed mark for player %d at position (%d, %d)\n",
etatJeu->tourJoueur, i, j);
etatJeu->tourJoueur = (etatJeu->tourJoueur == 1) ? 2 : 1;
dessinerGrille(*etatJeu);
} }
} }
/* Fonction pour initialiser l'état du jeu */
struct EtatJeu initialiserJeu(int tailleGrille, int mode) { struct EtatJeu initialiserJeu(int tailleGrille, int mode) {
struct EtatJeu etatJeu; struct EtatJeu etatJeu;
int i, j; int i, j;
etatJeu.tailleGrille = tailleGrille; etatJeu.tailleGrille = tailleGrille;
etatJeu.mode = mode; etatJeu.mode = mode;
etatJeu.tourJoueur = 1; /* Initialiser le joueur courant */ etatJeu.tourJoueur = 1;
etatJeu.phase = 0; /* Initialiser la phase */ etatJeu.phase = 0;
etatJeu.positionSourisJoueur1x = -1; /* Initialiser les positions de la souris */
etatJeu.positionSourisJoueur1y = -1;
etatJeu.positionSourisJoueur2x = -1;
etatJeu.positionSourisJoueur2y = -1;
/* Allouer de la mémoire pour la grille */
etatJeu.grille = (int**)malloc(tailleGrille * sizeof(int*)); 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++) { for (i = 0; i < tailleGrille; i++) {
etatJeu.grille[i] = (int*)malloc(tailleGrille * sizeof(int)); 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++) { for (j = 0; j < tailleGrille; j++) {
etatJeu.grille[i][j] = 0; /* Initialiser les cellules de la grille à 0 */ etatJeu.grille[i][j] = 0;
} }
} }
return etatJeu; return etatJeu;
} }
/* Fonction pour jouer avec l'IA */ int verifierVictoire(struct EtatJeu etatJeu) {
void jouerAvecIA(struct EtatJeu etatJeu) {
int i, j; int i, j;
/* Logique simple pour que l'IA bloque une case */
for (i = 0; i < etatJeu.tailleGrille; i++) { for (i = 0; i < etatJeu.tailleGrille; i++) {
for (j = 0; j < etatJeu.tailleGrille; j++) { if (etatJeu.grille[i][0] != 0) {
if (etatJeu.grille[i][j] == 0) { /* Trouver une case libre */ int gagnant = etatJeu.grille[i][0];
etatJeu.grille[i][j] = 2; /* Marquer la case comme bloquée par l'IA */ int victoire = 1;
dessinerGrille(etatJeu); /* Redessiner la grille */ for (j = 1; j < etatJeu.tailleGrille; j++) {
return; /* Sortir après avoir bloqué une case */ if (etatJeu.grille[i][j] != gagnant) {
victoire = 0;
break;
}
} }
if (victoire) return gagnant;
} }
} }
for (j = 0; j < etatJeu.tailleGrille; j++) {
if (etatJeu.grille[0][j] != 0) {
int gagnant = etatJeu.grille[0][j];
int victoire = 1;
for (i = 1; i < etatJeu.tailleGrille; i++) {
if (etatJeu.grille[i][j] != gagnant) {
victoire = 0;
break;
}
}
if (victoire) return gagnant;
}
}
if (etatJeu.grille[0][0] != 0) {
int gagnant = etatJeu.grille[0][0];
int victoire = 1;
for (i = 1; i < etatJeu.tailleGrille; i++) {
if (etatJeu.grille[i][i] != gagnant) {
victoire = 0;
break;
}
}
if (victoire) return gagnant;
}
if (etatJeu.grille[0][etatJeu.tailleGrille - 1] != 0) {
int gagnant = etatJeu.grille[0][etatJeu.tailleGrille - 1];
int victoire = 1;
for (i = 1; i < etatJeu.tailleGrille; i++) {
if (etatJeu.grille[i][etatJeu.tailleGrille - 1 - i] != gagnant) {
victoire = 0;
break;
}
}
if (victoire) return gagnant;
}
return 0;
} }
/* Ajouter d'autres fonctions de logique de jeu si nécessaire */

16
jeu.h
View File

@@ -1,12 +1,9 @@
/* jeu.h */
#ifndef JEU_H #ifndef JEU_H
#define JEU_H #define JEU_H
/* Définir la structure pour l'état du jeu */
struct EtatJeu { struct EtatJeu {
int tailleGrille; /* Taille de la grille */ int tailleGrille;
int mode; /* Mode de jeu (1 joueur ou 2 joueurs) */ int mode;
int tourJoueur; int tourJoueur;
int phase; int phase;
int positionSourisJoueur1x; int positionSourisJoueur1x;
@@ -14,16 +11,13 @@ struct EtatJeu {
int positionSourisJoueur2x; int positionSourisJoueur2x;
int positionSourisJoueur2y; int positionSourisJoueur2y;
int** grille; int** grille;
/* Ajouter d'autres variables d'état du jeu si nécessaire */
}; };
/* Fonction pour initialiser l'état du jeu */
struct EtatJeu initialiserJeu(int tailleGrille, int mode); struct EtatJeu initialiserJeu(int tailleGrille, int mode);
/* Fonction pour jouer avec l'IA */
void jouerAvecIA(struct EtatJeu etatJeu); void jouerAvecIA(struct EtatJeu etatJeu);
/* Ajouter d'autres prototypes de fonction liés à la logique du jeu */
void gererClicSouris(struct EtatJeu *etatJeu); void gererClicSouris(struct EtatJeu *etatJeu);
void dessinerGrille(struct EtatJeu etatJeu);
void DessinerCercle(int x, int y, int rayon);
int verifierVictoire(struct EtatJeu etatJeu);
#endif /* JEU_H */ #endif /* JEU_H */

148
main.c
View File

@@ -2,88 +2,104 @@
#include <stdlib.h> #include <stdlib.h>
#include <graph.h> #include <graph.h>
#include <unistd.h> #include <unistd.h>
#include "jeu.h" /* Inclure l'en-tête pour la logique du jeu */ #include "jeu.h"
void menuPrincipale() { void menuPrincipale() {
int tailleGrille = 3; /* Taille de la grille */ int tailleGrille = 3;
int continuer = 1; /* Variable pour continuer le menu */ int continuer = 1;
int besoinRedessiner = 1; /* Drapeau pour indiquer si un redessin est nécessaire */ char tailleStr[4];
char tailleStr[4]; /* Augmenter la taille pour contenir des nombres plus grands */ InitialiserGraphique();
CreerFenetre(100, 100, 800, 600);
InitialiserGraphique(); /* Initialiser la graphique */ ChoisirTitreFenetre("Blocus");
CreerFenetre(100, 100, 800, 600); /* Créer la fenêtre */
ChoisirTitreFenetre("Blocus"); /* Choisir le titre de la fenêtre */
while (continuer) { /* Boucle principale du menu */ while (continuer) {
if (besoinRedessiner) { /* Redessiner uniquement si nécessaire */ EffacerEcran(CouleurParNom("white"));
EffacerEcran(CouleurParNom("white")); /* Effacer l'écran */ ChoisirCouleurDessin(CouleurParNom("black"));
EcrireTexte(300, 50, "BLOCUS", 2);
ChoisirCouleurDessin(CouleurParNom("black")); /* Choisir la couleur noire pour le dessin */ EcrireTexte(250, 120, "Taille de la grille:", 1);
EcrireTexte(300, 50, "BLOCUS", 2); /* Écrire le titre du jeu */ sprintf(tailleStr, "%d", tailleGrille);
EcrireTexte(450, 120, tailleStr, 1);
EcrireTexte(250, 120, "Taille de la grille:", 1); /* Écrire le texte pour la taille de la grille */ RemplirRectangle(500, 110, 30, 30);
sprintf(tailleStr, "%d", tailleGrille); /* Convertir la taille de la grille en chaîne */ RemplirRectangle(540, 110, 30, 30);
EcrireTexte(450, 120, tailleStr, 1); /* Afficher la taille de la grille */ ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(510, 120, "+", 1);
RemplirRectangle(500, 110, 30, 30); /* Dessiner le rectangle pour augmenter la taille */ EcrireTexte(550, 120, "-", 1);
RemplirRectangle(540, 110, 30, 30); /* Dessiner le rectangle pour diminuer la taille */ ChoisirCouleurDessin(CouleurParNom("black"));
ChoisirCouleurDessin(CouleurParNom("white")); /* Choisir la couleur blanche pour le texte */ RemplirRectangle(250, 180, 300, 50);
EcrireTexte(510, 120, "+", 1); /* Écrire le symbole pour augmenter */ RemplirRectangle(250, 250, 300, 50);
EcrireTexte(550, 120, "-", 1); /* Écrire le symbole pour diminuer */ ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(280, 195, "1 Joueur (contre IA)", 1);
ChoisirCouleurDessin(CouleurParNom("black")); /* Choisir la couleur noire pour le dessin */ EcrireTexte(280, 265, "2 Joueurs (Humain vs Humain)", 1);
RemplirRectangle(250, 180, 300, 50); /* Dessiner le rectangle pour le mode 1 joueur */ ChoisirCouleurDessin(CouleurParNom("black"));
RemplirRectangle(250, 250, 300, 50); /* Dessiner le rectangle pour le mode 2 joueurs */ RemplirRectangle(250, 320, 300, 50);
ChoisirCouleurDessin(CouleurParNom("white")); /* Choisir la couleur blanche pour le texte */ ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(280, 195, "1 Joueur (contre IA)", 1); /* Écrire le texte pour le mode 1 joueur */ EcrireTexte(320, 335, "Quitter", 1);
EcrireTexte(280, 265, "2 Joueurs (Humain vs Humain)", 1); /* Écrire le texte pour le mode 2 joueurs */
ChoisirCouleurDessin(CouleurParNom("black")); /* Choisir la couleur noire pour le dessin */
RemplirRectangle(250, 320, 300, 50); /* Dessiner le rectangle pour quitter */
ChoisirCouleurDessin(CouleurParNom("white")); /* Choisir la couleur blanche pour le texte */
EcrireTexte(320, 335, "Quitter", 1); /* Écrire le texte pour quitter */
besoinRedessiner = 0; /* Réinitialiser le drapeau de redessin */
}
if (SourisCliquee()) { /* Vérifier si la souris est cliquée */ if (SourisCliquee()) {
if (_Y >= 110 && _Y <= 140) { /* Vérifier si le clic est dans la zone de taille de grille */ int mouseX = _X;
if (_X >= 500 && _X <= 530 && tailleGrille < 9) { /* Augmenter la taille de la grille */ int mouseY = _Y;
printf("Menu click at: (%d, %d)\n", mouseX, mouseY);
if (mouseX >= 500 && mouseX <= 530 && mouseY >= 110 && mouseY <= 140) {
if (tailleGrille < 9) {
tailleGrille++; tailleGrille++;
besoinRedessiner = 1; /* Indiquer qu'un redessin est nécessaire */
} else if (_X >= 540 && _X <= 570 && tailleGrille > 3) { /* Diminuer la taille de la grille */
tailleGrille--;
besoinRedessiner = 1; /* Indiquer qu'un redessin est nécessaire */
} }
} else if (_X >= 250 && _X <= 550) { /* Vérifier si le clic est dans la zone de mode de jeu */ } else if (mouseX >= 540 && mouseX <= 570 && mouseY >= 110 && mouseY <= 140) {
if (_Y >= 180 && _Y <= 230) { /* Mode 1 joueur */ if (tailleGrille > 3) {
struct EtatJeu etatJeu = initialiserJeu(tailleGrille, 1); /* Initialiser l'état du jeu */ tailleGrille--;
EffacerEcran(CouleurParNom("white")); /* Effacer l'écran pour afficher la grille */ }
dessinerGrille(etatJeu); /* Dessiner la grille */ } else if (mouseX >= 250 && mouseX <= 550) {
struct EtatJeu etatJeu;
if (mouseY >= 180 && mouseY <= 230) {
etatJeu = initialiserJeu(tailleGrille, 1);
EffacerEcran(CouleurParNom("white"));
dessinerGrille(etatJeu);
/* Boucle pour garder la fenêtre ouverte */ while (1) {
while (!SourisCliquee()) { if (SourisCliquee()) {
gererClicSouris(&etatJeu); /* Gérer les clics de souris */ printf("Grid click detected at: (%d, %d)\n", _X, _Y);
usleep(10000); /* Attendre un court instant */ gererClicSouris(&etatJeu);
int gagnant = verifierVictoire(etatJeu);
if (gagnant != 0) {
printf("Le joueur %d a gagné !\n", gagnant);
break;
}
}
usleep(10000);
} }
continuer = 0; /* Sortir du menu */ } else if (mouseY >= 250 && mouseY <= 300) {
} else if (_Y >= 250 && _Y <= 300) { /* Mode 2 joueurs */ etatJeu = initialiserJeu(tailleGrille, 2);
continuer = 0; /* Sortir du menu */ EffacerEcran(CouleurParNom("white"));
} else if (_Y >= 320 && _Y <= 370) { /* Quitter */ dessinerGrille(etatJeu);
continuer = 0; /* Sortir du menu */
while (1) {
if (SourisCliquee()) {
printf("Grid click detected at: (%d, %d)\n", _X, _Y);
gererClicSouris(&etatJeu);
int gagnant = verifierVictoire(etatJeu);
if (gagnant != 0) {
printf("Le joueur %d a gagné !\n", gagnant);
break;
}
}
usleep(10000);
}
} else if (mouseY >= 320 && mouseY <= 370) {
continuer = 0;
} }
} }
} }
usleep(10000); /* Attendre 10 millisecondes pour améliorer la réactivité */ usleep(10000);
} }
FermerGraphique(); /* Fermer la graphique */ FermerGraphique();
} }
int main() { int main() {
menuPrincipale(); /* Appeler la fonction du menu principal */ menuPrincipale();
return 0; /* Retourner 0 pour indiquer que le programme s'est terminé avec succès */ return 0;
} }