ok

Case.java

@@ -153,14 +153,14 @@ public class Case extends JComponent{
   					//autrement nous afficherons l'image de la bombe
     			}else{
     				Image imgboombe= Toolkit.getDefaultToolkit().getImage("./IMAGE/bombe.png");
-    				//si la suspition est de 4 (possible que si c'est la bombe qui a exploser)
+    				//si la suspition est de 4 (possible que si c'est la bombe qui a exploser) valeur sentinelle
     				if(this.suspition==4){
     					//on dessine un rectangle rouge
     					secondPinceau.setColor(new Color(255,0,0));
     					secondPinceau.fillRect(this.getWidth()/20, this.getHeight()/20, this.getWidth()/20*18, this.getHeight()/20*18);
     				}else{
-    					//on dessine un rectangle orange pour montrer que la case étais miner
+    					//on dessine un rectangle orange pour montrer que la case était une bombe
-    					secondPinceau.setColor(new Color(255, 127, 0));
+    					secondPinceau.setColor(new Color(200, 127, 0));
     					secondPinceau.fillRect(this.getWidth()/20, this.getHeight()/20, this.getWidth()/20*18, this.getHeight()/20*18);
     				}
     				//on affiche la bombe

Makefile

@@ -14,7 +14,7 @@ OFILES= Case.class\
 		paintChoix.class\
 		observateurChoix.class\
 		plusoumoins.class\
-		bombeEtValider.class
+		observateurButtonEtText.class
 
 CFLAGS= -implicit:none
 
@@ -51,8 +51,8 @@ observateurChoix.class: observateurChoix.java
 plusoumoins.class: plusoumoins.java
 	javac $(CFLAGS) plusoumoins.java
 
-bombeEtValider.class: bombeEtValider.java
+observateurButtonEtText.class: observateurButtonEtText.java
-	javac $(CFLAGS) bombeEtValider.java
+	javac $(CFLAGS) observateurButtonEtText.java
 
 #Chapitre 5: nettoyage des fichiers generes
 

main_ex.java

@@ -3,14 +3,15 @@
 // Classe ayant pour but d'être executer
 
 //importons les packages necessaires
-import java.awt.*;
 import javax.swing.*;
 
 public class main_ex{
 	public static void main(String[] Args){
 		// on initialise une fenettre
 		JFrame fenetre = new JFrame("Démineur");
+		//on créé notre plateau de jeu
 		plateau jeu = new plateau(fenetre);
+		//on lance a l'aide de celui-ci le 1er menu
 		jeu.menuChoixTypePartie();
 	}
 }

observateurButtonEtText.java

@@ -0,0 +1,64 @@
+//Clément Martins et Tom Monin
+//Class utiliser pour observateur avec plusieur action ossible (en fonction de sa fonction défini a la création) 
+import java.awt.event.*;
+import javax.swing.*;
+import java.awt.*;
+import java.io.*;
+
+public class observateurButtonEtText implements ActionListener {
+  private plateau plat;
+  private int fonction;
+  private JTextField zone;
+  public observateurButtonEtText(plateau plat0, int fonction0, JTextField zone0){
+    this.plat=plat0;
+    this.fonction=fonction0;
+    this.zone=zone0;
+  }
+  @Override
+  public void actionPerformed(ActionEvent evenement){
+    if(this.fonction==1){
+      int nombre=0;
+      try{
+        this.zone.setBackground(new Color(255,255,255));
+        nombre=Integer.parseInt(evenement.getActionCommand());
+        if(nombre<0){
+          nombre=0;
+        }
+        if(this.plat.getLigne()!=-1 && this.plat.getCollonne()!=-1){
+          if(nombre>this.plat.getLigne()*this.plat.getCollonne()){
+            nombre=this.plat.getLigne()*this.plat.getCollonne();
+          }
+          this.zone.setText(String.valueOf(nombre));
+        }else{
+          this.zone.setBackground(Color.red);
+          this.zone.setText("Selectionner Ligne et Collonne Avant");
+          this.plat.setBombe(-1);
+        }
+        this.plat.setBombe(nombre);
+      }catch(NumberFormatException e1){
+        this.zone.setBackground(Color.red);
+        this.zone.setText("rentrer un nombre valide");
+        this.plat.setBombe(-1);
+      }
+    }
+    if(this.fonction==2){
+      if(this.plat.getLigne()!=-1 && this.plat.getLigne()!=-1 && this.plat.getBombe()!=-1){
+        this.plat.newGame();
+      }
+    }
+    if(this.fonction==3){
+      this.plat.menuChoixLCB();
+    }
+    if(this.fonction==4){
+      try{
+        FileInputStream fichier = new FileInputStream("./sauvegarde.data");
+        this.plat.reprendrePartie(fichier);
+      }catch(FileNotFoundException e1){
+
+      }
+    }
+    if(this.fonction==5){
+      this.plat.getFenetre().dispose();
+    }
+  }
+}

observateurCase.java

@@ -50,21 +50,9 @@ public class observateurCase implements MouseListener{
 		if(plat.etatDeVictoire()==-1){
 			//on precise quelle case a exploser
 			this.tableau[this.ligne][this.collonne].setSuspition(4);
-			plateau.removeListener(this.tableau);
-			for(int i=0;i<this.tableau.length;i++){
-				for(int t=0;t<this.tableau[i].length;t++){
-					this.tableau[i][t].setVisibiliter(true);
-					this.tableau[i][t].repaint();
-				}
-			}
-			plat.perdu();
-			plat.paintLogo();
 		}
 		//si gagner
 		if(plat.etatDeVictoire()==1){
-			plateau.removeListener(this.tableau);
-			plat.gagner();
-			plat.paintLogo();
 		}
 	}
 	@Override          // un bouton cliqué

plateau.java

@@ -138,6 +138,9 @@ public class plateau{
 				}
 				//si une bombe est visible
 				if(this.tableau[i][t].getVisibiliter()==true && this.tableau[i][t].getBombe()==true){
+					// le joueur a perdu
+					this.removeListener();
+					this.perdu();
 					//on retourne une valeur représentant la défaite: -1
 					return -1;
 				}
@@ -153,47 +156,73 @@ public class plateau{
 			//on retourne 0 ici comme une valleur null
 			return 0;
 		}
+		// le joueur a gagner
+		this.removeListener();
+		this.gagner();
 		//sinon le joueur a donc gagner on renvoie 1
 		return 1;
 	}
 	//-----------------------------------Fonction après victoire/defaite pour enlever les observateur a chaque Case--------------------------------
 
