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

Supprimer les dossiers include et src

Browse Source
This commit is contained in:
Haffa BAKHOUCHE
2024-11-24 15:15:54 +01:00
parent 027fb82f36
commit 25550e887f
7 changed files with 0 additions and 707 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
include/jeu.h
View File

@@ -1,40 +0,0 @@
#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;
int tourJoueur;
int phase;
struct Position joueur1;
struct Position joueur2;
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 */

16
include/jeu_humain.h
View File

@@ -1,16 +0,0 @@
#ifndef JEU_HUMAIN_H
#define JEU_HUMAIN_H
#include "jeu.h"
/* Fonction qui gère le mode humain */
void jouerModeHumain(struct EtatJeu *etatJeu);
/* Fonction qui gère le placement initial */
void gererPlacementInitial(struct EtatJeu *etatJeu);
/* Fonction qui gère le tour du joueur */
void gererTourJoueur(struct EtatJeu *etatJeu);
void attendre(int secondes);
#endif

24
include/jeu_ia.h
View File

@@ -1,24 +0,0 @@
#ifndef JEU_IA_H_INCLUS
#define JEU_IA_H_INCLUS
#include "jeu.h"
/* Fonction qui gère le mode IA */
void jouerModeIA(struct EtatJeu *etatJeu);
/* Fonction qui gère le placement initial IA */
void gererPlacementInitialIA(struct EtatJeu *etatJeu);
/* Fonction qui gère le tour du joueur IA */
void gererTourJoueurIA(struct EtatJeu *etatJeu);
/* Fonction qui gère le placement de l'IA */
void placementIA(struct EtatJeu *etatJeu);
/* Fonction qui gère le déplacement de l'IA */
void deplacementIA(struct EtatJeu *etatJeu);
/* Fonction qui gère le blocage de l'IA */
void blocageIA(struct EtatJeu *etatJeu);
#endif /* JEU_IA_H_INCLUS */

181
src/jeu.c
View File

