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

Problème UTF8: Changer le texte de fin et les indications de partie

Browse Source
This commit is contained in:
Haffa BAKHOUCHE
2024-11-21 12:08:15 +01:00
parent f617be351b
commit 2d0a9aea00
7 changed files with 192 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
blocus
View File

Binary file not shown.

10
jeu.c
View File

@@ -4,6 +4,7 @@
#include <graph.h>
#include "jeu.h"
/* Fonction qui initialise le jeu */
struct EtatJeu initialiserJeu(int tailleGrille, int mode) {
struct EtatJeu etat;
int i;
@@ -26,10 +27,12 @@ struct EtatJeu initialiserJeu(int tailleGrille, int mode) {
return etat;
}
/* Fonction qui vérifie si deux cases sont adjacentes */
int estCaseAdjacente(struct Position pos1, struct Position pos2) {
return abs(pos1.x - pos2.x) <= 1 && abs(pos1.y - pos2.y) <= 1;
}
/* Fonction qui vérifie si le joueur peut déplacer son pion */
int peutDeplacer(struct EtatJeu etatJeu, int joueur) {
struct Position pos;
int i, j;
@@ -54,6 +57,7 @@ int peutDeplacer(struct EtatJeu etatJeu, int joueur) {
return 0;
}
/* Fonction qui affiche la grille de jeu */
void dessinerGrille(struct EtatJeu etatJeu) {
int i, j;
int largeurFenetre = 800;
@@ -69,7 +73,7 @@ void dessinerGrille(struct EtatJeu etatJeu) {
if(etatJeu.phase == 0) {
sprintf(message, "Joueur %d : Placez votre pion", etatJeu.tourJoueur);
} else if(etatJeu.phase == 1) {
sprintf(message, "Joueur %d : Déplacez votre pion", etatJeu.tourJoueur);
sprintf(message, "Joueur %d : Deplacez votre pion", etatJeu.tourJoueur);
} else {
sprintf(message, "Joueur %d : Bloquez une case", etatJeu.tourJoueur);
}
@@ -105,18 +109,20 @@ void dessinerGrille(struct EtatJeu etatJeu) {
}
}
/* Fonction qui affiche le gagnant de la partie */
void afficherVictoire(int gagnant) {
char message[100];
EffacerEcran(CouleurParNom("white"));
ChoisirCouleurDessin(CouleurParNom("black"));
sprintf(message, "Le joueur %d a gagné !", gagnant);
sprintf(message, "Le joueur %d remporte la partie !", gagnant); /* Affiche le gagnant après avoir clear la window de la partie */
EcrireTexte(250, 300, message, 2);
EcrireTexte(200, 400, "Cliquez pour retourner au menu", 1);
}
/* Fonction qui vérifie si le joueur a gagné la partie */
int verifierVictoire(struct EtatJeu etatJeu) {
if (etatJeu.phase == 0) {
return 0;

13
jeu.h
View File

@@ -1,11 +1,13 @@
#ifndef JEU_H_INCLUS
#define JEU_H_INCLUS
/* Structure qui représente une position sur la grille */
struct Position {
int x;
int y;
};
/* Structure qui représente l'état du jeu */
struct EtatJeu {
int tailleGrille;
int mode;
@@ -16,11 +18,22 @@ struct EtatJeu {
int** grille;
};
/* Fonction qui initialise le jeu */
struct EtatJeu initialiserJeu(int tailleGrille, int mode);
/* Fonction qui dessine la grille de jeu */
void dessinerGrille(struct EtatJeu etatJeu);
/* Fonction qui vérifie si le joueur a gagné la partie */
int verifierVictoire(struct EtatJeu etatJeu);
/* Fonction qui affiche le gagnant de la partie */
void afficherVictoire(int gagnant);
/* Fonction qui vérifie si deux cases sont adjacentes */
int estCaseAdjacente(struct Position pos1, struct Position pos2);
/* Fonction qui vérifie si le joueur peut déplacer son pion */
int peutDeplacer(struct EtatJeu etatJeu, int joueur);
#endif /* JEU_H_INCLUS */

112
jeu_humain.c
View File

@@ -2,18 +2,21 @@
#include <stdlib.h>
#include <graph.h>
#include <unistd.h>
#include "jeu.h"
#include "jeu_humain.h"
/* Fonction qui permet de jouer en mode humain */
void jouerModeHumain(struct EtatJeu *etatJeu) {
while (1) {
if (SourisCliquee()) {
printf("Clic détecté sur la grille à : (%d, %d)\n", _X, _Y);
gererClicHumain(etatJeu);
if (etatJeu->phase == 0) {
gererPlacementInitial(etatJeu);
} else {
gererTourJoueur(etatJeu);
}
int gagnant = verifierVictoire(*etatJeu);
if (gagnant != 0) {
afficherVictoire(gagnant);
printf("En attente d'un clic pour retourner au menu...\n");
if (etatJeu->phase > 0 && !peutDeplacer(*etatJeu, etatJeu->tourJoueur)) {
afficherVictoire(etatJeu->tourJoueur == 1 ? 2 : 1);
while (!SourisCliquee()) {
usleep(100000);
}
@@ -24,35 +27,112 @@ void jouerModeHumain(struct EtatJeu *etatJeu) {
}
}
void gererClicHumain(struct EtatJeu *etatJeu) {
int x = _X;
int y = _Y;
/* Fonction qui gère le placement initial du joueur 1 */
void gererPlacementInitial(struct EtatJeu *etatJeu) {
int x, y, i, j;
int largeurFenetre = 800;
int hauteurFenetre = 600;
int marge = 50;
int tailleCase;
int startX, startY;
int tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
x = _X;
y = _Y;
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;
startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
x -= startX;
y -= startY;
int i = y / tailleCase;
int j = x / tailleCase;
i = y / tailleCase;
j = x / tailleCase;
if (i >= 0 && i < etatJeu->tailleGrille &&
j >= 0 && j < etatJeu->tailleGrille &&
etatJeu->grille[i][j] == 0) {
etatJeu->grille[i][j] = etatJeu->tourJoueur;
etatJeu->tourJoueur = (etatJeu->tourJoueur == 1) ? 2 : 1;
if (etatJeu->tourJoueur == 1) {
etatJeu->joueur1.x = j;
etatJeu->joueur1.y = i;
} else {
etatJeu->joueur2.x = j;
etatJeu->joueur2.y = i;
}
if (etatJeu->tourJoueur == 2) {
etatJeu->phase = 1;
etatJeu->tourJoueur = 1;
} else {
etatJeu->tourJoueur = 2;
}
EffacerEcran(CouleurParNom("white"));
dessinerGrille(*etatJeu);
}
}
/* Fonction qui gère le tour du joueur 1 */
void gererTourJoueur(struct EtatJeu *etatJeu) {
int x, y, i, j;
int largeurFenetre = 800;
int hauteurFenetre = 600;
int marge = 50;
int tailleCase;
int startX, startY;
struct Position posActuelle;
struct Position posCliquee;
x = _X;
y = _Y;
tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
if (tailleCase * etatJeu->tailleGrille > (hauteurFenetre - 2 * marge)) {
tailleCase = (hauteurFenetre - 2 * marge) / etatJeu->tailleGrille;
}
startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
x -= startX;
y -= startY;
i = y / tailleCase;
j = x / tailleCase;
posActuelle = etatJeu->tourJoueur == 1 ? etatJeu->joueur1 : etatJeu->joueur2;
posCliquee.x = j;
posCliquee.y = i;
if (i >= 0 && i < etatJeu->tailleGrille && j >= 0 && j < etatJeu->tailleGrille) {
if (etatJeu->phase == 1) {
if (etatJeu->grille[i][j] == 0 && estCaseAdjacente(posActuelle, posCliquee)) {
etatJeu->grille[posActuelle.y][posActuelle.x] = 0;
etatJeu->grille[i][j] = etatJeu->tourJoueur;
if (etatJeu->tourJoueur == 1) {
etatJeu->joueur1.x = j;
etatJeu->joueur1.y = i;
} else {
etatJeu->joueur2.x = j;
etatJeu->joueur2.y = i;
}
etatJeu->phase = 2;
dessinerGrille(*etatJeu);
}
} else if (etatJeu->phase == 2) {
if (etatJeu->grille[i][j] == 0) {
etatJeu->grille[i][j] = 3;
etatJeu->phase = 1;
etatJeu->tourJoueur = etatJeu->tourJoueur == 1 ? 2 : 1;
dessinerGrille(*etatJeu);
}
}
}
}

14
jeu_humain.h
View File

@@ -1,9 +1,15 @@
#ifndef JEU_HUMAIN_H
#define JEU_HUMAIN_H
#ifndef JEU_HUMAIN_H_INCLUS
#define JEU_HUMAIN_H_INCLUS
#include "jeu.h"
/* Fonction qui permet de jouer en mode humain */
void jouerModeHumain(struct EtatJeu *etatJeu);
void gererClicHumain(struct EtatJeu *etatJeu);
#endif
/* Fonction qui gère le placement initial du joueur 1 */
void gererPlacementInitial(struct EtatJeu *etatJeu);
/* Fonction qui gère le tour du joueur 1 */
void gererTourJoueur(struct EtatJeu *etatJeu);
#endif /* JEU_HUMAIN_H_INCLUS */

22
jeu_ia.c
View File

@@ -5,9 +5,11 @@
#include "jeu.h"
#include "jeu_ia.h"
/* Fonction qui permet de jouer avec l'IA */
void jouerModeIA(struct EtatJeu *etatJeu) {
int gagnant;
/* Boucle qui permet de jouer avec l'IA */
while (1) {
if (etatJeu->tourJoueur == 1) {
if (SourisCliquee()) {
@@ -28,6 +30,7 @@ void jouerModeIA(struct EtatJeu *etatJeu) {
}
}
/* Vérifie si le joueur a gagné la partie */
if (etatJeu->phase > 0) {
gagnant = verifierVictoire(*etatJeu);
if (gagnant != 0) {
@@ -42,6 +45,7 @@ void jouerModeIA(struct EtatJeu *etatJeu) {
}
}
/* Fonction qui gère le placement initial de l'IA */
void gererPlacementInitialIA(struct EtatJeu *etatJeu) {
int x, y, i, j;
int largeurFenetre = 800;
@@ -53,11 +57,12 @@ void gererPlacementInitialIA(struct EtatJeu *etatJeu) {
x = _X;
y = _Y;
/* Calcul de la taille de chaque case */
tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
if (tailleCase * etatJeu->tailleGrille > (hauteurFenetre - 2 * marge)) {
tailleCase = (hauteurFenetre - 2 * marge) / etatJeu->tailleGrille;
}
/* Calcul de la position de départ de la grille */
startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
@@ -67,6 +72,7 @@ void gererPlacementInitialIA(struct EtatJeu *etatJeu) {
i = y / tailleCase;
j = x / tailleCase;
/* Vérifie si la case est valide */
if (i >= 0 && i < etatJeu->tailleGrille &&
j >= 0 && j < etatJeu->tailleGrille &&
etatJeu->grille[i][j] == 0) {
@@ -79,6 +85,7 @@ void gererPlacementInitialIA(struct EtatJeu *etatJeu) {
}
}
/* Fonction qui gère le tour de l'IA */
void gererTourJoueurIA(struct EtatJeu *etatJeu) {
int x, y, i, j;
int largeurFenetre = 800;
@@ -92,11 +99,12 @@ void gererTourJoueurIA(struct EtatJeu *etatJeu) {
x = _X;
y = _Y;
/* Calcul de la taille de chaque case */
tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
if (tailleCase * etatJeu->tailleGrille > (hauteurFenetre - 2 * marge)) {
tailleCase = (hauteurFenetre - 2 * marge) / etatJeu->tailleGrille;
}
/* Calcul de la position de départ de la grille */
startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
@@ -106,10 +114,12 @@ void gererTourJoueurIA(struct EtatJeu *etatJeu) {
i = y / tailleCase;
j = x / tailleCase;
/* Position actuelle du joueur 1 */
posActuelle = etatJeu->joueur1;
posCliquee.x = j;
posCliquee.y = i;
/* Vérifie si la case est valide */
if (i >= 0 && i < etatJeu->tailleGrille && j >= 0 && j < etatJeu->tailleGrille) {
if (etatJeu->phase == 1) {
if (etatJeu->grille[i][j] == 0 && estCaseAdjacente(posActuelle, posCliquee)) {
@@ -131,8 +141,10 @@ void gererTourJoueurIA(struct EtatJeu *etatJeu) {
}
}
/* Fonction qui permet de s'assurer que l'IA place son pion à un endroit valide */
void placementIA(struct EtatJeu *etatJeu) {
int i, j;
/* Boucle qui place le pion de l'IA à un endroit valide à l'aide de random */
do {
i = rand() % etatJeu->tailleGrille;
j = rand() % etatJeu->tailleGrille;
@@ -146,11 +158,13 @@ void placementIA(struct EtatJeu *etatJeu) {
dessinerGrille(*etatJeu);
}
/* Fonction qui permet à l'IA de déplacer son pion */
void deplacementIA(struct EtatJeu *etatJeu) {
int dx, dy;
int newX, newY;
int trouve = 0;
/* Boucle qui permet de trouver une case valide pour le déplacement */
for(dx = -1; dx <= 1 && !trouve; dx++) {
for(dy = -1; dy <= 1 && !trouve; dy++) {
if(dx == 0 && dy == 0) continue;
@@ -174,10 +188,12 @@ void deplacementIA(struct EtatJeu *etatJeu) {
dessinerGrille(*etatJeu);
}
/* Fonction qui permet à l'IA de placer un pion de blocage */
void blocageIA(struct EtatJeu *etatJeu) {
int i, j;
int trouve = 0;
/* Boucle qui permet de trouver une case valide pour le placement du pion de blocage (avec l'aide de random)*/
do {
i = rand() % etatJeu->tailleGrille;
j = rand() % etatJeu->tailleGrille;
@@ -187,4 +203,4 @@ void blocageIA(struct EtatJeu *etatJeu) {
etatJeu->phase = 1;
etatJeu->tourJoueur = 1;
dessinerGrille(*etatJeu);
}
}

99
main.c
View File

@@ -3,6 +3,8 @@
#include <graph.h>
#include <unistd.h>
#include "jeu.h"
#include "jeu_humain.h"
#include "jeu_ia.h"
void menuPrincipale() {
int tailleGrille = 3;
@@ -10,79 +12,69 @@ void menuPrincipale() {
char tailleStr[4];
int besoinRedessiner = 1;
InitialiserGraphique();
CreerFenetre(100, 100, 800, 600);
ChoisirTitreFenetre("Blocus");
InitialiserGraphique(); /* Initialise la fenêtre graphique */
CreerFenetre(100, 100, 800, 600); /* Crée la fenêtre graphique */
ChoisirTitreFenetre("Blocus"); /* Change le titre de la fenêtre */
while (continuer) {
if (besoinRedessiner) {
EffacerEcran(CouleurParNom("white"));
ChoisirCouleurDessin(CouleurParNom("black"));
EcrireTexte(300, 50, "BLOCUS", 2);
EcrireTexte(250, 120, "Taille de la grille:", 1);
if (besoinRedessiner) { /* Si besoin de redessiner */
EffacerEcran(CouleurParNom("white")); /* Efface l'écran */
ChoisirCouleurDessin(CouleurParNom("black")); /*
EcrireTexte(300, 50, "BLOCUS", 2); /* Affiche le titre du jeu */
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);
EcrireTexte(450, 120, tailleStr, 1); /* Affiche la taille de la grille */
besoinRedessiner = 0;
RemplirRectangle(500, 110, 30, 30); /* Remplit la case + */
RemplirRectangle(540, 110, 30, 30); /* Remplit la case - */
ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(510, 120, "+", 1); /* Affiche le + */
EcrireTexte(550, 120, "-", 1); /* Affiche le - */
ChoisirCouleurDessin(CouleurParNom("black"));
RemplirRectangle(250, 180, 300, 50); /* Remplit la case 1 Joueur (contre IA) */
RemplirRectangle(250, 250, 300, 50); /* Remplit la case 2 Joueurs */
ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(280, 195, "1 Joueur (contre IA)", 1); /* Affiche 1 Joueur (contre IA) */
EcrireTexte(280, 265, "2 Joueurs", 1); /* Affiche 2 Joueurs */
ChoisirCouleurDessin(CouleurParNom("black"));
RemplirRectangle(250, 320, 300, 50); /* Remplit la case Quitter */
ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(320, 335, "Quitter", 1); /* Affiche Quitter */
besoinRedessiner = 0;
}
if (SourisCliquee()) {
if (SourisCliquee()) { /* Si la souris est cliquée */
int mouseX = _X;
int mouseY = _Y;
printf("Clic détecté dans le menu à : (%d, %d)\n", mouseX, mouseY);
if (mouseX >= 500 && mouseX <= 530 && mouseY >= 110 && mouseY <= 140) {
if (mouseX >= 500 && mouseX <= 530 && mouseY >= 110 && mouseY <= 140) { /* Si la souris est sur la case + */
if (tailleGrille < 9) {
tailleGrille++;
besoinRedessiner = 1;
}
} else if (mouseX >= 540 && mouseX <= 570 && mouseY >= 110 && mouseY <= 140) {
} else if (mouseX >= 540 && mouseX <= 570 && mouseY >= 110 && mouseY <= 140) { /* Si la souris est sur la case - */
if (tailleGrille > 3) {
tailleGrille--;
besoinRedessiner = 1;
}
} else if (mouseX >= 250 && mouseX <= 550) {
} else if (mouseX >= 250 && mouseX <= 600) { /* Si la souris est sur la case 1 Joueur (contre IA) */
struct EtatJeu etatJeu;
if (mouseY >= 180 && mouseY <= 230 || mouseY >= 250 && mouseY <= 300) {
int mode = (mouseY >= 180 && mouseY <= 230) ? 1 : 2;
etatJeu = initialiserJeu(tailleGrille, mode);
if (mouseY >= 180 && mouseY <= 230) {
etatJeu = initialiserJeu(tailleGrille, 1);
EffacerEcran(CouleurParNom("white"));
dessinerGrille(etatJeu);
while (1) {
if (SourisCliquee()) {
printf("Clic détecté sur la grille à : (%d, %d)\n", _X, _Y);
gererClicSouris(&etatJeu);
int gagnant = verifierVictoire(etatJeu);
if (gagnant != 0) {
afficherVictoire(gagnant);
printf("En attente d'un clic pour retourner au menu...\n");
while (!SourisCliquee()) {
usleep(100000);
}
besoinRedessiner = 1;
break;
}
}
usleep(20000);
}
} else if (mouseY >= 320 && mouseY <= 370) {
jouerModeIA(&etatJeu);
besoinRedessiner = 1;
} else if (mouseY >= 250 && mouseY <= 300) { /* Si la souris est sur la case 2 Joueurs */
etatJeu = initialiserJeu(tailleGrille, 2);
EffacerEcran(CouleurParNom("white"));
dessinerGrille(etatJeu);
jouerModeHumain(&etatJeu);
besoinRedessiner = 1;
} else if (mouseY >= 320 && mouseY <= 370) { /* Si la souris est sur la case Quitter */
continuer = 0;
}
}
@@ -94,6 +86,7 @@ void menuPrincipale() {
}
int main() {
srand(time(NULL));
menuPrincipale();
return 0;
}