amrouchi/SAE21_2025
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fonctionnalite pour perdre

Browse Source
This commit is contained in:
lecointre
2026-04-07 13:54:01 +02:00
parent dc266ea40f
commit a5d3c87427
2 changed files with 44 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
FenetreJeu.java
+34
View File
@@ -84,4 +84,38 @@ public class FenetreJeu extends JFrame {
}
}
}
/**
* Affiche la grille de fin de partie en cas de défaite, comme demandé dans le sujet.
* @param lExplose la ligne de la mine qui a fait BOUM
* @param cExplose la colonne de la mine qui a fait BOUM
*/
public void afficherDefaite(int lExplose, int cExplose) {
for (int i = 0; i < grille.getLignes(); i++) {
for (int j = 0; j < grille.getColonnes(); j++) {
Case c = grille.getCase(i, j);
JButton btn = boutons[i][j];
// On désactive le bouton pour empêcher de cliquer dessus
btn.setEnabled(false);
// 1. La case dont la mine a "sauté"
if (i == lExplose && j == cExplose) {
btn.setText("BOUM");
btn.setBackground(Color.RED);
}
// 2. Les cases minées non marquées (les bombes oubliées)
else if (c.isMinee() && c.getMarqueur() != 1) {
btn.setText("M");
btn.setBackground(Color.ORANGE);
}
// 3. Les cases marquées non minées (les fausses pistes)
else if (!c.isMinee() && c.getMarqueur() == 1) {
btn.setText("X"); // Un X pour dire "Erreur"
btn.setBackground(Color.YELLOW);
}
// Si la case ne rentre pas dans ces cas, on la laisse tranquille
}
}
}
} // <--- L'accolade finale est bien ici maintenant !
Grille.java
+10 -54
View File
@@ -9,55 +9,42 @@ public class Grille implements Serializable {
private int lignes;
private int colonnes;
private int mines;
private boolean partieTerminee; // <--- LE FAMEUX VERROU !
/**
* Initialise une nouvelle grille et place les mines.
*/
public Grille(int l, int c, int m) {
this.lignes = l;
this.colonnes = c;
this.mines = m;
this.partieTerminee = false;
this.plateau = new Case[this.lignes][this.colonnes];
// 1. Initialisation : on remplit avec des cases vides
for (int i = 0; i < this.lignes; i++) {
for (int j = 0; j < this.colonnes; j++) {
this.plateau[i][j] = new Case();
}
}
// 2. On appelle nos nouvelles méthodes
placerMines();
calculerVoisins();
}
// --- Les Getters ---
// --- Les Getters et Setters ---
public int getLignes() { return this.lignes; }
public int getColonnes() { return this.colonnes; }
public Case getCase(int l, int c) { return this.plateau[l][c]; }
/**
* Permet d'accéder à une case spécifique de la grille.
*/
public Case getCase(int l, int c) {
return this.plateau[l][c];
}
// <--- LES DEUX MÉTHODES QUI TE MANQUAIENT ICI --->
public boolean isPartieTerminee() { return this.partieTerminee; }
public void setPartieTerminee(boolean terminee) { this.partieTerminee = terminee; }
// --- Les algorithmes du jeu ---
/**
* Place les mines aléatoirement dans le tableau.
*/
private void placerMines() {
Random rand = new Random();
int minesPlacees = 0;
// Tant qu'on n'a pas placé toutes les mines demandées...
while (minesPlacees < this.mines) {
int l = rand.nextInt(this.lignes);
int c = rand.nextInt(this.colonnes);
// Si la case n'est pas déjà minée, on y met une mine
if (!this.plateau[l][c].isMinee()) {
this.plateau[l][c].setMinee(true);
minesPlacees++;
@@ -65,25 +52,15 @@ public class Grille implements Serializable {
}
}
/**
* Calcule le nombre de mines autour de chaque case.
*/
private void calculerVoisins() {
for (int i = 0; i < this.lignes; i++) {
for (int j = 0; j < this.colonnes; j++) {
// Si la case elle-même n'est pas une mine
if (!this.plateau[i][j].isMinee()) {
int compteMines = 0;
// On parcourt les 8 cases autour (de -1 à +1 en ligne et colonne)
for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
int voisinI = i + di;
int voisinJ = j + dj;
// On vérifie qu'on ne sort pas du tableau !
// (Pour éviter l'ArrayIndexOutOfBoundsException vu dans ton cours)
if (voisinI >= 0 && voisinI < this.lignes && voisinJ >= 0 && voisinJ < this.colonnes) {
if (this.plateau[voisinI][voisinJ].isMinee()) {
compteMines++;
@@ -91,60 +68,41 @@ public class Grille implements Serializable {
}
}
}
// On enregistre le chiffre dans la case
this.plateau[i][j].setNbMinesVoisines(compteMines);
}
}
}
}
/**
* Révèle une case et déclenche une réaction en chaîne si elle vaut 0.
* C'est l'algorithme récursif principal du jeu !
* @return true si on a cliqué sur une mine (défaite), false sinon.
*/
public boolean revelerCase(int l, int c) {
Case caseCliquee = this.plateau[l][c];
// Conditions d'arrêt : on s'arrête si la case est déjà révélée ou a une étoile
if (caseCliquee.isRevelee() || caseCliquee.getMarqueur() == 1) {
return false;
}
// On révèle la case
caseCliquee.setRevelee(true);
// Si c'est une mine, c'est perdu !
if (caseCliquee.isMinee()) {
return true;
}
// RÉACTION EN CHAÎNE : Si c'est un 0, on révèle les voisins
if (caseCliquee.getNbMinesVoisines() == 0) {
for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
int voisinL = l + di;
int voisinC = c + dj;
// On vérifie qu'on ne sort pas des bords du tableau
if (voisinL >= 0 && voisinL < this.lignes && voisinC >= 0 && voisinC < this.colonnes) {
// LA RÉCURSIVITÉ EST ICI : la fonction s'appelle elle-même
revelerCase(voisinL, voisinC);
}
}
}
}
return false; // Pas de mine explosée
return false;
}
/**
* Vérifie si le joueur a gagné la partie.
* @return true si toutes les cases sans mine sont révélées, false sinon.
*/
public boolean estGagnee() {
int casesRevelees = 0;
// On compte combien de cases le joueur a réussi à révéler
for (int i = 0; i < this.lignes; i++) {
for (int j = 0; j < this.colonnes; j++) {
if (this.plateau[i][j].isRevelee()) {
@@ -152,9 +110,7 @@ public class Grille implements Serializable {
}
}
}
// C'est gagné si le nombre de cases révélées correspond au total des cases vides
int casesVidesTotales = (this.lignes * this.colonnes) - this.mines;
return casesRevelees == casesVidesTotales;
}
}
}