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 <stdlib.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) {
DessinerArc(x - rayon, y - rayon, 2 * rayon, 2 * rayon, 0, 360);
}
/* Fonction pour dessiner la grille */
void dessinerGrille(struct EtatJeu etatJeu) {
int i, j;
int largeurFenetre = 800; /* Largeur de la fenêtre */
int hauteurFenetre = 600; /* Hauteur de la fenêtre */
int largeurFenetre = 800;
int hauteurFenetre = 600;
int marge = 50; /* Marge pour éviter les bords */
/* Calculer la taille de chaque case pour remplir complètement la fenêtre */
int tailleCase = (largeurFenetre < hauteurFenetre) ? (largeurFenetre / etatJeu.tailleGrille) : (hauteurFenetre / etatJeu.tailleGrille);
/* Ajuster la taille de la case pour qu'elle prenne tout l'espace */
if (tailleCase * etatJeu.tailleGrille > hauteurFenetre) {
tailleCase = hauteurFenetre / etatJeu.tailleGrille;
/* Calculer la taille de case en prenant le minimum entre largeur et hauteur */
int tailleCase = (largeurFenetre - 2 * marge) / etatJeu.tailleGrille;
if (tailleCase * etatJeu.tailleGrille > (hauteurFenetre - 2 * marge)) {
tailleCase = (hauteurFenetre - 2 * marge) / 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 (j = 0; j < etatJeu.tailleGrille; j++) {
int x = j * tailleCase; /* Calculer la position x */
int y = i * tailleCase; /* Calculer la position y */
ChoisirCouleurDessin(CouleurParNom("black")); /* Couleur de la grille */
DessinerRectangle(x, y, tailleCase, tailleCase); /* Dessiner le rectangle pour la case */
int x = startX + (j * tailleCase);
int y = startY + (i * tailleCase);
/* Dessiner les pièces bloquées */
if (etatJeu.grille[i][j] == 1) { /* 1 pour l'humain */
ChoisirCouleurDessin(CouleurParNom("black"));
DessinerRectangle(x, y, tailleCase, tailleCase);
if (etatJeu.grille[i][j] == 1) {
ChoisirCouleurDessin(CouleurParNom("blue"));
DessinerCercle(x + tailleCase / 2, y + tailleCase / 2, tailleCase / 4); /* Dessiner un cercle bleu */
} else if (etatJeu.grille[i][j] == 2) { /* 2 pour l'IA */
RemplirRectangle(x + 5, y + 5, tailleCase - 10, tailleCase - 10);
} else if (etatJeu.grille[i][j] == 2) {
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) {
int x, y;
int tailleCase;
int i, j;
if (SourisCliquee()) {
x = _X; /* Position X du clic */
y = _Y; /* Position Y du clic */
tailleCase = 800 / etatJeu->tailleGrille; /* Taille de chaque case */
i = y / tailleCase; /* Ligne cliquée */
j = x / tailleCase; /* Colonne cliquée */
/* Vérifier si la case est libre */
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 */
dessinerGrille(*etatJeu); /* Redessiner la grille */
jouerAvecIA(*etatJeu); /* Appeler la fonction de l'IA pour bloquer une case */
}
int x = _X;
int y = _Y;
int largeurFenetre = 800;
int hauteurFenetre = 600;
int marge = 50;
int tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
if (tailleCase * etatJeu->tailleGrille > (hauteurFenetre - 2 * marge)) {
tailleCase = (hauteurFenetre - 2 * marge) / etatJeu->tailleGrille;
}
int startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
int startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
/* Ajuster les coordonnées du clic en fonction du décalage de la grille */
x -= startX;
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 etatJeu;
int i, j;
etatJeu.tailleGrille = tailleGrille;
etatJeu.mode = mode;
etatJeu.tourJoueur = 1; /* Initialiser le joueur courant */
etatJeu.phase = 0; /* Initialiser la phase */
etatJeu.positionSourisJoueur1x = -1; /* Initialiser les positions de la souris */
etatJeu.positionSourisJoueur1y = -1;
etatJeu.positionSourisJoueur2x = -1;
etatJeu.positionSourisJoueur2y = -1;
etatJeu.tourJoueur = 1;
etatJeu.phase = 0;
/* Allouer de la mémoire pour la grille */
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; /* Initialiser les cellules de la grille à 0 */
etatJeu.grille[i][j] = 0;
}
}
return etatJeu;
}
/* Fonction pour jouer avec l'IA */
void jouerAvecIA(struct EtatJeu etatJeu) {
int verifierVictoire(struct EtatJeu etatJeu) {
int i, j;
/* Logique simple pour que l'IA bloque une case */
for (i = 0; i < etatJeu.tailleGrille; i++) {
for (j = 0; j < etatJeu.tailleGrille; j++) {
if (etatJeu.grille[i][j] == 0) { /* Trouver une case libre */
etatJeu.grille[i][j] = 2; /* Marquer la case comme bloquée par l'IA */
dessinerGrille(etatJeu); /* Redessiner la grille */
return; /* Sortir après avoir bloqué une case */
if (etatJeu.grille[i][0] != 0) {
int gagnant = etatJeu.grille[i][0];
int victoire = 1;
for (j = 1; j < etatJeu.tailleGrille; j++) {
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
#define JEU_H
/* Définir la structure pour l'état du jeu */
struct EtatJeu {
int tailleGrille; /* Taille de la grille */
int mode; /* Mode de jeu (1 joueur ou 2 joueurs) */
int tailleGrille;
int mode;
int tourJoueur;
int phase;
int positionSourisJoueur1x;
@@ -14,16 +11,13 @@ struct EtatJeu {
int positionSourisJoueur2x;
int positionSourisJoueur2y;
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);
/* Fonction pour jouer avec l'IA */
void jouerAvecIA(struct EtatJeu etatJeu);
/* Ajouter d'autres prototypes de fonction liés à la logique du jeu */
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 */

148
main.c
View File

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