diff --git a/Case.java b/Case.java
index e89fb1c..8b99cd3 100644
--- a/Case.java
+++ b/Case.java
@@ -2,49 +2,64 @@ import javax.swing.*;
 import java.awt.*;
 
 public class Case extends JPanel {
+	//	Definition d'attributs
 	private Dimension caseSize;
 	private int entourage;
 	private boolean visible;
 	private boolean minee;
-	private Listener listener;
+	private ListenerCase listener;
 
-	public Case(Dimension caseSize, boolean minee, int entourage) {
+	//	Définition du constructeur
+	public Case(Dimension caseSize) {
 		super();
-		this.entourage=entourage;
-		this.visible=false;
-		this.minee=minee;
+		this.visible=false;		//	Par défaut la case est cachée
 		this.caseSize= caseSize;
-				
 		this.setSize(caseSize);
 		
-		this.listener = new Listener();
+		//	On place un listener sur notre case pour qu'elle réagisse aux clicks du joueur
+		this.listener = new ListenerCase();
 		this.addMouseListener(this.listener);
 		
+		//	Mise en page de la page et couleur par défaut
 		GridLayout unique = new GridLayout(1,1);
 		this.setLayout(unique);
 		this.setBackground(new Color(70, 70, 70));
 	}
 
+	//	Méthode qui permet de montrer la case
 	public void setVisible(){
 		this.visible=true;
+		
+		// On affiche une mine si la case est minée, sinon le nombre de mines autour d'elle
 		if (this.minee == true) {
 			this.setBackground(new Color(236, 0, 140));	
 		} else {
 			this.setBackground(new Color(80, 80, 80));
 			if (this.entourage>0){
-				this.add(new Chiffre(entourage,caseSize));
+				this.add(new Entourage(this.entourage,caseSize));
 			}
 		}
+		//	Mise à jour de l'affichage de la case
 		this.updateUI();
 	}
 
+	//	Méthode permettant de savoir si la case est cachée ou visible
 	public boolean getVisible(){
 		return this.visible;
 	}
 
-	
+	//	Mathode pour déclarer la présence d'une mine sur une case
+	public void setMine(){
+		this.minee=true;
+	}
 
+	// Permet de savoir si une case est minée
 	public boolean getMine(){
 		return this.minee;
 	}
+
+	//	Défini combien de mines entourent la case
+	public void setEntourage(int entourage){
+		this.entourage=entourage;
+	}
 }
diff --git a/Doute.java b/Doute.java
new file mode 100644
index 0000000..d090373
--- /dev/null
+++ b/Doute.java
@@ -0,0 +1,18 @@
+import javax.swing.JComponent;
+import java.awt.*;
+ 
+public class Doute extends JComponent {
+  private Dimension caseSize;
+  public Doute(Dimension caseSize) {
+    super();
+    this.caseSize=caseSize;
+  }
+  @Override
+  protected void paintComponent(Graphics pinceau) {
+    Graphics chiffre = pinceau.create();
+    Font font = new Font("Arial", Font.BOLD, caseSize.width*3/5);
+    chiffre.setFont(font);
+    chiffre.setColor(new Color(236, 0, 140));
+    chiffre.drawString("?",caseSize.width*3/10,caseSize.height*4/5);
+  }
+}
diff --git a/Entourage.java b/Entourage.java
new file mode 100644
index 0000000..0446dac
--- /dev/null
+++ b/Entourage.java
@@ -0,0 +1,21 @@
+import javax.swing.JComponent;
+import java.awt.*;
+ 
+public class Entourage extends JComponent {
+  private int entourage;
+  private Dimension caseSize;
+  public Entourage(int entourage, Dimension caseSize) {
+    super();
+    this.entourage = entourage;
+    this.caseSize=caseSize;
+  }
+  @Override
+  protected void paintComponent(Graphics pinceau) {
+    Graphics chiffre = pinceau.create();
+    Font font = new Font("Arial", Font.BOLD, caseSize.width*2/5);
+    chiffre.setFont(font);
+    Color jaune = new Color(236, 214, 0);
+    chiffre.setColor(jaune);
+    chiffre.drawString(Integer.toString(this.entourage),caseSize.width*2/5,caseSize.height*3/5);
+  }
+}
diff --git a/FrameJeu.java b/FrameJeu.java
index 93faa4c..d9dff05 100644
--- a/FrameJeu.java
+++ b/FrameJeu.java
@@ -11,19 +11,16 @@ public class FrameJeu{
 		// On crée ensuite notre fenêtre avec des valeurs par défaut
 		JFrame fenetre = new JFrame("Démineur - En Jeu");
 	    fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-		
-		// Couleur
-		Color vert = new Color(0, 236, 96);
 
 		//	Mise en page
 		fenetre.setLayout(new GridBagLayout());
 		GridBagConstraints miseEnPage = new GridBagConstraints();
 
 
-		// Création de la bannière (qui sera dans une autre classe)
+		// Création de la bannière (qui sera dans une autre classe plus tard)
 		Dimension grilleSize= grille.getGrilleSize();
 		JPanel banniere= new JPanel();
-		banniere.setBackground(vert);
+		banniere.setBackground( new Color(0, 236, 96);
 		Dimension banniereSize=new Dimension(grilleSize.width,grilleSize.height/8);
 		banniere.setSize(banniereSize);
 
@@ -49,7 +46,6 @@ public class FrameJeu{
 		fenetre.setSize(grilleSize.width,grilleSize.height*9/8);
 		Dimension fenetreSize=fenetre.getSize();
 		fenetre.setLocation(screenSize.width/2-(fenetreSize.width/2), screenSize.height/2-(fenetreSize.height/2));
-		//fenetre.setResizable(false);
 	    fenetre.setVisible(true);
 	}
 }
\ No newline at end of file
diff --git a/Grille.java b/Grille.java
index 0442197..e18b23d 100644
--- a/Grille.java
+++ b/Grille.java
@@ -6,7 +6,7 @@ public class Grille extends JPanel  {
     private Dimension grilleSize=new Dimension(0,0);
 	private Case[] plateau;
 
-    // On crée La grille de jeu
+    // Définition du constructeur qui correspond à une grille de jeu
     public Grille(int lignes, int colonnes, int mines){
 		
 		// Découpage de l'espace en fonction des paramètres pour la mise en place de la grille
@@ -18,7 +18,8 @@ public class Grille extends JPanel  {
         System.out.println("Taille de la Grille : "+grilleSize);
 		this.setLayout(damier);
         this.setSize(grilleSize);
-		this.plateau= new Case[lignes*colonnes];
+		// On génère le plateau contenant les cases
+		GenererPlateau(lignes*colonnes, caseSize);
 
 
 		//	Instalation des mines
@@ -38,241 +39,109 @@ public class Grille extends JPanel  {
 			}
 		}
 
-		//	On place maintenant les mines sur la plateau
-		boolean[] minee = new boolean[lignes*colonnes];
+		//	On place maintenant les mines sur la plateau en fixant la variable minee des cases à true
 		for (int i=0; i<lignes*colonnes;i++){
 			for (int j=0;j<mines;j++){
 				if (caseMine[j]==i){
-					minee[i]=true;
+					plateau[i].setMine();
 				}
 			}
 		}
 
-		//	Connaître le nombre de mines autour de la case
-		int[] entourage = new int[lignes*colonnes];
+		//	On cherche à connaître le nombre de mines autour de chaque case
 		for (int i=0;i<lignes*colonnes;i++){
-			//	Gestion des coins
-			//	Coin supérieur droit 
-			if (i==colonnes-1){
+			int entourage = 0;
+			//  On vérifie pour chaque case qu'elle n'est pas déjà à l'extrémité du plateau où on cherche une case
+			//	Mine au dessus à droite
+			if ((i>colonnes)&&(i%colonnes!=colonnes-1)){
 				for (int j=0;j<mines;j++){
-					// Si une mine est à gauche
-					if (caseMine[j]==i-1){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous
-					if (caseMine[j]==i+colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous à gauche
-					if (caseMine[j]==i+colonnes-1){
-						entourage[i]+=1;
-					}
-				}
-			}
-			//	Coin suppérieur gauche
-			else if (i==0){
-				for (int j=0;j<mines;j++){
-					// Si une mine est à droite
-					if (caseMine[j]==i+1){
-						entourage[i]+=1;
-					}
-					
-					// Si une mine est en dessous
-					if (caseMine[j]==i+colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous à droite
-					if (caseMine[j]==i+colonnes+1){
-						entourage[i]+=1;
-					}
-				}
-			}
-			//	Coin inférieur droit
-			else if (i==lignes*colonnes-1){
-				for (int j=0;j<mines;j++){
-					// Si une mine est à gauche
-					if (caseMine[j]==i-1){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus
-					if (caseMine[j]==i-colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus à gauche
-					if (caseMine[j]==i-colonnes-1){
-						entourage[i]+=1;
-					}
-				}
-			}
-			// Coin inférieur gauche
-			else if (i==lignes*colonnes-colonnes){
-				for (int j=0;j<mines;j++){
-					// Si une mine est à droite
-					if (caseMine[j]==i+1){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus
-					if (caseMine[j]==i-colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus à droite
 					if (caseMine[j]==i-colonnes+1){
-						entourage[i]+=1;
+						entourage+=1;
 					}
 				}
 			}
-			//	Si la mine est tout en haut
-			else if (i<colonnes){
+			//	Mine au dessus à gauche
+			if ((i>colonnes)&&(i%colonnes!=0)){
 				for (int j=0;j<mines;j++){
-					// Si une mine est à droite
-					if (caseMine[j]==i+1){
-						entourage[i]+=1;
-					}
-					// Si une mine est à gauche
-					if (caseMine[j]==i-1){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous
-					if (caseMine[j]==i+colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous à droite
-					if (caseMine[j]==i+colonnes+1){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous à gauche
-					if (caseMine[j]==i+colonnes-1){
-						entourage[i]+=1;
-					}
-				}
-			}
-			//	Si la mine est tout en bas
-			else if (i>lignes*colonnes-colonnes){ // Vérifier la condition
-				for (int j=0;j<mines;j++){
-					// Si une mine est à droite
-					if (caseMine[j]==i+1){
-						entourage[i]+=1;
-					}
-					// Si une mine est à gauche
-					if (caseMine[j]==i-1){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus
-					if (caseMine[j]==i-colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus à droite
-					if (caseMine[j]==i-colonnes+1){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus à gauche
 					if (caseMine[j]==i-colonnes-1){
-						entourage[i]+=1;
+						entourage+=1;
 					}
 				}
 			}
-			//	Si la mine est tout à droite
-			else if (i%colonnes==colonnes-1){
+			//  Mine en dessous à droite
+			if ((i<=lignes*colonnes-colonnes)&&(i%colonnes!=colonnes-1)){
 				for (int j=0;j<mines;j++){
-					// Si une mine est à gauche
-					if (caseMine[j]==i-1){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus
-					if (caseMine[j]==i-colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus à gauche
-					if (caseMine[j]==i-colonnes-1){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous
-					if (caseMine[j]==i+colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous à gauche
-					if (caseMine[j]==i+colonnes-1){
-						entourage[i]+=1;
-					}
-				}
-			}
-			//	Si la mine est tout à gauche
-			else if (i%colonnes==0){
-				for (int j=0;j<mines;j++){
-					// Si une mine est à droite
-					if (caseMine[j]==i+1){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus
-					if (caseMine[j]==i-colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus à droite
-					if (caseMine[j]==i-colonnes+1){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous
-					if (caseMine[j]==i+colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous à droite
 					if (caseMine[j]==i+colonnes+1){
-						entourage[i]+=1;
-					}
-				}
-			} else {
-				for (int j=0;j<mines;j++){
-					// Si une mine est à droite
-					if (caseMine[j]==i+1){
-						entourage[i]+=1;
-					}
-					// Si une mine est à gauche
-					if (caseMine[j]==i-1){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus
-					if (caseMine[j]==i-colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus à droite
-					if (caseMine[j]==i-colonnes+1){
-						entourage[i]+=1;
-					}
-					// Si une mine est au dessus à gauche
-					if (caseMine[j]==i-colonnes-1){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous
-					if (caseMine[j]==i+colonnes){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous à droite
-					if (caseMine[j]==i+colonnes+1){
-						entourage[i]+=1;
-					}
-					// Si une mine est en dessous à gauche
-					if (caseMine[j]==i+colonnes-1){
-						entourage[i]+=1;
+						entourage+=1;
 					}
 				}
 			}
+			//  Mine en bas à gauche
+			if ((i!=lignes*colonnes-colonnes)&&(i%colonnes!=0)){
+				for (int j=0;j<mines;j++){
+					if (caseMine[j]==i+colonnes-1){
+						entourage+=1;
+					}
+				}
+			}
+			//	Mine au dessus
+			if (i>colonnes){
+				for (int j=0;j<mines;j++){
+					if (caseMine[j]==i-colonnes){
+						entourage+=1;
+					}
+				}
+			}
+			//	Mine en dessous
+			if (i<=lignes*colonnes-colonnes){
+				for (int j=0;j<mines;j++){
+					if (caseMine[j]==i+colonnes){
+						entourage+=1;
+					}
+				}
+			}
+			//	Mine à droite
+			if (i%colonnes!=colonnes-1){
+				for (int j=0;j<mines;j++){
+					if (caseMine[j]==i+1){
+						entourage+=1;
+					}
+				}
+			}
+			//	Mine à gauche
+			if (i%colonnes!=0){
+				for (int j=0;j<mines;j++){
+					if (caseMine[j]==i-1){
+						entourage+=1;
+					}
+				}
+			}
+			plateau[i].setEntourage(entourage);
 		}
 
 
 		//	On place les cases à leur état actuel dans la grille
-		AfficherPlateau(lignes*colonnes, caseSize, entourage, minee);
+		AfficherPlateau(lignes*colonnes);
     }
 
-	//	Méthode pour Afficher le plateau
-	protected void AfficherPlateau(int taille, Dimension caseSize, int[] entourage, boolean[] minee){
+	//	Méthode pour Génerer le plateau
+	protected void GenererPlateau(int taille, Dimension caseSize){
+		this.plateau= new Case[taille];
 		for (int i=0;i<taille;i++){
-			this.plateau[i]= new Case(caseSize,minee[i],entourage[i]);
+			this.plateau[i]= new Case(caseSize);
+		}
+	}
+
+	//	Méthode pour Afficher le plateau
+	protected void AfficherPlateau(int taille){
+		for (int i=0;i<taille;i++){
+			this.plateau[i].setVisible();
 			this.add(this.plateau[i]);
   		}
 	}
 
 	//	Méthode pour obtenir la taille de la grille de jeu
-    public Dimension getGrilleSize() {
+    public Dimension getGrilleSize(){
         return grilleSize;
     }
 }
diff --git a/ListenerCase.java b/ListenerCase.java
new file mode 100644
index 0000000..6f72440
--- /dev/null
+++ b/ListenerCase.java
@@ -0,0 +1,51 @@
+import java.awt.event.*;
+import java.awt.*;
+
+public class ListenerCase implements MouseListener{
+	private int marquage=0;
+
+    @Override
+	//	Méthode qui va servir à détecter le click de la souris
+    public void mouseClicked(MouseEvent evenement){
+		Case panel = (Case)evenement.getSource();
+		// 	Si le joueur clique gauche, tant que la case n'est pas marquée, elle sera révélée
+		if ((evenement.getButton() == MouseEvent.BUTTON1)&&(panel.getVisible()==false)&&(this.marquage==0)){
+        	panel.setVisible();
+			if (panel.getMine()==true){
+				System.out.println("Perdu!");
+			}
+		}
+		//	Si le joueur clique droit, la case sera marquée
+		if (evenement.getButton() == MouseEvent.BUTTON3) {
+			// Au premier click, on place une étoile pour indiquer la présence d'une mine
+        	if (this.marquage==0){
+				panel.add(new Etoile(panel.getSize()), BorderLayout.CENTER);
+				this.marquage=1;
+			}
+			//	Au second, on met un point d'interrogation en cas de soupçon pour aider à la réflexion
+			else if (this.marquage==1){
+				panel.removeAll();
+				panel.add(new Doute(panel.getSize()), BorderLayout.CENTER);
+				this.marquage=2;
+			}
+			//	Au troisième click on efface tout marquage
+			else if (this.marquage==2){
+				panel.removeAll();
+				this.marquage=0;
+			}
+			//	On met à jour l'affichage de la case cliquée
+			panel.updateUI();
+		}
+	}
+
+	//	Les autres méthodes de l'interface n'interviennent pas
+	public void mouseEntered(MouseEvent evenement){
+	}         
+	public void mouseExited(MouseEvent evenement){
+	}        
+	public void mousePressed(MouseEvent evenement){
+	}      
+	public void mouseReleased(MouseEvent evenement){
+	}
+
+}