ajout 2eme SAE DEV 1ere année 15,50/20

SAE21_2024/README.md

@@ -0,0 +1,2 @@
+# sameGame
+# sameGame

SAE21_2024/code_source/ControleurSouris.java

@@ -0,0 +1,79 @@
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+
+/**
+ * La classe <code>ControleurSouris</code> gère les clics de souris dans le jeu SameGame.
+ * Elle permet de supprimer un groupe de blocs lorsqu’un clic est effectué,
+ * de mettre à jour le score et de rafraîchir la vue.
+ *
+ * @version 1.9
+ * @author Emmanuel Srivastava-Tiamzon & Wael Atik
+ */
+public class ControleurSouris extends MouseAdapter {
+
+    /** La grille logique du jeu. */
+    private Grille grille;
+
+    /** La vue graphique du jeu. */
+    private JeuBlocs vue;
+
+    /** Le label affichant le score du joueur. */
+    private JLabel labelScore;
+
+    /** Le score du joueur */
+    private Score score;
+
+    /** La fenêtre principale. */
+    private Fenetre fenetre;
+
+    /**
+     * Constructeur du contrôleur souris.
+     *
+     * @param grille la grille du jeu
+     * @param vue la vue graphique contenant les blocs
+     * @param labelScore le label affichant le score
+     * @param fenetre la fenêtre principale du jeu
+     */
+    public ControleurSouris(Grille grille, JeuBlocs vue, JLabel labelScore, Fenetre fenetre) {
+        this.score = new Score();
+        this.grille = grille;
+        this.vue = vue;
+        this.labelScore = labelScore;
+        this.fenetre = fenetre;
+    }
+
+    /**
+     * Méthode appelée lorsqu’un clic est détecté.
+     * Elle supprime le groupe de blocs cliqué (s’il est valide),
+     * met à jour le score et rafraîchit l’affichage.
+     *
+     * @param e l’événement souris
+     */
+    @Override
+    public void mousePressed(MouseEvent e) {
+        int tailleBloc = vue.getTailleBloc();
+        int ligne = e.getY() / tailleBloc;
+        int colonne = e.getX() / tailleBloc;
+        
+        if (ligne >= 0 && ligne < grille.getLignes() && colonne >= 0 && colonne < grille.getColonnes()) {
+            if (grille.estGroupe(ligne, colonne)) {
+                grille.supprimerGroupe(ligne, colonne);
+                labelScore.setText("Score actuel : " + score.getScore() + "  Meilleur score : " + score.getHighestScore());
+                vue.mettreAJourCouleurs();
+                
+                if (grille.jeuFini()) {
+                    fenetre.dispose();
+                    FenetreFin fenetreFin = new FenetreFin(score.getScore());
+                    if (score.getScore() > score.getHighestScore() || score.getHighestScore() == 0) {
+                        score.setHighestScore(score.getScore());
+                    }
+
+                    fenetreFin.setVisible(true);
+                }
+            }
+        }
+    }
+}
+

SAE21_2024/code_source/Fenetre.java

@@ -0,0 +1,78 @@
+/**
+ * La classe <code>Fenetre</code> représente la fenêtre principale du jeu SameGame.
+ * Elle contient l’affichage graphique de la grille, le score, et le contrôleur de la souris.
+ *
+ * @version 1.7
+ * @author Emmanuel Srivastava-Tiamzon & Wael Atik
+ */
+
+ import javax.swing.*;
+ import java.awt.*;
+ 
+ public class Fenetre extends JFrame {
+ 
+     /** Label affichant le score du joueur. */
+     private JLabel labelScore;
+ 
+     /**
+      * Constructeur de la fenêtre principale.
+      * Initialise les composants graphiques du jeu : la grille, la vue, le score et le contrôleur souris.
+      */
+     public Fenetre() {
+         super("SameGame");
+ 
+         Grille grille = new Grille();
+ 
+         int tailleBloc = 50;
+         int largeur = grille.getColonnes() * tailleBloc;
+         int hauteur = grille.getLignes() * tailleBloc;
+ 
+         JeuBlocs vue = new JeuBlocs(grille, largeur, hauteur);
+         this.labelScore = new JLabel("Score : 0");
+         this.labelScore.setHorizontalAlignment(SwingConstants.CENTER);
+         this.labelScore.setFont(new Font("Arial", Font.BOLD, 18));
+ 
+         ControleurSouris controleur = new ControleurSouris(grille, vue, this.labelScore,this);
+         vue.addMouseListener(controleur);
+ 
+         this.setLayout(new BorderLayout());
+         this.add(this.labelScore, BorderLayout.NORTH);
+         this.add(vue, BorderLayout.CENTER);
+ 
+         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+         this.setSize(largeur + 11, hauteur + 61);
+         this.setLocationRelativeTo(null);
+         this.setVisible(true);
+     }
+     /**
+      * Par polymorphisme on crée un nouveau constructeur pour qu'il s'adapte à une grille predefini 
+      */
+     public Fenetre(Grille grille) {
+         super("SameGame");
+ 
+         int tailleBloc = 50;
+         int largeur = grille.getColonnes() * tailleBloc;
+         int hauteur = grille.getLignes() * tailleBloc;
+ 
+         JeuBlocs vue = new JeuBlocs(grille, largeur, hauteur);
+         this.labelScore = new JLabel("Score : 0");
+         this.labelScore.setHorizontalAlignment(SwingConstants.CENTER);
+         this.labelScore.setFont(new Font("Arial", Font.BOLD, 18));
+ 
+         ControleurSouris controleur = new ControleurSouris(grille, vue, this.labelScore,this);
+         vue.addMouseListener(controleur);
+ 
+         this.setLayout(new BorderLayout());
+         this.add(this.labelScore, BorderLayout.NORTH);
+         this.add(vue, BorderLayout.CENTER);
+ 
+         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+         this.setSize(largeur + 11, hauteur + 61);
+         this.setLocationRelativeTo(null);
+         this.setVisible(true);
+     }
+ }
+ 
+ 
+ 
+ 

SAE21_2024/code_source/FenetreDebut.java