@@ -1,181 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <graph.h>
#include "../include/jeu.h"
/* Fonction qui initialise le jeu */
struct EtatJeu initialiserJeu(int tailleGrille, int mode) {
struct EtatJeu etat;
int i;
etat.tailleGrille = tailleGrille;
etat.mode = mode;
etat.tourJoueur = 1;
etat.phase = 0;
etat.joueur1.x = -1;
etat.joueur1.y = -1;
etat.joueur2.x = -1;
etat.joueur2.y = -1;
/* Alloue la mémoire pour la grille de jeu */
etat.grille = malloc(tailleGrille * sizeof(int*));
/* Pour chaque ligne de la grille */
for(i = 0; i < tailleGrille; i++) {
/* Alloue la mémoire pour la ligne et l'initialise à 0 */
etat.grille[i] = malloc(tailleGrille * sizeof(int));
memset(etat.grille[i], 0, tailleGrille * sizeof(int));
}
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;
int newX, newY;
/* Récupère la position du pion du joueur actuel */
pos = joueur == 1 ? etatJeu.joueur1 : etatJeu.joueur2;
/* Parcourt toutes les cases adjacentes (8 directions possibles) */
for(i = -1; i <= 1; i++) {
for(j = -1; j <= 1; j++) {
/* Ignore la position actuelle du pion */
if(i == 0 && j == 0) continue;
/* Calcule les nouvelles coordonnées potentielles */
newX = pos.x + i;
newY = pos.y + j;
/* Vérifie si la nouvelle position est :
1. Dans les limites de la grille (>= 0 et < tailleGrille)
2. Sur une case vide (== 0) */
if(newX >= 0 && newX < etatJeu.tailleGrille &&
newY >= 0 && newY < etatJeu.tailleGrille &&
etatJeu.grille[newY][newX] == 0) {
return 1;
}
}
}
return 0;
}
/* Fonction qui affiche la grille de jeu */
void dessinerGrille(struct EtatJeu etatJeu) {
int i, j;
int largeurFenetre = 800;
int hauteurFenetre = 600;
int marge = 50;
int tailleCase;
int startX, startY;
char message[100];
EffacerEcran(CouleurParNom("white"));
ChoisirCouleurDessin(CouleurParNom("black"));
/* Affiche le message en fonction de la phase du jeu */
if(etatJeu.phase == 0) {
sprintf(message, "Joueur %d : Placez votre pion", etatJeu.tourJoueur);
} else if(etatJeu.phase == 1) {
sprintf(message, "Joueur %d : Deplacez votre pion", etatJeu.tourJoueur);
} else {
sprintf(message, "Joueur %d : Bloquez une case", etatJeu.tourJoueur);
}
EcrireTexte(200, 30, message, 2);
/* Calcule la taille de chaque case de la grille */
tailleCase = (largeurFenetre - 2 * marge) / etatJeu.tailleGrille;
if (tailleCase * etatJeu.tailleGrille > (hauteurFenetre - 2 * marge)) {
tailleCase = (hauteurFenetre - 2 * marge) / etatJeu.tailleGrille;
}
/* Calcule la position de départ de la grille */
startX = (largeurFenetre - (tailleCase * etatJeu.tailleGrille)) / 2;
startY = (hauteurFenetre - (tailleCase * etatJeu.tailleGrille)) / 2;
/* Pour chaque case de la grille */
for (i = 0; i < etatJeu.tailleGrille; i++) {
for (j = 0; j < etatJeu.tailleGrille; j++) {
int x = startX + (j * tailleCase);
int y = startY + (i * tailleCase);
ChoisirCouleurDessin(CouleurParNom("black"));
DessinerRectangle(x, y, tailleCase, tailleCase);
if (etatJeu.grille[i][j] == 1) {
ChoisirCouleurDessin(CouleurParNom("blue"));
RemplirRectangle(x + 5, y + 5, tailleCase - 10, tailleCase - 10);
} else if (etatJeu.grille[i][j] == 2) {
ChoisirCouleurDessin(CouleurParNom("red"));
RemplirRectangle(x + 5, y + 5, tailleCase - 10, tailleCase - 10);
} else if (etatJeu.grille[i][j] == 3) {
ChoisirCouleurDessin(CouleurParNom("black"));
RemplirRectangle(x + 5, y + 5, tailleCase - 10, tailleCase - 10);
}
}
}
}
/* Fonction qui affiche le gagnant de la partie */
void afficherVictoire(int gagnant) {
int continuer = 1;
char message[100];
int mouseX, mouseY;
int xStartNouveau = 200, yStartNouveau = 400, largeur = 200, hauteur = 50;
int xStartQuitter = 400, yStartQuitter = 400;
EffacerEcran(CouleurParNom("white"));
ChoisirCouleurDessin(CouleurParNom("black"));
sprintf(message, "Le joueur %d remporte la partie !", gagnant);
EcrireTexte(250, 300, message, 2);
EcrireTexte(100,500, "Cliquez sur 'New Party' pour recommencer ou 'Quitter' pour quitter.", 1);
ChoisirCouleurDessin(CouleurParNom("blue"));
RemplirRectangle(xStartNouveau, yStartNouveau, largeur, hauteur);
ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(xStartNouveau + 5, yStartNouveau + 30, "New Party", 2);
ChoisirCouleurDessin(CouleurParNom("red"));
RemplirRectangle(xStartQuitter, yStartQuitter, largeur, hauteur);
ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(xStartQuitter + 90, yStartQuitter + 30, "Quitter", 2);
while (continuer) {
if (SourisCliquee()) {
mouseX = _X;
mouseY = _Y;
if (mouseX >= xStartNouveau && mouseX <= xStartNouveau + largeur && mouseY >= yStartNouveau && mouseY <= yStartNouveau + hauteur) {
continuer = 0;
return;
}
if (mouseX >= xStartQuitter && mouseX <= xStartQuitter + largeur && mouseY >= yStartQuitter && mouseY <= yStartQuitter + hauteur) {
continuer = 0;
exit(EXIT_SUCCESS);
}
}
}
}
/* Fonction qui vérifie si le joueur a gagné la partie */
int verifierVictoire(struct EtatJeu etatJeu) {
if (etatJeu.phase == 0) {
return EXIT_FAILURE;
}
if (!peutDeplacer(etatJeu, etatJeu.tourJoueur)) {
return etatJeu.tourJoueur == 1 ? 2 : 1;
return 2;
}
return EXIT_FAILURE;
}