-	public static void removeListener(Case[][] tableau0){
+	private void removeListener(){
 		//on parcour le tableau du jeu
-		for(int i=0; i<tableau0.length; i++){
+		for(int i=0; i<this.tableau.length; i++){
-			for(int t=0; t<tableau0[i].length; t++){
+			for(int t=0; t<this.tableau[i].length; t++){
 				//on récupere le tableau d'observateur
 				MouseListener[] tabListener;
-				tabListener=tableau0[i][t].getMouseListeners();
+				tabListener=this.tableau[i][t].getMouseListeners();
 				//que nous parcourons
 				for(int longeur=0; longeur<=tabListener.length-1; longeur++){
 					//on enleve a chaque case les observateur 1 par 1
-					tableau0[i][t].removeMouseListener(tabListener[longeur]);
+					this.tableau[i][t].removeMouseListener(tabListener[longeur]);
 				}	
 			}
 		}
 	}
-	public void perdu(){
+	//-------------------------------------Fonction des modification a faire si le joeur a perdu-------------------------------------
+	private void perdu(){
+		//on modifie l'affichage du menu du haut par le choix 5(tete rouge)
 		for(int i=0; i<tabScore.length; i++){
 			this.tabScore[i].setChoix(5);
 		}
+		//puis nous affichons toutes les case pour que le joueur puisse voir la grille
+		for(int i=0;i<this.tableau.length;i++){
+			for(int t=0;t<this.tableau[i].length;t++){
+				this.tableau[i][t].setVisibiliter(true);
+				this.tableau[i][t].repaint();
 			}
-	public void gagner(){
+		}
+		//enfin nous affichons le logo rejouer
+		this.paintLogo();
+	}
+	//-------------------------------------Fonction des modification a faire si le joeur a gagner-------------------------------------
+	private void gagner(){
+		//on modifie l'affichage du menu du haut par le choix 6(tete vert)
 		for(int i=0; i<tabScore.length; i++){
 			this.tabScore[i].setChoix(6);
 		}
+		//nous affichons le logo rejouer
+		this.paintLogo();
 	}
+	//-------------------------------------Fonction pour modifier le Score des bombes restantes--------------------------------------
 	public void setScore(int n){
+		//on parcoure le menu du haut avec le score et nous lui ajoutons l'entier entrée dans l'apel
 		for(int i=0; i<tabScore.length; i++){
 			tabScore[i].setScore(tabScore[i].getScore()+n);
 		}
 	}
-	public void paintLogo(){
+	//------------------------------------> Fonction pour afficher le logo rejouer <----------------------------
+	private void paintLogo(){
+		//on modifie l'aspect de l'ancien logo
 		this.logo.setChoix(7);
+		//et la fonction de son observateur
 		this.observateur.setFonction(true);
 	}
 
+	//------------------------------------> Fonction pour lancer une nouvelle partie <-----------------------
+
 	public void newGame(){
+		//initialisation du tableau de Case
 		this.tableau=new Case[ligne][collonne];
 		for(int i=0; i<ligne; i++){
 			for(int t=0; t<collonne; t++){
@@ -206,67 +235,91 @@ public class plateau{
 		this.setAllBombe();
 		//maitenant que les bombe sont mise nous pouvons modifier le nombre de voisin des cases
 		this.setAllVoisin();
+		//on lance la partie avec le tableau de Case initialiser et le nombre de bombe en score(aucune Case n'est encore suspecter)
 		this.launchGame(this.bombe);
 	}
 
+	//------------------------------------> Fonction pour sauvegarder la partie <-------------------------
+
 	public void save(){
+		//les fonctions vont lever des Exeption nous devons donc mettre un try Catch
 		try{
+			//nous initialison le outputStream en créant le fichier "sauvegarde.data"
 			FileOutputStream sav = new FileOutputStream(new File("sauvegarde.data"));
+			//nous allons sérialiser le tableau de Case
       		ObjectOutputStream oos = new ObjectOutputStream(sav);
+      		//nous écrivons donc tout d'abord la taille de celui-ci
 			oos.writeInt(this.ligne);
 			oos.writeInt(this.collonne);
+			//puis nous parcourons le tableau en sérialisant toute les Case
 			for(int i=0; i<this.ligne; i++){
 				for(int t=0; t<this.collonne; t++){
 					oos.writeObject(this.tableau[i][t]);
 				}
 			}
+			//nous écrivons ensuite le score Maximum(nombre de bombe) pour éviter de regarder toutes les Case plus tard
 			oos.writeInt(this.tabScore[0].getScoreMax());
+			//puis le score a l'instant T
 			oos.writeInt(this.tabScore[0].getScore());
+			//nous fermons la sauvegardes
 			oos.close();
 			sav.close();
 		}catch(FileNotFoundException e1){
 		}catch(IOException e2){
 		}
+		//nous fermons la fenetre et donc arrêtons l'applications
 		this.fenetre.dispose();
 		
 	}
-	public void reprendrePartie(){
+	public void reprendrePartie(FileInputStream file){
+		//initialisation de la variable score
 		int score=0;
+		//les fonctions vont lever des Exeption nous devons donc mettre un try Catch
 		try{
-			FileInputStream file = new FileInputStream("./sauvegarde.data");
+			//création de l'objet pour lire le fichier donner
       		ObjectInputStream ois = new ObjectInputStream(file);
+      		//initialisation des collonnes avec le fichier
 			this.ligne=ois.readInt();
 			this.collonne=ois.readInt();
+			//on crée le tableau de Case avec les bonnes dimention
 			this.tableau=new Case[this.ligne][this.collonne];
+			//on parcoure celui-ci et remettons les Case avec la sauvegarde
 			for(int i=0; i<ligne; i++){
 				for(int t=0; t<collonne; t++){
 					this.tableau[i][t]=(Case) ois.readObject();
 				}
 			}
+			//nous initialison maintenant le nombre de bombe
 			this.bombe=ois.readInt();
+			//puis le score
 			score=ois.readInt();
-		}catch(FileNotFoundException e1){
-			System.out.println("FNF");
 		}catch(IOException e2){
-			System.out.println("IOE");
 		}catch(ClassNotFoundException e3){
-			System.out.println("CNF");
 		}
+		//nous pouvons maintenant lancer la partie sauvegarder
 		this.launchGame(score);
-		
 	}
+	//----------------------------------------> Fonction pour Lancer une partie <--------------------------------------
+
 	private void launchGame(int score){
+		//on ferme l'ancienne fenetre
 		this.fenetre.dispose();
+		//on en crée une nouvelles
 		this.fenetre=new JFrame("démineur");
-		// l'application ne se fermera que si on clique sur 
+		// l'application se fermera que si on ferme la fenetre
-		fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		this.fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-		fenetre.setVisible(true);
+		//on l'affiche
-		fenetre.addWindowListener(new observateurFenetre(this));
+		this.fenetre.setVisible(true);
-		GridLayout grille = new GridLayout(this.ligne+1,this.collonne);
+		//on ajoute son observateur (pour savegarder la partie si on ferme la fenetre)
-		fenetre.setLayout(grille);
+		this.fenetre.addWindowListener(new observateurFenetre(this));
+		//on met un gestionaires de mise en page grille avec le nombre de ligne+1 (pour le menu en haut) et le nombre de collonne
+		this.fenetre.setLayout(new GridLayout(this.ligne+1,this.collonne));
+		//on met en place le menu du haut et donc toute la première ligne
 		for(int i=0; i<collonne; i++){
 			paintMenuJeu menu= new paintMenuJeu(0, score, bombe);
+			//nous mettons des dimensions convenable pour des Case
 			menu.setPreferredSize(new Dimension(100,100));
+			//les 3 premières case serons consacrés au score
 			if(i==0){
 				this.tabScore[0]=menu;
 				menu.setChoix(1);
@@ -279,6 +332,7 @@ public class plateau{
 				this.tabScore[2]=menu;
 				menu.setChoix(3);
 			}
+			//et la derniere au logo
 			if(i==collonne-1){
 				menu.setChoix(4);
 				this.setLogo(menu);
@@ -286,98 +340,134 @@ public class plateau{
 				menu.addMouseListener(observateur);
 				this.setObservateur(observateur);
 			}
+			//sinon le composant sera juste sobre
 			fenetre.add(menu);
 		}
+		//on ajoute ensuite toutes les Case a la fenetre
 		for(int i=0; i<ligne; i++){
 			for(int t=0;t<collonne; t++){
 				this.fenetre.add(this.tableau[i][t]);
 				this.tableau[i][t].addMouseListener(new observateurCase(i, t, this.tableau, this));
 			}
 		}
+		//on ajuste la taille de la fenetre a son contenu
 		this.fenetre.pack();
 	}
+	//---------------------> Fonction d'affichage du menu pour le Choix des Ligne, Collonne et Bombe <-----------------------------
 	public void menuChoixLCB(){
+		//nous fermons l'ancienne fenetre
 		this.fenetre.dispose();
+		//créons une nouvelle
 		this.fenetre= new JFrame("démineur");
 		this.fenetre.setLocation(0,0);
 		this.fenetre.setVisible(true);
 		this.fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-		GridLayout grille = new GridLayout(27,3);
+		//nous utiliserons un gestionnaires avec 27 ligne(de 4 a 30 ligne/collonne) et 3 collonne
-		fenetre.setLayout(grille);
+		fenetre.setLayout(new GridLayout(27,3));
+		//initialisation des objet utiliser par des observateur plus tard
 		paintChoix retenue= new paintChoix(-1, -1);
 		paintChoix premier= new paintChoix(-1, -1);
 		paintChoix retenue2= new paintChoix(-1, -1);
 		paintChoix premier2= new paintChoix(-1, -1);
 		JLabel texte1 = new JLabel("ligne: ???");
 		JLabel texte2 = new JLabel("collonne: ???");
+		//aligment Central plus estetique
 		texte1.setHorizontalAlignment(JLabel.CENTER);
 		texte2.setHorizontalAlignment(JLabel.CENTER);
 		JTextField nbombe = new JTextField("0");
+		//nous ajoutons les Case
 		for(int i=0; i<27; i++){
+			//creons les composant
 			paintChoix pinceau = new paintChoix(i, 1);
 			paintChoix pinceau2 = new paintChoix(i, 2);
-			pinceau.setPreferredSize(new Dimension(500,100));
+			pinceau.setPreferredSize(new Dimension(700,100));
 			pinceau2.setPreferredSize(new Dimension(500, 100));
 			if(i==0){
+				//si c'est la première Case alors ça sera la première pour sa ligne
 				premier=pinceau;
 				premier2=pinceau2;
 			}
+			//nous leurs ajoutons un observateur
 			pinceau.addMouseListener(new observateurChoix(pinceau, premier, texte1, this));
 			pinceau2.addMouseListener(new observateurChoix(pinceau2, premier2, texte2, this));
+			//positionons la retenue sur le nouveau pinceau
 			retenue.setPaintChoix(pinceau);
 			retenue=pinceau;
 			retenue2.setPaintChoix(pinceau2);
 			retenue2=pinceau2;
+			//nous ajoutons la première case sur la collonne 1
 			this.fenetre.add(pinceau);
+			//la dexième collonne dependra de sa hauteur dans la ligne
 			if(i==10){
+				//texte sur les lignes
 				this.fenetre.add(texte1);
 			}
 			if(i==12){
+				//texte sur les collonnes
 				this.fenetre.add(texte2);
-			}if(i!=10 && i!=12 && i!=26 && i!=17 && i!=18 && i!=19 && i!=16){
-				this.fenetre.add(new JLabel());
 			}if(i==26){
+				//si c'est la dernière ligne, boutons valider
 				JButton valider = new JButton("valider");
-				valider.addActionListener(new bombeEtValider(this, 2, nbombe));
+				valider.addActionListener(new observateurButtonEtText(this, 2, nbombe));
 				this.fenetre.add(valider);
 			}if(i==17){
+				//boutons plus
 				JButton plus = new JButton("+");
 				plus.addActionListener(new plusoumoins(nbombe, 1, this));
 				this.fenetre.add(plus);
 			}if(i==18){
+				//texteArea qui représente le nombre de bombe
 				nbombe.setHorizontalAlignment(JLabel.CENTER);
-				nbombe.addActionListener(new bombeEtValider(this, 1, nbombe));
+				nbombe.addActionListener(new observateurButtonEtText(this, 1, nbombe));
 				this.fenetre.add(nbombe);
 			}if(i==19){
+				//boutons moins
 				JButton moins = new JButton("-");
 				moins.addActionListener(new plusoumoins(nbombe, -1, this));
 				this.fenetre.add(moins);
 			}if(i==16){
+				//juste le texte
 				JLabel texte3 = new JLabel("Nombre de Bombe");
 				texte3.setHorizontalAlignment(JLabel.CENTER);
 				this.fenetre.add(texte3);
+			}if(i!=10 && i!=12 && i!=26 && i!=17 && i!=18 && i!=19 && i!=16){
+				//autrement nous ajoutons un composant inutile
+				this.fenetre.add(new JLabel());
 			}
+			//enfin nous ajoutons sur la 3ième collonne le 2ième paintChoix
 			this.fenetre.add(pinceau2);
 		}
+		//nous ajustons la fenetre a la taille de son contenue volontairement grand qui poussera sûrment un plein ecran (2700x2100)
 		this.fenetre.pack();
 	}
+	//-----------------------------------------> Fonction pour l'affichage du premier menu (nouvelle partie/reprendrePartie/quitter) <---------------------
 	public void menuChoixTypePartie(){
+		//nous créons une nouvelles fenetre
 		this.fenetre.dispose();
 		this.fenetre= new JFrame("démineur");
 		this.fenetre.setLocation(0,0);
 		this.fenetre.setVisible(true);
-		this.fenetre.setSize(1000, 500);
 		this.fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-		JPanel pan = new JPanel();
+		this.fenetre.setLayout(new FlowLayout());
+		JPanel pan1 = new JPanel();
+		JPanel pan2 = new JPanel();
+		JPanel pan3 = new JPanel();
 		JButton nouveau = new JButton("nouvelle partie");
 		JButton reprende = new JButton("reprendrePartie");
 		JButton quitter = new JButton("quitter");
-		nouveau.addActionListener(new bombeEtValider(this, 3, null));
+		nouveau.addActionListener(new observateurButtonEtText(this, 3, null));
-		reprende.addActionListener(new bombeEtValider(this, 4, null));
+		reprende.addActionListener(new observateurButtonEtText(this, 4, null));
-		quitter.addActionListener(new bombeEtValider(this, 5, null));
+		quitter.addActionListener(new observateurButtonEtText(this, 5, null));
-		pan.add(nouveau);
+		pan1.add(nouveau);
-		pan.add(reprende);
+		pan2.add(reprende);
-		pan.add(quitter);
+		pan3.add(quitter);
-		this.fenetre.add(pan, BorderLayout.CENTER);
+		pan1.setPreferredSize(new Dimension(800, 800));
+		pan2.setPreferredSize(new Dimension(800, 800));
+		pan3.setPreferredSize(new Dimension(800, 800));
+		this.fenetre.add(pan1);
+		this.fenetre.add(pan2);
+		this.fenetre.add(pan3);
+		this.fenetre.pack();
+		//nous ajustons la fenetre a la taille de son contenue volontairement grand qui poussera sûrment un plein ecran (2000x2000)
 	}
 }