@@ -0,0 +1,34 @@
+/**
+ * La classe <code>FenetreDebut</code> représente la fenêtre de démarrage du jeu SameGame.
+ * Elle affiche le menu principal permettant de démarrer une nouvelle partie, charger une partie ou quitter le jeu.
+ *
+ * @version 1.6
+ * @author Emmanuel Srivastava-Tiamzon & Wael Atik
+ */
+
+ import javax.swing.*;
+ import java.awt.*;
+ 
+ public class FenetreDebut extends JFrame {
+ 
+     /**
+      * Constructeur de la fenêtre de démarrage.
+      * Initialise les composants graphiques du menu d’accueil avec une grille vide et un fond personnalisé.
+      */
+     public FenetreDebut() {
+         super("SameGame");
+ 
+         this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+         this.setSize(765, 510);
+         this.setLocationRelativeTo(null);
+ 
+         JPanel imagePanel = new JPanel();
+         imagePanel.setLayout(new GridLayout(1, 1));
+ 
+         Grille grille = new Grille();
+         PaintFenetreDebut paint = new PaintFenetreDebut(grille, this);
+         imagePanel.add(paint);
+         this.add(imagePanel);
+     }
+ }
+ 

SAE21_2024/code_source/FenetreFin.java

@@ -0,0 +1,35 @@
+/**
+ * La classe <code>FenetreFin</code> représente la fenêtre affichée à la fin d'une partie de SameGame.
+ * Elle affiche le score final du joueur et propose deux options : rejouer ou quitter le jeu.
+ *
+ * @version 1.7
+ * @author Emmanuel Srivastava-Tiamzon & Wael Atik
+ */
+
+ import javax.swing.*;
+
+ public class FenetreFin extends JFrame {
+ 
+     /**
+      * Constructeur de la fenêtre de fin de jeu.
+      * Affiche l’écran final avec le score et les boutons "Rejouer" et "Quitter".
+      *
+      * @param score le score final obtenu par le joueur
+      */
+     public FenetreFin(int score) {
+         super("Fin du Jeu");
+ 
+         this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+         this.setSize(765, 510);
+         this.setLocationRelativeTo(null);
+ 
+         PaintFenetreFin paintfenetrefin = new PaintFenetreFin(score);
+         this.add(paintfenetrefin);
+ 
+         MouseFenetreFin mouseListener = new MouseFenetreFin(this);
+         paintfenetrefin.addMouseListener(mouseListener);
+ 
+         this.setVisible(true);
+     }
+ }
+ 

SAE21_2024/code_source/Grille.java