146
src/jeu_humain.c
View File

@@ -1,146 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <graph.h>
#include <time.h>
#include "../include/jeu.h"
#include "../include/jeu_humain.h"
void attendre(int secondes) {
time_t start_time = time(NULL);
while(difftime(time(NULL), start_time) < secondes) {
break;
}
}
void jouerModeHumain(struct EtatJeu *etatJeu) {
while (1) {
if (SourisCliquee()) {
if (etatJeu->phase == 0) {
gererPlacementInitial(etatJeu);
} else {
gererTourJoueur(etatJeu);
}
if (etatJeu->phase > 0 && !peutDeplacer(*etatJeu, etatJeu->tourJoueur)) {
afficherVictoire(etatJeu->tourJoueur == 1 ? 2 : 1);
while (!SourisCliquee()) {
attendre(1);
}
break;
}
}
attendre(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;
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;
if (i >= 0 && i < etatJeu->tailleGrille &&
j >= 0 && j < etatJeu->tailleGrille &&
etatJeu->grille[i][j] == 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;
}
if (etatJeu->tourJoueur == 2) {
etatJeu->phase = 1;
etatJeu->tourJoueur = 1;
} else {
etatJeu->tourJoueur = 2;
}
dessinerGrille(*etatJeu);
}
}
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);
}
}
}
}

205
src/jeu_ia.c
View File

