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

Ajout du header jeu.h et de plusieurs fonctions importantes

Browse Source
This commit is contained in:
Haffa BAKHOUCHE
2024-11-14 12:12:14 +01:00
parent a476b5695b
commit d7dad1116c
6 changed files with 114 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
README.md Normal file → Executable file
View File

BIN
blocus Executable file
View File

Binary file not shown.

155
jeu.c Normal file → Executable file
View File

@@ -1,25 +1,40 @@
#include <stdio.h>
#include <stdlib.h>
#include <graph.h>
#include "jeu.h"
#include <graph.h> /* Assurez-vous d'inclure la bibliothèque graphique */
#define TAILLE_FENETRE 800
#define MARGE 100
#define TAILLE_MAX_GRILLE 400
/* Fonction pour dessiner la grille */
void dessinerGrille(struct EtatJeu etatJeu) {
int i, j;
int tailleCase = 50; /* Taille de chaque case de la grille */
int x, y;
for (i = 0; i < etatJeu.tailleGrille; i++) {
for (j = 0; j < etatJeu.tailleGrille; j++) {
x = j * tailleCase; /* Calculer la position x */
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 */
/* Vous pouvez ajouter ici du code pour dessiner des éléments spécifiques dans chaque case */
}
}
}
/* 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;
etatJeu.phase = 0;
etatJeu.positionSourisJoueur1x = -1;
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;
/* 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");
@@ -37,130 +52,22 @@ struct EtatJeu initialiserJeu(int tailleGrille, int mode) {
exit(1);
}
for (j = 0; j < tailleGrille; j++) {
etatJeu.grille[i][j] = 0;
etatJeu.grille[i][j] = 0; /* Initialiser les cellules de la grille à 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;
}
/* Fonction pour jouer avec l'IA */
void jouerAvecIA(struct EtatJeu etatJeu) {
/* Logique de jeu avec l'IA ici */
/* Par exemple, afficher la grille et gérer les tours */
printf("Début du jeu avec l'IA...\n");
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) {
/* Dessiner la grille */
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);
/* Ajoutez ici la logique pour gérer les tours de jeu, etc. */
}
/* Ajouter d'autres fonctions de logique de jeu si nécessaire */

28
jeu.h Normal file
View File

@@ -0,0 +1,28 @@
/* 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 tourJoueur;
int phase;
int positionSourisJoueur1x;
int positionSourisJoueur1y;
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 */
#endif /* JEU_H */

103
main.c Normal file → Executable file
View File

@@ -1,73 +1,74 @@
#include <stdio.h>
#include <stdlib.h>
#include <graph.h>
#include <unistd.h>
#include "jeu.h" /* Inclure l'en-tête pour la logique du jeu */
void menuPrincipale() {
int tailleGrille = 3, mode = 0;
int continuer = 1;
int tailleGrille = 3; /* Taille de la grille */
int continuer = 1; /* Variable pour continuer le menu */
InitialiserGraphique();
CreerFenetre(100, 100, 800, 600);
ChoisirTitreFenetre("Blocus");
char tailleStr[4]; /* Augmenter la taille pour contenir des nombres plus grands */
while (continuer) {
EffacerEcran(CouleurParNom("white"));
InitialiserGraphique(); /* Initialiser la graphique */
CreerFenetre(100, 100, 800, 600); /* Créer la fenêtre */
ChoisirTitreFenetre("Blocus"); /* Choisir le titre de la fenêtre */
ChoisirCouleurDessin(CouleurParNom("black"));
EcrireTexte(300, 50, "BLOCUS", 2);
while (continuer) { /* Boucle principale du menu */
EffacerEcran(CouleurParNom("white")); /* Effacer l'écran */
EcrireTexte(250, 120, "Taille de la grille:", 1);
char tailleStr[2];
sprintf(tailleStr, "%d", tailleGrille);
EcrireTexte(450, 120, tailleStr, 1);
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);
RemplirRectangle(540, 110, 30, 30);
ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(510, 120, "+", 1);
EcrireTexte(550, 120, "-", 1);
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"));
RemplirRectangle(250, 180, 300, 50);
RemplirRectangle(250, 250, 300, 50);
ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(280, 195, "1 Joueur", 1);
EcrireTexte(280, 265, "2 Joueurs", 1);
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 */
ChoisirCouleurDessin(CouleurParNom("black"));
RemplirRectangle(250, 320, 300, 50);
ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(320, 335, "Quitter", 1);
if (SourisCliquee()) {
if (_Y >= 110 && _Y <= 140) {
if (_X >= 500 && _X <= 530 && tailleGrille < 9) {
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 */
tailleGrille++;
} else if (_X >= 540 && _X <= 570 && tailleGrille > 3) {
} else if (_X >= 540 && _X <= 570 && tailleGrille > 3) { /* Diminuer la taille de la grille */
tailleGrille--;
}
}
else if (_X >= 250 && _X <= 550) {
if (_Y >= 180 && _Y <= 230) {
mode = 1;
continuer = 0;
} else if (_Y >= 250 && _Y <= 300) {
mode = 2;
continuer = 0;
} else if (_Y >= 320 && _Y <= 370) {
mode = 0;
continuer = 0;
}
} 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 */
jouerAvecIA(etatJeu); /* Appeler la fonction pour démarrer le jeu avec l'IA */
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 */
}
}
}
FermerGraphique();
sleep(1); /* Attendre un court instant (remplacer usleep par sleep) */
}
FermerGraphique(); /* Fermer la graphique */
}
int main() {
menuPrincipale(); /* Appeler la fonction du menu principal */
return 0; /* Retourner 0 pour indiquer que le programme s'est terminé avec succès */
}

0
makefile Normal file → Executable file
View File