@@ -0,0 +1,207 @@
+import java.util.Random;
+
+/**
+ * La classe <code>Grille</code> représente la logique du jeu SameGame.
+ * Elle gère la création aléatoire des blocs, la détection et suppression de groupes,
+ * l’application de la gravité et le décalage des colonnes.
+ *
+ * @author Emmanuel Srivastava-Tiamzon & Wael ATIK
+ * @version 1.8
+ */
+public class Grille {
+
+    private static final int LIGNES = 10;
+    private static final int COLONNES = 15;
+    private final char[][] grille;
+    private Score score;
+
+    /**
+    * Constructeur : initialise la grille avec des blocs aléatoires.
+    */
+    public Grille() {
+        this.grille = new char[LIGNES][COLONNES];
+        this.score = new Score();
+        this.score.setScore(0);
+        char[] couleurs = {'R', 'V', 'B'};
+        Random rand = new Random();
+
+        for (int i = 0; i < LIGNES; i++) {
+            for (int j = 0; j < COLONNES; j++) {
+                grille[i][j] = couleurs[rand.nextInt(couleurs.length)];
+            }
+        }
+    }
+
+    /** 
+	 * Par polymorphisme on adapte le constructeur pour que l'on puisse jouer avec une grille préféfini.
+	 */
+	public Grille(char[][] grille) {
+		this.grille = grille;
+		this.score = new Score();
+        this.score.setScore(0);
+	}
+
+    /**
+    * Vérifie si un groupe de blocs de même couleur existe à une position donnée.
+    *
+    * @param ligne   ligne de la case
+    * @param colonne colonne de la case
+    * @return true si un groupe valide (taille > 1) existe
+    */
+    public boolean estGroupe(int ligne, int colonne) {
+        char couleur = grille[ligne][colonne];
+        if (couleur == ' ') return false;
+
+        boolean[][] visite = new boolean[LIGNES][COLONNES];
+        return tailleGroupe(ligne, colonne, couleur, visite) > 1;
+    }
+
+    /**
+    * Supprime un groupe de blocs si sa taille est supérieure à 1 et applique la gravité et le décalage.
+    *
+    * @param ligne   ligne de départ
+    * @param colonne colonne de départ
+    */
+    public void supprimerGroupe(int ligne, int colonne) {
+        char couleur = grille[ligne][colonne];
+        if (couleur == ' ') return;
+
+        boolean[][] visite = new boolean[LIGNES][COLONNES];
+        int taille = tailleGroupe(ligne, colonne, couleur, visite);
+
+        if (taille > 1) {
+            this.score.addToScore((taille - 2) * (taille - 2));
+            supprimerRec(ligne, colonne, couleur, new boolean[LIGNES][COLONNES]);
+            appliquerGravite();
+            appliquerDecalageGauche();
+        }
+    }
+
+    /**
+    * Calcule la taille d’un groupe avec un parcours en largeur.
+    */
+    private int tailleGroupe(int i, int j, char couleur, boolean[][] visite) {
+        if (i < 0 || i >= this.LIGNES || j < 0 || j >= this.COLONNES) return 0;
+        if (visite[i][j] || this.grille[i][j] != couleur) return 0;
+
+        visite[i][j] = true;
+        return 1
+        + tailleGroupe(i + 1, j, couleur, visite)
+        + tailleGroupe(i - 1, j, couleur, visite)
+        + tailleGroupe(i, j + 1, couleur, visite)
+        + tailleGroupe(i, j - 1, couleur, visite);
+    }
+
+    /**
+    * Supprime récursivement un groupe avec un parcours en largeur.
+    */
+    private void supprimerRec(int i, int j, char couleur, boolean[][] visite) {
+        if (i < 0 || i >= this.LIGNES || j < 0 || j >= this.COLONNES) return;
+        if (visite[i][j] || this.grille[i][j] != couleur) return;
+
+        visite[i][j] = true;
+        this.grille[i][j] = ' ';
+
+        supprimerRec(i + 1, j, couleur, visite);
+        supprimerRec(i - 1, j, couleur, visite);
+        supprimerRec(i, j + 1, couleur, visite);
+        supprimerRec(i, j - 1, couleur, visite);
+    }
+
+    /**
+    * Applique la gravité : fait tomber les blocs vers le bas.
+    */
+    private void appliquerGravite() {
+        for (int col = 0; col < this.COLONNES; col++) {
+            int ligneVide = this.LIGNES - 1;
+            for (int i = this.LIGNES - 1; i >= 0; i--) {
+                if (this.grille[i][col] != ' ') {
+                    this.grille[ligneVide][col] = this.grille[i][col];
+                    if (ligneVide != i) this.grille[i][col] = ' ';
+                    ligneVide--;
+                }
+            }
+        }
+    }
+
+    /**
+    * Décale les colonnes vers la gauche si elles sont vides.
+    */
+    private void appliquerDecalageGauche() {
+        int colDestination = 0;
+
+        for (int colSource = 0; colSource < this.COLONNES; colSource++) {
+            boolean colonneVide = true;
+
+            for (int i = 0; i < this.LIGNES; i++) {
+                if (this.grille[i][colSource] != ' ') {
+                    colonneVide = false;
+                    break;
+                }
+            }
+
+            if (!colonneVide) {
+                if (colDestination != colSource) {
+                    for (int i = 0; i < this.LIGNES; i++) {
+                        this.grille[i][colDestination] = this.grille[i][colSource];
+                        this.grille[i][colSource] = ' ';
+                    }
+                }
+                colDestination++;
+            }
+        }
+    }
+
+/**
+ * Marque toutes les cases d’un groupe à partir d’une position donnée.
+ *
+ * @param couleur couleur du bloc de départ
+ * @param i ligne de départ
+ * @param j colonne de départ
+ * @param surbrillance tableau où marquer les blocs du groupe
+ */
+    public void marquerGroupe(char couleur, int i, int j, boolean[][] surbrillance) {
+        if (i < 0 || i >= this.LIGNES || j < 0 || j >= this.COLONNES) return;
+        if (surbrillance[i][j] || this.grille[i][j] != couleur) return;
+
+        surbrillance[i][j] = true;
+
+        marquerGroupe(couleur, i + 1, j, surbrillance);
+        marquerGroupe(couleur, i - 1, j, surbrillance);
+        marquerGroupe(couleur, i, j + 1, surbrillance);
+        marquerGroupe(couleur, i, j - 1, surbrillance);
+    }
+
+    /**
+     
+    Vérifie s’il reste des groupes de blocs valides
+    @return true si le jeu est terminé, false sinon*/
+    public boolean jeuFini() {
+        for (int i = 0; i < this.LIGNES; i++) {
+            for (int j = 0; j < this.COLONNES; j++) {
+                char bloc = this.grille[i][j];
+                if (bloc != ' ' && estGroupe(i, j)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    public char getCase(int i, int j) {
+        return this.grille[i][j];
+    }
+
+    public char[][] getGrille() {
+        return this.grille;
+    }
+
+    public int getLignes() {
+        return this.LIGNES;
+    }
+
+    public int getColonnes() {
+        return this.COLONNES;
+    }
+
+}

SAE21_2024/code_source/GrillePaint.java

@@ -0,0 +1,81 @@
+/**
+ * La classe <code>GrillePaint</code> représente une grille graphique initialisée aléatoirement
+ * pour l’affichage de blocs colorés dans le jeu SameGame.
+ * Elle utilise des images pour représenter les blocs rouges, verts et bleus.
+ *
+ * @version 1.5
+ * @author Emmanuel Srivastava-Tiamzon & Wael Atik
+ */
+
+ import javax.swing.*;
+ import java.awt.*;
+ import java.util.Random;
+ 
+ public class GrillePaint extends JComponent {
+ 
+     /** Nombre de colonnes dans la grille. */
+     public static final int COLONNES = 15;
+ 
+     /** Nombre de lignes dans la grille. */
+     public static final int LIGNES = 10;
+ 
+     /** Tableau représentant la grille de blocs. */
+     private char[][] grille;
+ 
+     /**
+      * Constructeur de la grille graphique.
+      * Initialise chaque case avec une couleur aléatoire parmi 'R', 'V' et 'B'.
+      */
+     public GrillePaint() {
+         super();
+         this.grille = new char[this.LIGNES][this.COLONNES];
+         char[] couleurs = {'R', 'V', 'B'};
+         Random random = new Random();
+ 
+         for (int i = 0; i < this.LIGNES; i++) {
+             for (int j = 0; j < this.COLONNES; j++) {
+                 grille[i][j] = couleurs[random.nextInt(3)];
+             }
+         }
+     }
+ 
+     /**
+      * Méthode de dessin de la grille. Affiche les images correspondant à chaque bloc.
+      *
+      * @param pinceau l'objet <code>Graphics</code> utilisé pour dessiner
+      */
+     @Override
+     public void paintComponent(Graphics pinceau) {
+         Graphics secondPinceau = pinceau.create();
+         if (this.isOpaque()) {
+             secondPinceau.setColor(this.getBackground());
+             secondPinceau.fillRect(0, 0, this.getWidth(), this.getHeight());
+         }
+ 
+         Image imgR = Toolkit.getDefaultToolkit().getImage("../image/Coeur.png");
+         Image imgV = Toolkit.getDefaultToolkit().getImage("../image/Croix.png");
+         Image imgB = Toolkit.getDefaultToolkit().getImage("../image/Carre.png");
+ 
+         int tailleBloc = Math.min(getWidth() / COLONNES, getHeight() / LIGNES);
+ 
+         for (int i = 0; i < this.LIGNES; i++) {
+             for (int j = 0; j < this.COLONNES; j++) {
+                 int x = j * tailleBloc;
+                 int y = i * tailleBloc;
+ 
+                 switch (this.grille[i][j]) {
+                     case 'R':
+                         secondPinceau.drawImage(imgR, x, y, tailleBloc, tailleBloc, this);
+                         break;
+                     case 'V':
+                         secondPinceau.drawImage(imgV, x, y, tailleBloc, tailleBloc, this);
+                         break;
+                     case 'B':
+                         secondPinceau.drawImage(imgB, x, y, tailleBloc, tailleBloc, this);
+                         break;
+                 }
+             }
+         }
+     }
+ }
+ 

SAE21_2024/code_source/JeuBlocs.java

@@ -0,0 +1,125 @@
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseMotionAdapter;
+
+/**
+ * La classe <code>JeuBlocs</code> est responsable de l'affichage graphique du jeu SameGame.
+ * Elle affiche la grille avec ses blocs et gère la surbrillance des groupes de blocs lorsqu'ils sont survolés par la souris.
+ *
+ * @version 1.11
+ * @author Emmanuel Srivastava-Tiamzon & Wael Atik
+ */
+public class JeuBlocs extends JComponent {
+
+    /** La grille logique du jeu. */
+    private Grille grille;
+
+    /** Images représentant les blocs rouges, verts, bleus et vides. */
+    private Image imageRouge;
+    private Image imageVert;
+    private Image imageBleu;
+    private Image imageVide;
+
+    /** La taille d'un bloc (en pixels). */
+    private int tailleBloc;
+
+    /** Tableau de booleans pour gérer la surbrillance des blocs. */
+    private boolean[][] surbrillance;
+
+    /**
+     * Constructeur de la vue graphique du jeu SameGame.
+     * Initialise les images des blocs, la taille des blocs et configure la gestion de la souris.
+     *
+     * @param grille la grille logique du jeu
+     * @param largeur la largeur totale de la fenêtre (en pixels)
+     * @param hauteur la hauteur totale de la fenêtre (en pixels)
+     */
+    public JeuBlocs(Grille grille, int largeur, int hauteur) {
+        this.grille = grille;
+        this.tailleBloc = Math.min(largeur / grille.getColonnes(), hauteur / grille.getLignes());
+        this.setPreferredSize(new Dimension(largeur, hauteur));
+
+        this.imageRouge = Toolkit.getDefaultToolkit().getImage("../image/Coeur.jpg");
+        this.imageVert = Toolkit.getDefaultToolkit().getImage("../image/Croix.jpg");
+        this.imageBleu = Toolkit.getDefaultToolkit().getImage("../image/Carre.jpg");
+        this.imageVide = Toolkit.getDefaultToolkit().getImage("../image/Vide.jpg");
+        this.surbrillance = new boolean[grille.getLignes()][grille.getColonnes()];
+
+        this.addMouseMotionListener(new MouseMotionAdapter() {
+            @Override
+            public void mouseMoved(MouseEvent e) {
+                int ligne = e.getY() / tailleBloc;
+                int colonne = e.getX() / tailleBloc;
+
+                if (ligne >= 0 && ligne < grille.getLignes() && colonne >= 0 && colonne < grille.getColonnes()) {
+                    if (grille.estGroupe(ligne, colonne)) {
+                        surbrillance = new boolean[grille.getLignes()][grille.getColonnes()];
+                        grille.marquerGroupe(grille.getCase(ligne, colonne), ligne, colonne, surbrillance);
+                    } else {
+                        surbrillance = new boolean[grille.getLignes()][grille.getColonnes()];
+                    }
+                    repaint();
+                }
+            }
+        });
+    }
+
+    /**
+     * Méthode de dessin de la grille et des blocs.
+     * Affiche les blocs et leur surbrillance si nécessaire.
+     *
+     * @param g l'objet graphique utilisé pour dessiner
+     */
+    @Override
+    protected void paintComponent(Graphics pinceau) {
+        Graphics secondPinceau = pinceau.create();
+
+		if (this.isOpaque()) {
+			secondPinceau.setColor(this.getBackground());
+			secondPinceau.fillRect(0, 0, this.getWidth(), this.getHeight());
+		}
+
+        char[][] gLogique = grille.getGrille();
+
+
+        for (int i = 0; i < grille.getLignes(); i++) {
+            for (int j = 0; j < grille.getColonnes(); j++) {
+                char c = gLogique[i][j];
+                Image image = switch (c) {
+                    case 'R' -> imageRouge;
+                    case 'V' -> imageVert;
+                    case 'B' -> imageBleu;
+                    default -> imageVide;
+                };
+
+                secondPinceau.drawImage(image, j * tailleBloc, i * tailleBloc, tailleBloc, tailleBloc, this);
+
+                if (surbrillance[i][j]) {
+                    secondPinceau.setColor(new Color(255, 255, 0, 80));
+                    secondPinceau.fillRect(j * tailleBloc, i * tailleBloc, tailleBloc, tailleBloc);
+                }
+
+                secondPinceau.setColor(Color.BLACK);
+                secondPinceau.drawRect(j * tailleBloc, i * tailleBloc, tailleBloc, tailleBloc);
+            }
+        }
+    }
+
+    /**
+     * Méthode pour mettre à jour l'affichage graphique après une modification de la grille.
+     * Elle appelle le repaint pour rafraîchir la vue.
+     */
+    public void mettreAJourCouleurs() {
+        repaint();
+    }
+
+    /**
+     * Retourne la taille d'un bloc (en pixels).
+     *
+     * @return la taille d'un bloc
+     */
+    public int getTailleBloc() {
+        return tailleBloc;
+    }
+}

SAE21_2024/code_source/Main.java

@@ -0,0 +1,20 @@
+/**
+ * La classe <code>Main</code> contient le point d’entrée principal du jeu SameGame.
+ * Elle initialise et affiche la fenêtre de démarrage du jeu à l'aide de la classe <code>FenetreDebut</code>.
+ *
+ * @version 1.5
+ * @author Emmanuel Srivastava-Tiamzon & Wael Atik
+ */
+public class Main {
+
+    /**
+     * Méthode principale du programme. Elle lance l'application SameGame
+     * en affichant la fenêtre d'accueil du jeu.
+     *
+     * @param args les arguments passés en ligne de commande (non utilisés ici)
+     */
+    public static void main(String[] args) {
+        FenetreDebut fenetredebut = new FenetreDebut();
+        fenetredebut.setVisible(true);
+    }
+}

SAE21_2024/code_source/Makefile

@@ -0,0 +1,64 @@
+### VARIABLES ###
+
+JC = javac
+JCFLAGS = -encoding UTF-8 -implicit:none
+
+JVM = java
+JVMFLAGS = 
+
+### REGLES ESSENTIELLES ###
+
+Main.class : Main.java Fenetre.class
+	${JC} ${JCFLAGS} Main.java
+
+Fenetre.class : Fenetre.java Grille.class JeuBlocs.class ControleurSouris.class
+	${JC} ${JCFLAGS} Fenetre.java
+
+FenetreDebut.class : FenetreDebut.java PaintFenetreDebut.class MouseFenetreDebut.class
+	${JC} ${JCFLAGS} FenetreDebut.java
+
+FenetreFin.class : FenetreFin.java PaintFenetreFin.class MouseFenetreFin.class
+	${JC} ${JCFLAGS} FenetreFin.java
+
+Grille.class : Grille.java
+	${JC} ${JCFLAGS} Grille.java
+
+GrillePaint.class : GrillePaint.java Grille.class
+	${JC} ${JCFLAGS} GrillePaint.java
+
+JeuBlocs.class : JeuBlocs.java Grille.class Score.class
+	${JC} ${JCFLAGS} JeuBlocs.java
+
+ControleurSouris.class : ControleurSouris.java Grille.class JeuBlocs.class
+	${JC} ${JCFLAGS} ControleurSouris.java
+
+MouseFenetreDebut.class : MouseFenetreDebut.java
+	${JC} ${JCFLAGS} MouseFenetreDebut.java
+
+MouseFenetreFin.class : MouseFenetreFin.java
+	${JC} ${JCFLAGS} MouseFenetreFin.java
+
+PaintFenetreDebut.class : PaintFenetreDebut.java
+	${JC} ${JCFLAGS} PaintFenetreDebut.java
+
+PaintFenetreFin.class : PaintFenetreFin.java
+	${JC} ${JCFLAGS} PaintFenetreFin.java
+
+Score.class : Score.java
+	${JC} ${JCFLAGS} Score.java
+
+### REGLES OPTIONNELLES ###
+
+run : Main.class
+	${JVM} ${JVMFLAGS} Main
+
+clean :
+	-rm -f *.class
+
+mrproper : clean Main.class
+
+### BUTS FACTICES ###
+
+.PHONY : run clean mrproper
+
+### FIN ###

SAE21_2024/code_source/MouseFenetreDebut.java

@@ -0,0 +1,168 @@
+import javax.swing.*;
+import java.awt.event.*;
+import java.io.*;
+
+/**
+ * La classe <code>MouseFenetreDebut</code> gère les événements de souris pour les différentes fenêtres 
+ * au début du jeu. Elle permet de changer d'état de fenêtre en fonction des clics de souris et de gérer
+ * les actions associées (lancement du jeu, ouverture de fichiers, etc.).
+ *
+ * @version 1.6
+ * @author Emmanuel Srivastava-Tiamzon & Wael Atik
+ */
+public class MouseFenetreDebut extends MouseAdapter {
+
+    /** L'attribut qui instancie l'état actuel de la fenêtre. */
+    private int fenetreActuelle;
+
+    /** L'attribut qui gère le dessin de la fenêtre de début. */
+    private PaintFenetreDebut paintComponent;
+
+    /** L'attribut représentant la grille du jeu. */
+    private Grille grille;
+
+    /** L'attribut qui instancie un objet de type Fenetre*/
+    private FenetreDebut fenetre;
+
+    /**
+     * Constructeur de la classe <code>MouseFenetreDebut</code>.
+     * Initialise l'état de la fenêtre et les composants nécessaires.
+     *
+     * @param paintComponent l'objet qui gère le dessin de la fenêtre de début
+     * @param grille l'objet représentant la grille du jeu
+     */
+    public MouseFenetreDebut(PaintFenetreDebut paintComponent, Grille grille, FenetreDebut fenetre) {
+        this.fenetreActuelle = 1;
+        this.paintComponent = paintComponent;
+        this.grille = grille;
+        this.fenetre = fenetre;
+    }
+
+    /**
+     * Retourne l'état actuel de la fenêtre.
+     *
+     * @return l'état actuel de la fenêtre
+     */
+    public int getEtatFenetre() {
+        return this.fenetreActuelle;
+    }
+
+    /**
+     * Vérifie si un clic de souris se trouve dans une zone définie par les coordonnées 
+     * et les dimensions données.
+     *
+     * @param clickX la coordonnée X du clic
+     * @param clickY la coordonnée Y du clic
+     * @param x la coordonnée X de la zone
+     * @param y la coordonnée Y de la zone
+     * @param w la largeur de la zone
+     * @param h la hauteur de la zone
+     * @return true si le clic est dans la zone, false sinon
+     */
+    private boolean isInArea(int clickX, int clickY, int x, int y, int w, int h) {
+        return clickX >= x && clickX <= x + w && clickY >= y && clickY <= y + h;
+    }
+
+    /**
+     * Méthode appelée lorsqu'un clic est effectué dans la fenêtre.
+     * Cette méthode gère les actions à effectuer en fonction de l'état de la fenêtre actuelle.
+     *
+     * @param e l'événement de clic de souris
+     */
+    @Override
+    public void mouseClicked(MouseEvent e) {
+        int x = e.getX();
+        int y = e.getY();
+        switch (fenetreActuelle) {
+            case 1:
+                if (isInArea(x, y, 290, 285, 182, 78)) {
+                    fenetreActuelle = 2;
+                    paintComponent.repaint();
+                } else if (isInArea(x, y, 300, 400, 200, 75)) {
+                    System.exit(0); 
+                }
+                break;
+
+            case 2:
+                if (isInArea(x, y, 180, 340, 180, 60)) {
+                    fenetre.dispose();
+                    new Fenetre(); 
+                } else if (isInArea(x, y, 400, 340, 180, 75)) {
+                    File fichier = choisirFichierGrille();
+                    if(fichier != null) {
+                        char[][] tableau = getGrilleFromFile(fichier);
+                        Grille grilleChoisi = new Grille(tableau);
+                        fenetre.dispose();
+                        new Fenetre(grilleChoisi);
+
+
+                    }
+                } else if (isInArea(x, y, 300, 400, 200, 75)) {
+                    System.exit(0); 
+                }
+                break;
+
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Ouvre un sélecteur de fichiers pour choisir un fichier à partir du système de fichiers.
+     */
+    public File choisirFichierGrille() {
+        JFileChooser fileChooser = new JFileChooser();
+        fileChooser.setDialogTitle("Choisir une grille texte");
+        fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
+        
+        fileChooser.setFileFilter(new javax.swing.filechooser.FileNameExtensionFilter("Fichiers texte", "txt"));
+
+        int returnValue = fileChooser.showOpenDialog(null);
+
+        if (returnValue == JFileChooser.APPROVE_OPTION) {
+            return fileChooser.getSelectedFile();
+        } else {
+            System.out.println("Aucun fichier sélectionné");
+            return null;
+        }
+    }
+
+    /**
+     * Lit un fichier voulu pour crée et renvoyer une grille de char[][]
+     * @param fileGrille est utilisé en tant que fichier choisi par JFilechooser
+     * @return Une grille adéquat pour le constructeur de la classe <code>Grille</code> 
+     */    
+    public char[][] getGrilleFromFile(File fileGrille) {
+		char[][] newGrille = new char[10][15];
+
+		try {
+			FileReader grilleReader = new FileReader(fileGrille);
+			BufferedReader bufferedreader = new BufferedReader(grilleReader);
+			String line = bufferedreader.readLine();
+
+			for(int i = 0; line != null && i < 10; i++) {
+				if(line.length() >= 15) {
+                	for(int j = 0; j < 15; j++) {
+                    	newGrille[i][j] = line.charAt(j);
+                	}
+            	} else {
+                	System.err.println("Ligne " + i + " trop courte : " + line);
+            	}
+				line = bufferedreader.readLine();
+			}
+
+			try {
+				bufferedreader.close();
+			} catch(IOException e) {
+				System.err.println("Erreur de fermeture de fichier : "+e);
+			}
+		} catch(IOException e) {
+			System.err.println("Erreur d'ouverture de fichier : "+e);
+		} catch(NumberFormatException e) {
+			System.err.println("Le contenu du fichier n'est pas valide : "+e);
+		}
+
+		return newGrille;
+	}
+
+}

SAE21_2024/code_source/MouseFenetreFin.java

@@ -0,0 +1,61 @@
+import javax.swing.*;
+import java.awt.event.*;
+
+/**
+ * La classe <code>MouseFenetreFin</code> gère les événements de souris pour la fenêtre de fin de jeu.
+ * Elle permet de lancer une nouvelle partie ou de quitter le jeu en fonction des clics de souris.
+ *
+ * @version 1.6
+ * @author Emmanuel Srivastava-Tiamzon & Wael Atik
+ */
+public class MouseFenetreFin extends MouseAdapter {
+
+    /** La fenêtre associée à la fin du jeu. */
+    private JFrame fenetre;
+
+    /**
+     * Constructeur de la classe <code>MouseFenetreFin</code>.
+     * Initialise la fenêtre de fin du jeu.
+     *
+     * @param fenetre la fenêtre de fin du jeu
+     */
+    public MouseFenetreFin(JFrame fenetre) {
+        this.fenetre = fenetre;
+    }
+
+    /**
+     * Vérifie si un clic de souris se trouve dans une zone définie par les coordonnées 
+     * et les dimensions données.
+     *
+     * @param clickX la coordonnée X du clic
+     * @param clickY la coordonnée Y du clic
+     * @param x la coordonnée X de la zone
+     * @param y la coordonnée Y de la zone
+     * @param w la largeur de la zone
+     * @param h la hauteur de la zone
+     * @return true si le clic est dans la zone, false sinon
+     */
+    private boolean isInArea(int clickX, int clickY, int x, int y, int w, int h) {
+        return clickX >= x && clickX <= x + w && clickY >= y && clickY <= y + h;
+    }
+
+    /**
+     * Méthode appelée lorsqu'un clic est effectué dans la fenêtre de fin du jeu.
+     * Cette méthode gère les actions à effectuer selon l'endroit où l'utilisateur clique.
+     *
+     * @param e l'événement de clic de souris
+     */
+    @Override
+    public void mouseClicked(MouseEvent e) {
+        int x = e.getX();
+        int y = e.getY();
+
+        if (isInArea(x, y, 290, 270, 200, 75)) {
+        fenetre.dispose();
+        FenetreDebut fenetredebut = new FenetreDebut();
+        fenetredebut.setVisible(true);
+        } else if (isInArea(x, y, 300, 355, 200, 75)) {
+            System.exit(0);
+        }
+    }
+}

SAE21_2024/code_source/PaintFenetreDebut.java

@@ -0,0 +1,63 @@
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * La classe <code>PaintFenetreDebut</code> est un composant graphique personnalisé
+ * qui gère l'affichage du menu de démarrage du jeu SameGame. Elle permet d'afficher
+ * différentes images en fonction de l'état du menu et de gérer les interactions via la souris.
+ *
+ * @version 1.6
+ * @author Emmanuel Srivastava-Tiamzon & Wael Atik
+ */
+public class PaintFenetreDebut extends JComponent {
+
+    /** Image du menu principal */
+    private Image MenuDebutI;
+
+    /** Image du menu de sélection */
+    private Image MenuDebutII;
+
+    /** Le gestionnaire des événements de souris associé à cette fenêtre. */
+    private MouseFenetreDebut mouseFenetre;
+
+    /**
+     * Constructeur de la classe <code>PaintFenetreDebut</code>.
+     * Charge les images du menu et initialise le gestionnaire d'événements de souris.
+     *
+     * @param grille la grille du jeu à passer au gestionnaire de souris
+     * @param fenetre la fenêtre principale de démarrage (FenetreDebut)
+     */
+    public PaintFenetreDebut(Grille grille, FenetreDebut fenetre) {
+        this.MenuDebutI = Toolkit.getDefaultToolkit().getImage("../image/MenuDebut.jpg");
+        this.MenuDebutII = Toolkit.getDefaultToolkit().getImage("../image/MenuDebutSelection.jpg");
+        this.mouseFenetre = new MouseFenetreDebut(this, grille, fenetre);
+        this.addMouseListener(this.mouseFenetre);
+    }
+
+    /**
+     * Redéfinit la méthode <code>paintComponent</code> pour dessiner les éléments du menu.
+     * Affiche l'image correspondant à l'état actuel du menu.
+     *
+     * @param pinceau le contexte graphique utilisé pour dessiner
+     */
+    @Override
+    protected void paintComponent(Graphics pinceau) {
+        Graphics secondPinceau = pinceau.create();
+
+        if (this.isOpaque()) {
+            secondPinceau.setColor(this.getBackground());
+            secondPinceau.fillRect(0, 0, this.getWidth(), this.getHeight());
+        }
+
+        switch (this.mouseFenetre.getEtatFenetre()) {
+            case 1:
+                secondPinceau.drawImage(this.MenuDebutI, 0, 0, 765, 510, this);
+                break;
+            case 2:
+                secondPinceau.drawImage(this.MenuDebutII, 0, 0, 765, 510, this);
+                break;
+            default:
+                secondPinceau.drawImage(this.MenuDebutI, 0, 0, 765, 510, this);
+        }
+    }
+}

SAE21_2024/code_source/PaintFenetreFin.java

@@ -0,0 +1,61 @@
+import javax.swing.*;
+import java.awt.*;
+
+/**
+ * La classe <code>PaintFenetreFin</code> gère l'affichage graphique de la fenêtre de fin du jeu.
+ * Elle affiche l'image de fond ainsi que le score final du joueur.
+ *
+ * @version 1.8
+ * @author Emmanuel Srivastava-Tiamzon & Wael Atik
+ */
+public class PaintFenetreFin extends JComponent {
+
+    /** L'image de fond du menu de fin. */
+    private Image MenuFin;
+
+    /** Le score final du joueur. */
+    private int score;
+
+    /**
+     * Constructeur de la classe <code>PaintFenetreFin</code>.
+     * Initialise l'image de fond et le score final du joueur.
+     *
+     * @param score le score final du joueur
+     */
+    public PaintFenetreFin(int score) {
+        this.MenuFin = Toolkit.getDefaultToolkit().getImage("../image/MenuFin.jpg");
+        this.score = score;
+    }
+
+    /**
+     * Méthode de dessin du composant. Cette méthode est appelée pour afficher
+     * l'image de fond ainsi que le score du joueur sur la fenêtre de fin.
+     *
+     * @param pinceau l'objet graphique utilisé pour dessiner
+     */
+    @Override
+    protected void paintComponent(Graphics pinceau) {
+        Graphics secondPinceau = pinceau.create();
+
+        if (this.isOpaque()) {
+            secondPinceau.setColor(this.getBackground());
+            secondPinceau.fillRect(0, 0, this.getWidth(), this.getHeight());
+        }
+
+        secondPinceau.drawImage(this.MenuFin, 0, 0, this.getWidth(), this.getHeight(), this);
+
+        // Création du label pour afficher le score
+        JLabel scoreLabel = new JLabel("Score: " + this.score, JLabel.CENTER);
+        scoreLabel.setFont(new Font("Arial", Font.BOLD, 36));
+        scoreLabel.setForeground(Color.WHITE);
+
+        // Calcul des dimensions et position du label
+        int labelWidth = scoreLabel.getPreferredSize().width;
+        int labelHeight = scoreLabel.getPreferredSize().height;
+        int x = (this.getWidth() - labelWidth) / 2;
+        int y = (this.getHeight() - labelHeight) / 2 - 40;
+
+        scoreLabel.setBounds(x, y, labelWidth, labelHeight);
+        this.add(scoreLabel);
+    }
+}

SAE21_2024/code_source/Score.java

@@ -0,0 +1,194 @@
+/**
+ * La classe <code>Score</code> est utilisée pour donner le score inscrit dans un fichier
+ * ou pour changer la valeur du score.
+ *  
+ * @version 1.6
+ * @author Emmanuel SRIVASTAVA-TIAMZON & Wael Atik
+ */
+
+/**
+ * Bibliothèque indispensable pour l'usage d'un fichier.
+ */ 
+import java.io.*;
+
+public class Score {
+
+/**
+ * Attribut qui instancie le score pour pouvoir modifier sa valeur plus tard.
+ */
+	private int score;
+
+/**
+ * Attribut qui instancie le fichier à utiliser pour pouvoir faciliter les méthodes.
+ */
+	private File scoreFile;
+
+/**
+ * Attribut qui instancie le plus haut score.
+ */
+	private int highestScore;
+
+/**
+ * Constructeur servant à mettre le score à 0 pour le réutiliser plus tard
+ * et à choisir quel fichier utiliser.
+ */
+	public Score() {
+		this.score = 0;
+		this.scoreFile = new File("score.txt");
+	}
+
+/**
+ * Remplace l'ancien score soit la valeur indiquée dans le fichier score.txt
+ * @param score modifie le score stocké dans le fichier texte.
+ */ 	
+	public void setScore(int score) {
+		this.score = score;
+
+		try {
+			FileWriter scoreWriter = new FileWriter(this.scoreFile);
+			BufferedWriter bufferedWriter = new BufferedWriter(scoreWriter);
+
+			bufferedWriter.write(String.valueOf(score));
+
+			try {
+				bufferedWriter.close();
+			} catch(IOException e) {
+				System.err.println("Erreur de fermeture de fichier : "+e);
+			}
+		} catch(IOException e) {
+			System.err.println("Erreur d'ouverture de fichier : "+e);
+		}
+	}
+
+/**
+ * Renvoie le score soit la valeur indiqué dans le fichier score.txt
+ * @return le score actuel dans le fichier crée
+ */
+	public int getScore() {
+		try {
+			FileReader scoreReader = new FileReader(this.scoreFile);
+			BufferedReader bufferedreader = new BufferedReader(scoreReader);
+
+			String line = bufferedreader.readLine();
+			if(line != null) {
+				this.score = Integer.parseInt(line); 
+			}
+
+			try {
+				bufferedreader.close();
+			} catch(IOException e) {
+				System.err.println("Erreur de fermeture de fichier : "+e);
+			}
+		} catch(IOException e) {
+			System.err.println("Erreur d'ouverture de fichier : "+e);
+		} catch(NumberFormatException e) {
+			System.err.println("Le contenu du fichier n'est pas un entier valide : "+e);
+		}
+
+		return this.score;
+
+	}
+
+/**
+ * Lis le score soit la valeur indiquée dans le fichier score.txt 
+ * pour ensuite lui ajouter la valeur du @param addons de cette méthode.
+ * C'est un mélange de la méthode getScore et setScore.
+ */ 
+	public void addToScore(int addons){
+		try {
+			FileReader scoreReader = new FileReader(this.scoreFile);
+			BufferedReader bufferedreader = new BufferedReader(scoreReader);
+
+			String line = bufferedreader.readLine();
+			int oldScore = Integer.parseInt(line);
+
+			int newScore = oldScore + addons;
+
+			try {
+				FileWriter scoreWriter = new FileWriter(this.scoreFile);
+				BufferedWriter bufferedWriter = new BufferedWriter(scoreWriter);
+
+				bufferedWriter.write(String.valueOf(newScore));
+
+				try{
+					bufferedWriter.close();
+				}catch(IOException e) {
+					System.err.println("Erreur de fermeture de fichier : "+e);
+				}
+			}catch(IOException e) {
+				System.err.println("Erreur d'ouverture/d'écriture de fichier : "+e);
+			}
+
+			try {
+				bufferedreader.close();
+			}catch(IOException e) {
+				System.err.println("Erreur de fermeture de fichier : "+e);
+			}
+
+		} catch(IOException e) {
+			System.err.println("Erreur de lecture de fichier : "+e);
+		}
+	}
+
+/**
+ * Remet le score à 0 grâçe à la méthode setScore.
+ */ 
+	public void resetScore() {
+		setScore(0);
+	}
+
+/**
+ * remplace l'ancien meilleur dans le fichier highscore.txt
+ * @param newBestScore remplace l'ancienne valeur placée dans le fichier highscore.txt
+ */
+	public void setHighestScore(int newBestScore) {
+		this.score = newBestScore;
+
+		try {
+			File bestScoreFile = new File("highscore.txt");
+			FileWriter scoreWriter = new FileWriter(bestScoreFile);
+			BufferedWriter bufferedWriter = new BufferedWriter(scoreWriter);
+
+			bufferedWriter.write(String.valueOf(newBestScore));
+
+			try {
+				bufferedWriter.close();
+			} catch(IOException e) {
+				System.err.println("Erreur de fermeture de fichier : "+e);
+			}
+		} catch(IOException e) {
+			System.err.println("Erreur d'ouverture de fichier : "+e);
+		}
+
+	}
+/**
+ * @return le plus haut score stocké dans un fichier highscore.txt
+ */
+	public int getHighestScore() {
+		try {
+			File bestScoreFile = new File("highscore.txt");
+			FileReader scoreReader = new FileReader(bestScoreFile);
+			BufferedReader bufferedreader = new BufferedReader(scoreReader);
+
+			String line = bufferedreader.readLine();
+			if(line != null) {
+				this.highestScore = Integer.parseInt(line); 
+			}
+
+			try {
+				bufferedreader.close();
+			} catch(IOException e) {
+				System.err.println("Erreur de fermeture de fichier : "+e);
+			}
+		} catch(IOException e) {
+			System.err.println("Erreur d'ouverture de fichier : "+e);
+		} catch(NumberFormatException e) {
+			System.err.println("Le contenu du fichier n'est pas un entier valide : "+e);
+		}
+
+		return this.highestScore;
+
+
+	}
+
+}

SAE21_2024/code_source/highscore.txt

@@ -0,0 +1 @@
+4150

SAE21_2024/code_source/score.txt

@@ -0,0 +1 @@
+4150

SAE21_2024/grille_predefini/GrilleCarre.txt

@@ -0,0 +1,10 @@
+VVVVVVVVVVVVVVV
+VVVVVVVVVVVVVVV
+VVVVVBBBBBBVVVV
+VVVVVBBBBBBVVVV
+VVVVVBBBBBBVVVV
+RRRRRBBBBBBRRRR
+RRRRRBBBBBBRRRR
+RRRRRBBBBBBRRRR
+RRRRRRRRRRRRRRR
+RRRRRRRRRRRRRRR

SAE21_2024/grille_predefini/GrilleEnCoeur.txt

@@ -0,0 +1,10 @@
+BVBRRRVVVRRRBVB
+VBRRRRRRRRRRBVV
+BRRRRRRRRRRRRRB
+VBRRRRRRRRRRRRV
+BRRRRRRRRRRRRRB
+VBRRRRRRRRRRRRV
+BVBRRRRRRRRRBVB
+VBVBRRRRRRRVBVB
+BVBVBRRRRRBVBVB
+VBVBVBRRRVBVBVB

SAE21_2024/grille_predefini/GrilleExempleSAE.txt

@@ -0,0 +1,10 @@
+RVVRRVRVBBBBRBV
+BVVVVRBVVBRRVRB
+VBBRVRBVRRBRRRR
+BRBVBRBBVVBRVRV
+RVBVBBBRRBRRRBV
+RVVVBBRBVVBVVRB
+BRBRBBBRBVRVRRV
+VRRVVBBVVBBRVVV
+BVRRVVBRVRRRBVV
+BBRBBBBRVVRRVRB