@@ -1,205 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <graph.h>
#include <time.h>
#include "../include/jeu.h"
#include "../include/jeu_ia.h"
#include "../include/jeu_humain.h" /* Pour utiliser la fonction attendre */
/* 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()) {
if (etatJeu->phase == 0) {
gererPlacementInitialIA(etatJeu);
} else {
gererTourJoueurIA(etatJeu);
}
}
} else {
attendre(1);
if (etatJeu->phase == 0) {
placementIA(etatJeu);
} else if (etatJeu->phase == 1) {
deplacementIA(etatJeu);
} else {
blocageIA(etatJeu);
}
}
/* Vérifie si le joueur a gagné la partie */
if (etatJeu->phase > 0) {
gagnant = verifierVictoire(*etatJeu);
if (gagnant != 0) {
afficherVictoire(gagnant);
while (!SourisCliquee()) {
attendre(1);
}
break;
}
}
attendre(1);
}
}
/* Fonction qui gère le placement initial de l'IA */
void gererPlacementInitialIA(struct EtatJeu *etatJeu) {
int x, y, i, j;
int largeurFenetre = 800;
int hauteurFenetre = 600;
int marge = 50;
int tailleCase;
int startX, startY;
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;
x -= startX;
y -= startY;
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) {
etatJeu->grille[i][j] = 1;
etatJeu->joueur1.x = j;
etatJeu->joueur1.y = i;
etatJeu->tourJoueur = 2;
dessinerGrille(*etatJeu);
}
}
/* Fonction qui gère le tour de l'IA */
void gererTourJoueurIA(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;
/* 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;
x -= startX;
y -= startY;
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)) {
etatJeu->grille[etatJeu->joueur1.y][etatJeu->joueur1.x] = 0;
etatJeu->grille[i][j] = 1;
etatJeu->joueur1.x = j;
etatJeu->joueur1.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 = 2;
dessinerGrille(*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;
} while (etatJeu->grille[i][j] != 0);
etatJeu->grille[i][j] = 2;
etatJeu->joueur2.x = j;
etatJeu->joueur2.y = i;
etatJeu->phase = 1;
etatJeu->tourJoueur = 1;
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;
newX = etatJeu->joueur2.x + dx;
newY = etatJeu->joueur2.y + dy;
if(newX >= 0 && newX < etatJeu->tailleGrille &&
newY >= 0 && newY < etatJeu->tailleGrille &&
etatJeu->grille[newY][newX] == 0) {
etatJeu->grille[etatJeu->joueur2.y][etatJeu->joueur2.x] = 0;
etatJeu->grille[newY][newX] = 2;
etatJeu->joueur2.x = newX;
etatJeu->joueur2.y = newY;
etatJeu->phase = 2;
trouve = 1;
}
}
}
dessinerGrille(*etatJeu);
}
/* Fonction qui permet à l'IA de placer un pion de blocage */
void blocageIA(struct EtatJeu *etatJeu) {
int i, j;
do {
i = rand() % etatJeu->tailleGrille;
j = rand() % etatJeu->tailleGrille;
} while (etatJeu->grille[i][j] != 0);
etatJeu->grille[i][j] = 3;
etatJeu->phase = 1;
etatJeu->tourJoueur = 1;
dessinerGrille(*etatJeu);
}

95
src/main.c
View File

@@ -1,95 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <graph.h>
#include <time.h>
#include "../include/jeu.h"
#include "../include/jeu_humain.h"
#include "../include/jeu_ia.h"
/* fonction qui gère tout le menu du jeu avec les boutons et tout */
void menuPrincipale() {
int tailleGrille = 3;
int continuer = 1;
char tailleStr[4];
int besoinRedessiner = 1;
struct EtatJeu etatJeu;
InitialiserGraphique();
CreerFenetre(100, 100, 800, 600);
ChoisirTitreFenetre("Blocus");
while (continuer) {
if (besoinRedessiner) {
EffacerEcran(CouleurParNom("white"));
ChoisirCouleurDessin(CouleurParNom("black"));
EcrireTexte(290, 50, "Jeu du Blocus", 2);
EcrireTexte(250, 130, "Taille de la grille:", 1);
sprintf(tailleStr, "%d", tailleGrille);
EcrireTexte(450, 130, tailleStr, 1);
RemplirRectangle(500, 110, 30, 30);
RemplirRectangle(540, 110, 30, 30);
ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(510, 125, "+", 1);
EcrireTexte(550, 125, "-", 1);
ChoisirCouleurDessin(CouleurParNom("black"));
RemplirRectangle(250, 190, 300, 50);
RemplirRectangle(250, 260, 300, 50);
ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(280, 215, "1 Joueur (contre IA)", 1);
EcrireTexte(280, 285, "2 Joueurs", 1);
ChoisirCouleurDessin(CouleurParNom("black"));
RemplirRectangle(250, 330, 300, 50);
ChoisirCouleurDessin(CouleurParNom("white"));
EcrireTexte(280, 355, "Quitter", 1);
besoinRedessiner = 0;
}
if (SourisCliquee()) {
int mouseX = _X;
int mouseY = _Y;
if (mouseX >= 500 && mouseX <= 530 && mouseY >= 110 && mouseY <= 140) {
if (tailleGrille < 9) {
tailleGrille++;
besoinRedessiner = 1;
}
} else if (mouseX >= 540 && mouseX <= 570 && mouseY >= 110 && mouseY <= 140) {
if (tailleGrille > 3) {
tailleGrille--;
besoinRedessiner = 1;
}
} else if (mouseX >= 250 && mouseX <= 600) {
if ((mouseY >= 180 && mouseY <= 230) || (mouseY >= 250 && mouseY <= 300)) {
int mode = (mouseY >= 180 && mouseY <= 230) ? 1 : 2;
etatJeu = initialiserJeu(tailleGrille, mode);
EffacerEcran(CouleurParNom("white"));
dessinerGrille(etatJeu);
if (mode == 1) {
jouerModeIA(&etatJeu);
} else {
jouerModeHumain(&etatJeu);
}
besoinRedessiner = 1;
} else if (mouseY >= 320 && mouseY <= 370) {
continuer = 0;
}
}
}
attendre(10);
}
FermerGraphique();
}
int main(void) {
srand((unsigned int)time(NULL));
menuPrincipale();
return EXIT_FAILURE;
}