MISE A JOUR

src/Main.java

@@ -1,68 +1,72 @@
-import controleur.ControleurPartie;
+    import controleur.ControleurPartie;
-import controleur.ControleurReseau;
+    import controleur.ControleurReseau;
-
+    import modele.Couleur;
-import modele.ModeDeJeu;
+    import modele.ModeDeJeu;
-import modele.Partie;
+    import modele.Partie;
-import modele.Couleur;
+    import modele.joueur.Joueur;
-
+    import modele.joueur.JoueurHumain;
-import vue.Vue;
+    import vue.Vue;
-import vue.VueConsole;
+    import vue.VueConsole;
-import vue.VueGraphiqueSwing;
+    import vue.VueGraphiqueSwing;
-
-import modele.joueur.Joueur;
-import modele.joueur.JoueurHumain;
 
 
-public class Main {
+    public class Main {
-    public static void main(String[] args) {
+        public static void main(String[] args) {
-        // Déclaration des variables nécessaires
+            // Déclaration des variables nécessaires
-        Vue vue;
+            Vue vue;
-        Joueur joueurBlanc;
+            Joueur joueurBlanc;
-        Joueur joueurNoir;
+            Joueur joueurNoir;
-        ModeDeJeu modeDeJeu;
+            ModeDeJeu modeDeJeu;
-        ControleurReseau controleurReseau = null; // À initialiser si tu utilises le réseau
+            ControleurReseau controleurReseau = null; // À initialiser si tu utilises le réseau
 
-        int choixMode = 1; // à remplacer par Scanner plus tard
+            int choixMode = 1; // à remplacer par Scanner plus tard
-        int choixAffichage = 3; // 1: Console, 2: JavaFX, 3: Swing
+            int choixAffichage = 3; // 1: Console, 2: JavaFX, 3: Swing
+            String stylePlateau = "BOIS_CLAIR"; // Style de plateau, à remplacer par une entrée utilisateur
 
-        modeDeJeu = ModeDeJeu.HUMAIN_VS_HUMAIN;
+            switch (choixMode) {
+                case 1 -> modeDeJeu = ModeDeJeu.HUMAIN_VS_HUMAIN;
+                case 2 -> modeDeJeu = ModeDeJeu.HUMAIN_VS_IA;
+                case 3 -> modeDeJeu = ModeDeJeu.IA_VS_IA;
+                default -> {
+                    modeDeJeu = ModeDeJeu.HUMAIN_VS_HUMAIN;
+                }
+            }
+
+            // Initialisation des joueurs et du mode de jeu
+            vue = new VueConsole();
+            joueurBlanc = new JoueurHumain(Couleur.BLANC, vue, false, "Mathis");
+            joueurNoir = new JoueurHumain(Couleur.NOIR, vue, false, "Pellel");
+
+            Partie partie = new Partie(joueurBlanc, joueurNoir, stylePlateau);
+
+            switch (choixAffichage) {
+            case 1 -> vue = new VueConsole();
+            case 2 -> {
+                // vue = new VueGraphiqueJavaFX();
+            }
+            case 3 -> vue = new VueGraphiqueSwing(partie);
+            default -> {
+                System.out.println("Type d'affichage non reconnu. Console par défaut utilisée.");
+                vue = new VueConsole();
+            }
+            }
+
+            // Recalification de la vue pour chaque joueur humain
+            if(joueurBlanc instanceof  JoueurHumain jb) jb.setVue(vue);
+            if(joueurNoir instanceof  JoueurHumain jb) jb.setVue(vue);
+
+            // if (joueurNoir instanceof JoueurHumain) {
+            //     JoueurHumain jb = (JoueurHumain) joueurBlanc;
+            //     jb.setVue(vue);
+            // }
+            // if (joueurNoir instanceof JoueurHumain) {
+            //     JoueurHumain jn = (JoueurHumain) joueurNoir;
+            //     jn.setVue(vue);
+            // }
 
 
-        // Initialisation des joueurs et du mode de jeu
+            // lancement de la partie
-        vue = new VueConsole();
+            var controleurPartie = new ControleurPartie(partie, vue, controleurReseau, modeDeJeu);
-        joueurBlanc = new JoueurHumain(Couleur.BLANC, vue, false, "Mathis");
+            controleurPartie.lancerPartie();
-        joueurNoir = new JoueurHumain(Couleur.NOIR, vue, false, "Pellel");
-
-        Partie partie = new Partie(joueurBlanc, joueurNoir);
-
-        switch (choixAffichage) {
-           case 1 -> vue = new VueConsole();
-           case 2 -> {
-               // vue = new VueGraphiqueJavaFX();
-           }
-           case 3 -> vue = new VueGraphiqueSwing(partie.getPlateau());
-           default -> {
-               System.out.println("Type d'affichage non reconnu. Console par défaut utilisée.");
-               vue = new VueConsole();
-           }
         }
-
-        // Recalification de la vue pour chaque joueur humain
-        if(joueurBlanc instanceof  JoueurHumain jb) jb.setVue(vue);
-        if(joueurNoir instanceof  JoueurHumain jb) jb.setVue(vue);
-
-        // if (joueurNoir instanceof JoueurHumain) {
-        //     JoueurHumain jb = (JoueurHumain) joueurBlanc;
-        //     jb.setVue(vue);
-        // }
-        // if (joueurNoir instanceof JoueurHumain) {
-        //     JoueurHumain jn = (JoueurHumain) joueurNoir;
-        //     jn.setVue(vue);
-        // }
-
-
-        // lancement de la partie
-        var controleurPartie = new ControleurPartie(partie, vue, controleurReseau, modeDeJeu);
-        controleurPartie.lancerPartie();
     }
-}

src/controleur/ControleurPartie.java

@@ -1,10 +1,9 @@
 package controleur;
 
-import modele.joueur.*;
 import modele.Coup;
-import modele.Partie;
-import modele.Plateau;
 import modele.ModeDeJeu;
+import modele.Partie;
+import modele.joueur.*;
 import vue.Vue;
 
 
@@ -26,6 +25,8 @@ public class ControleurPartie {
         System.out.println("BIENVENUE AU JEU D'ÉCHECS");
         System.out.println("===============================\n");
 
+        System.out.println("DEbug");
+
 
         vue.afficherMessage("Mode de jeu : " + modeDeJeu);
         vue.afficherMessage("Joueurs : " + partie.getJoueurBlanc().getNom() + " (Blancs) vs " + partie.getJoueurNoir().getNom() + " (Noirs)");
@@ -44,10 +45,14 @@ public class ControleurPartie {
             try {
                 Joueur joueurPrecedent = partie.getJoueurActif(); // AVANT le tour
                 partie.jouerTour(); // Moteur de jeu
-                Coup dernierCoup = partie.getHistorique().get(partie.getHistorique().size() - 1);
+                Coup dernierCoup = partie.getDernierCoup(); 
+                vue.setDernierCoup(dernierCoup);
                 vue.afficherPlateau(partie.getPlateau());
-                //System.out.println("");
+
-                vue.afficherMessage("Dernier coup : " + joueurPrecedent.getNom() + " a joué " + dernierCoup);
+                if(dernierCoup != null) {
+                    vue.afficherMessage("Dernier coup : " + joueurPrecedent.getNom() + " a joué " + dernierCoup);
+                }
+
                 vue.afficherMessage("\nC'est au tour de " + partie.getJoueurActif().getNom() + " de jouer.");
             } catch (IllegalArgumentException e) {
                 vue.afficherMessage("> Erreur : " + e.getMessage());

src/modele/ModeDeJeu.java

@@ -1,6 +1,6 @@
 package modele;
 public enum ModeDeJeu {
-    IA_VS_HUMAIN,
+    HUMAIN_VS_IA,
     HUMAIN_VS_HUMAIN,
     RESEAU_SERVEUR,
     RESEAU_CLIENT,

src/modele/Partie.java

@@ -1,11 +1,10 @@
 package modele;
 
-import modele.piece.Piece;
-import modele.joueur.*;
-
-import java.util.List;
 import java.awt.Point;
 import java.util.ArrayList;
+import java.util.List;
+import modele.joueur.*;
+import modele.piece.Piece;
 
 public class Partie{
     private Plateau plateau;
@@ -20,8 +19,8 @@ public class Partie{
     private List<Piece> listeCapturesBlancs;
     private List<Piece> listeCapturesNoires;
 
-    public Partie(Joueur joueurBlanc, Joueur joueurNoir) {
+    public Partie(Joueur joueurBlanc, Joueur joueurNoir, String stylePlateau) {
-        plateau = new Plateau();
+        plateau = new Plateau(stylePlateau);
         nombreCoups = 0;
         historique = new ArrayList<>();
         listeCapturesBlancs = new ArrayList<>();
@@ -118,6 +117,12 @@ public class Partie{
     public List<Coup> getHistorique() {
         return historique;
     }
+    public Coup getDernierCoup() {
+        if(this.historique.isEmpty()) {
+            return null;
+        }
+        return this.historique.get(this.historique.size() - 1);
+    }
 
     public int getNombreCoups() {
         return nombreCoups;

src/modele/Plateau.java

@@ -4,8 +4,10 @@ import modele.piece.*;
 
 public class Plateau {
     Case[][] cases;
+    String style;
 
-    public Plateau(){
+    public Plateau(String style){
+        this.style = style;
         // Création du plateau de jeu avec 64 cases
         cases = new Case[8][8];
         for (int i = 0; i < 8; i++) {
@@ -122,4 +124,8 @@ public class Plateau {
 
       
     }
+
+    public String getStyle() {
+        return style;
+    }
 }

src/modele/joueur/JoueurHumain.java

@@ -24,5 +24,9 @@ public class JoueurHumain extends Joueur {
     public Coup jouerCoup(Plateau plateau) {
         return vue.demanderCoup(plateau); // la vue s'adapte si c'est réseau ou pas
     }
+
+    public void setVue(Vue vue) {
+        this.vue = vue;
+    }
 }
 

src/vue/CaseSwingUI.java

@@ -1,58 +1,208 @@
 package vue;
 
-import modele.piece.Piece;
 import java.awt.*;
-import java.lang.ref.Reference;
+import java.awt.event.MouseEvent;
-import modele.Case;
+import java.awt.event.MouseListener;
 import javax.swing.*;
 
-public class CaseSwingUI extends JPanel {
-    private int ligne;
-    private int colonne;
 
-    private Color couleurdeFond; 
+import modele.Case;
+import modele.piece.Piece;
+import modele.Couleur;
+
+public class CaseSwingUI extends JPanel implements MouseListener{
+    
+
+    private Color couleurCaseClaire;
+    private Color couleurCaseFoncee;
+    private Color couleurCaseSelection;
+    private Color couleurCasePrecedente;  
+
+
+    private final int ligne;
+    private final  int colonne;
+
+    private boolean estDernierCoupOrigine = false;
+    private boolean estDernierCoupDestination = false;
+
     private boolean selectionnee = false;
 
     private final JLabel label = new JLabel("", SwingConstants.CENTER);
     private final Case caseModele; // reference vers la case de le modele
 
-    public CaseSwingUI(Color couleurdeFond, int ligne, int colonne, Case caseModele) {
+    public CaseSwingUI(String style, int ligne, int colonne, Case caseModele) {
-        this.couleurdeFond = couleurdeFond;
+        switch (style) {
+            case "RETRO_BOIS" -> {
+                // Style Bois rétro :
+                couleurCaseClaire = new Color(222, 184, 135); // Burlywood (bois clair rétro)
+                couleurCaseFoncee = new Color(139, 69, 19);   // SaddleBrown (bois foncé rétro)
+                couleurCaseSelection = new Color(205, 133, 63); // Peru (orange/brun vieilli)
+            }
+            case "METAL_FUTURISTE" -> {
+                // Style métallique Futuriste
+                couleurCaseClaire = new Color(192, 192, 192); // Silver
+                couleurCaseFoncee = new Color(105, 105, 105); // DimGray
+                couleurCaseSelection = new Color(0, 255, 255); // Cyan flashy (effet néon)
+            }
+            case "BOIS_CLAIR" -> {
+                // Style Bois clair
+                couleurCaseClaire = new Color(240, 218, 181);   // Beige clair
+                couleurCaseFoncee = new Color(181, 136, 99);    // Marron clair
+                couleurCaseSelection = new Color(209, 83, 71); // Rouge-orangé
+                couleurCasePrecedente = new Color(255, 112, 99); // Rouge clair
+            }
+            case "JAUNE_CHALEUREUX" -> {
+                // Style Jaune Chaleureux
+                couleurCaseClaire = new Color(253, 231, 76); // Jaune vif
+                couleurCaseFoncee = new Color(227, 101, 91); // Rouge doux
+                couleurCaseSelection = new Color(248, 161, 87); // Orange doux
+            }
+            case "VINTAGE_PASTEL" -> {
+                // Style vintage pastel
+                couleurCaseClaire = new Color(246, 229, 189); // Beige pastel
+                couleurCaseFoncee = new Color(249, 125, 125); // Rose brique clair
+                couleurCaseSelection = new Color(200, 90, 90); // Rouge passé
+            }
+            default -> {
+                couleurCaseClaire = new Color(255, 255, 255); // Blanc
+                couleurCaseFoncee = new Color(200, 200, 200); // Gris
+                couleurCaseSelection = new Color(100, 100, 100); // Gris foncé
+            }
+
+        }
+
         this.ligne = ligne;
         this.colonne = colonne;
         this.caseModele = caseModele;
 
+        // Gestion de la couleur
+        if ((ligne + colonne) % 2 == 0) {
+            setBackground(this.couleurCaseClaire); // couleur claire
+        } else {
+            setBackground(this.couleurCaseFoncee); // couleur foncée
+        }
+       
         setOpaque(true);
-        setBackground(couleurdeFond);
         setPreferredSize(new Dimension(64, 64));
         setLayout(new BorderLayout());
 
         // Ajout du label à la case
-        label.setFont(new Font("SansSerif", Font.BOLD, 28));
+        label.setFont(new Font("SansSerif", Font.BOLD, 60));
         add(label, BorderLayout.CENTER);
 
-        this.setBorder(BorderFactory.createLineBorder(Color.DARK_GRAY, 2));
+        this.setBorder(BorderFactory.createLineBorder(Color.DARK_GRAY, 1));
         this.updateFromModel(); // Mise à jour de l'affichage à partir du modèle 
+
+
+        //Ajoutons l'ecouteur 
+        addMouseListener(this);
     }
 
+    @Override
+    public void mouseClicked(MouseEvent e) {
+        Container parent = this.getParent();
+        while(parent != null && !(parent instanceof PlateauSwingUI)) {
+            parent = parent.getParent();
+        }
+        if (parent instanceof PlateauSwingUI plateau) {
+            plateau.selectionnerCase(this);
+        }
+        //System.out.println("Case cliquée : " + ligne + ", " + colonne);
+    }
+
+    @Override
+    public void mousePressed(MouseEvent e) {}
+
+    @Override
+    public void mouseReleased(MouseEvent e) {}
+
+    @Override
+    public void mouseEntered(MouseEvent e) {}
+
+    @Override
+    public void mouseExited(MouseEvent e) {}
+
+    
+    
     @Override
     protected void paintComponent(Graphics pinceaux) {
         super.paintComponent(pinceaux); // Pour effacer l'ancien objet
 
+        Graphics2D g2d = (Graphics2D) pinceaux.create();
+        // Appliquer l'anti-aliasing pour des bords plus doux
+        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+
+        int w = getWidth();
+        int h = getHeight();
+
         // Couleur de fond (jaune)
+        //System.out.println("Selectionner debug: "+selectionnee );
         if(selectionnee){
-            this.setBackground(new Color(255, 215, 0)); // Jaune doux sélectionnée
+            this.setBackground(couleurCaseSelection);
+
+            // Pour le truc de dégradé
+            // //Dégradé radial: claire au centre, foncé aux bords
+            // Color centre = new Color(255, 150, 130); // plus claire au centre
+            // Color bord = new Color(200, 50,  40); // plus foncé aux bords
+            // float[] dist = {0.0f, 1.0f};
+            // Color[] colors = {centre, bord};
+            // RadialGradientPaint gradient = new RadialGradientPaint(
+            //     w / 2f, h / 2f, Math.max(w, h) / 2f, // centre X, centre Y, rayon
+            //     dist,                    // fractions
+            //     colors                   // couleurs
+            // );
+
+            // g2d.setPaint(gradient);
+            // g2d.fillRect(0, 0, w, h);
+
+            // //petit contour plus sombre
+            // g2d.setColor(new Color(150, 30, 30));
+            // g2d.drawRect(0, 0, w-1, h-1);
+
+            
+
         }else{
-            this.setBackground(this.couleurdeFond);
+            // Couleur normale
+            //this.setBackground(this.couleurdeFond);
+            if ((ligne + colonne) % 2 == 0) {
+                g2d.setColor(couleurCaseClaire);
+            } else {
+                g2d.setColor(couleurCaseFoncee);
+            }
+            g2d.fillRect(0, 0, w, h);
+           
         }
+
+        // Surbrillance du dernier coup
+        if(estDernierCoupOrigine) {
+            g2d.setColor(couleurCasePrecedente);
+            g2d.fillRect(0, 0, w, h);
+        }
+
+        if(estDernierCoupDestination) {
+            g2d.setColor(couleurCaseSelection);
+            g2d.fillRect(0, 0, w, h);
+        }
+
+        g2d.dispose(); // Libération des ressources graphiques
     }
 
+
+
+
     // Rafrachit le contenu visuel depuis le model
     public void updateFromModel(){
         Piece p = (caseModele != null) ? caseModele.getPiece(): null;
         label.setText(toUnicode(p));
-        label.setForeground(Color.BLACK);
+        if(p != null) {
-        repaint();
+            label.setForeground(new Color(0,0,0));
+            if (caseModele.getPiece().getCouleur() == Couleur.BLANC) {
+                label.setForeground(new Color(250,250,250));
+            }else{
+                label.setForeground(new Color(30,30,30));
+            }
+        }
+        repaint(); // double appel car setForeground le fais deja
     }
 
     private String toUnicode(Piece piece) {
@@ -60,35 +210,56 @@ public class CaseSwingUI extends JPanel {
         if (piece == null) return "";
         String symbole = piece.getSymbole();
         return switch (symbole) {
-            case "BP" -> "♙";
+            case "BP" -> "♟";
-            case "BC" -> "♘";
+            case "BC" -> "♞";
-            case "BF" -> "♗";
+            case "BF" -> "♝";
-            case "BT" -> "♖";
+            case "BT" -> "♜";
-            case "BQ" -> "♕";
+            case "BR" -> "♛";
-            case "BK" -> "♔";
+            case "BO" -> "♚";
             case "NP" -> "♟";
             case "NC" -> "♞";
             case "NF" -> "♝";
             case "NT" -> "♜";
-            case "NQ" -> "♛";
+            case "NR" -> "♛";
-            case "NK" -> "♚";
+            case "NO" -> "♚";
             default -> symbole;
         };
     }
 
 
     // Getters/setters utiles pour l'IHM
-    public Piece getPiece() { return piece; }
+    public Piece getPiece() {
-    public void setPiece(Piece piece) { this.piece = piece; }
+       return (caseModele != null) ? caseModele.getPiece() : null;
+    }
+    public void setPiece(Piece piece) {
+        if(caseModele !=null ){
+            caseModele.setPiece(piece);
+        }
+        updateFromModel();
+    }
 
+    // Getters pour l'état de sélection
     public boolean isSelectionnee() { return selectionnee; }
-
     public void setSelectionnee(boolean selectionnee) {
         this.selectionnee = selectionnee;
-        this.setBorder(BorderFactory.createLineBorder(selectionnee ? Color.ORANGE : Color.DARK_GRAY,selectionnee ? 4 : 2));
+        //this.setBorder(BorderFactory.createLineBorder(selectionnee ? new Color(248, 161, 87) : Color.DARK_GRAY,selectionnee ? 3 : 1));
         // Repaint pour mettre à jour la couleur de fond
         repaint();
     }
+
+    // Gestion du dernier coup
+    public void setLastOrigin(boolean estDernierCoupOrigine) {
+        this.estDernierCoupOrigine = estDernierCoupOrigine;
+        repaint();
+    }
+    public void setLastDestination(boolean estDernierCoupDestination) {
+        this.estDernierCoupDestination = estDernierCoupDestination;
+        repaint();
+    }
+
+    // Getters pour la position de la case
     public int getLigne() { return ligne; }
     public int getColonne() { return colonne; }
 }
+
+

src/vue/PlateauSwingUI.java

@@ -1,26 +1,43 @@
 package vue;
-import modele.Case;
-import modele.Plateau;
-import javax.swing.*; 
 import java.awt.*;
+import javax.swing.*;
+import modele.Coup;
+import modele.Partie;
+import modele.Plateau; 
+import modele.joueur.Joueur;
+
+
 
 public class PlateauSwingUI extends JPanel {
+    
     private final CaseSwingUI[][] cases = new CaseSwingUI[8][8];
     private final Plateau plateauModele;
+    private final VueGraphiqueSwing vueGraphiqueSwing;
+    private final Partie partieModel;
+
+    // Pour la gestion du dernier coup
+    private Point prevOrigine = null;
+    private Point prevDestination = null;
+
+    private CaseSwingUI caseSelectionnee = null;
+
+
+
+    public PlateauSwingUI(Plateau plateauModel, Partie partieModel,VueGraphiqueSwing vueGraphiqueSwing) {
+        this.plateauModele = plateauModel;
+        this.partieModel = partieModel;
+        this.vueGraphiqueSwing = vueGraphiqueSwing;
 
-    public PlateauSwingUI(Plateau plateauModele) {
-        this.plateauModele = plateauModele;
         setLayout(new GridLayout(8, 8)); // Création de la grille 8x8
         for (int ligne = 0; ligne < 8; ligne++) {
             for (int colonne = 0; colonne < 8; colonne++) {
                 // Détermination de la couleur de fond
-                boolean claire = ((ligne + colonne) % 2 == 0);
+                //boolean estCaseClaire = ((ligne + colonne) % 2 == 0);
-                Color couleur = claire ? new Color(240, 217, 181) : new Color(181, 136, 99);
 
                 // Récupère la case du modèle, ne la crée pas !
                 var caseModele = plateauModele.getCase(ligne, colonne);
                 // Création de la case SwingUI
-                var caseUI = new CaseSwingUI(couleur, ligne, colonne, caseModele);
+                var caseUI = new CaseSwingUI(plateauModele.getStyle(), ligne, colonne, caseModele);
                 cases[ligne][colonne] = caseUI; // Stockage de la case dans le tableau
                 add(caseUI); 
             }
@@ -29,9 +46,10 @@ public class PlateauSwingUI extends JPanel {
 
     // pour rafraîchir l'affichage
     public void rafraichir() {
+        System.out.println("PlateauSwingUI : rafraichir() appelée");
         for (int ligne = 0; ligne < 8; ligne++) {
             for (int colonne = 0; colonne < 8; colonne++) {
-                // Mettre à jour l'état de chaque case
+                //cases[ligne][colonne].setSelectionnee(false);
                 cases[ligne][colonne].updateFromModel();
             }
         }
@@ -41,4 +59,81 @@ public class PlateauSwingUI extends JPanel {
 
     public CaseSwingUI getCase(int ligne, int colonne) {
         return cases[ligne][colonne];
-    s}
+    }
+
+    public void applyLastMove(Coup coup) {
+        // 1) Netoyer ancien
+        if (prevOrigine != null) {
+            cases[prevOrigine.x][prevOrigine.y].setLastOrigin(false);
+            cases[prevOrigine.x][prevOrigine.y].repaint();
+        }
+
+        if (prevDestination != null) {
+            cases[prevDestination.x][prevDestination.y].setLastDestination(false);
+            cases[prevDestination.x][prevDestination.y].repaint();
+        }
+        
+
+        // 2) Appliquons le nouveau coup
+        if (coup != null) {
+            Point O = new Point(coup.getOrigine().x, coup.getOrigine().y);
+            Point D = new Point(coup.getDestination().x, coup.getDestination().y);
+            prevDestination = D;
+
+            cases[O.x][O.y].setLastOrigin(true);
+            cases[D.x][D.y].setLastDestination(true);
+
+            prevOrigine = O;
+            prevDestination = D;
+
+            // 3) Repaint des cases concernées
+            cases[O.x][O.y].repaint();
+            cases[D.x][D.y].repaint();
+        }
+    }
+   
+
+    // Méthode à appeler depuis CaseSwingUI quand une case est cliquée
+    public void selectionnerCase(CaseSwingUI caseCliquee) {
+
+        Joueur joueur = partieModel.getJoueurActif();
+
+        // Etat 0 pas de case selection au paravant
+        if (caseSelectionnee == null) {
+            //1) il faut  une piece
+            var piece = caseCliquee.getPiece();
+            if(piece == null) return; // Pas de pièce sur la case cliquée, rien à faire
+
+            // 2) et que la pièce appartient au joueur actif
+            if(piece.getCouleur() != joueur.getCouleur()) return;
+            
+            caseSelectionnee = caseCliquee;
+            caseCliquee.setSelectionnee(true);
+            
+        // Etat 1 une origine est deja selectionnée
+        }else{
+            if(caseCliquee == caseSelectionnee ){ //  a revoir
+                // re-clique sur la meme case = annuller
+                caseCliquee.setSelectionnee(false);
+                caseSelectionnee = null;
+                return;
+            }
+
+            // 2e clic = destination on fabrique le coup
+            Coup coup = new Coup(
+                caseSelectionnee.getLigne(), caseSelectionnee.getColonne(),
+                caseCliquee.getLigne(), caseCliquee.getColonne()
+            );
+
+            // Rreset visuel + etat
+            caseSelectionnee.setSelectionnee(false);
+            caseSelectionnee = null;
+
+            // transmettre le coup a la vue 
+            vueGraphiqueSwing.recevoirCoup(coup);
+
+            
+        }
+    }
+
+}

src/vue/Vue.java

@@ -7,4 +7,5 @@ public interface Vue {
     Coup demanderCoup(Plateau plateau);        // Demande un coup au joueur
     void afficherPlateau(Plateau plateau);     // Affiche le plateau actuel
     void afficherMessage(String message);      // Affiche un message (texte)
+    void setDernierCoup(Coup coup);            // Met à jour le dernier coup joué
 }

src/vue/VueConsole.java

@@ -72,4 +72,10 @@ public class VueConsole implements Vue {
         return new int[]{ligne, col};
     }
 
+    @Override
+    public void setDernierCoup(Coup coup) {
+        // Implémentation pour mettre à jour le dernier coup joué
+        System.out.println("Dernier coup joué : " + coup);
+    }
+
 }

src/vue/VueGraphiqueSwing.java

@@ -1,30 +1,98 @@
 package vue;
 
-import javax.swing.JFrame;
 import java.awt.*;
-
+import javax.swing.*;
 import modele.Coup;
+import modele.Partie;
 import modele.Plateau;
 
 
 public class VueGraphiqueSwing implements Vue {
+    private Coup c;
     JFrame fen = new JFrame("CHESS GAME");
     private final PlateauSwingUI plateauUI;
+    //private Coup dernierCoup;
 
-    public VueGraphiqueSwing(Plateau plateau) {
+    // Journal systeme
+    private final JTextArea zoneSystem = new JTextArea(10, 24);
+    private final JScrollPane scrollSystem = new JScrollPane(zoneSystem);
+
+    // zone de message for chat
+    private final JTextArea zoneChat = new JTextArea(10, 24);
+    private final JScrollPane scrollChat = new JScrollPane(zoneChat);
+    private final JTextField champChat = new JTextField();
+    private final JButton btnEnvoyer = new JButton("Envoyer");
+
+    public VueGraphiqueSwing(Partie partie) {
         fen.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         fen.setResizable(false);
+        fen.setLayout(new BorderLayout());
 
-        plateauUI = new PlateauSwingUI(plateau); // Passe le modèle
+        //Centre : Gestion du plateau
+        plateauUI = new PlateauSwingUI(partie.getPlateau(), partie, this); // Passe le modèle
         fen.add(plateauUI, BorderLayout.CENTER);
         
-        fen.setSize(800, 800); 
+
+        // Journal systeme (droite, haut)
+        zoneSystem.setEditable(false);
+        zoneSystem.setLineWrap(true);
+        zoneSystem.setWrapStyleWord(true);
+        zoneSystem.setBorder(BorderFactory.createTitledBorder("System"));
+
+        // chat
+        zoneChat.setEditable(false);
+        zoneChat.setLineWrap(true);
+        zoneChat.setWrapStyleWord(true);
+        zoneChat.setBorder(BorderFactory.createTitledBorder("Chat"));
+
+        JPanel chatBas = new JPanel(new BorderLayout(6,0));
+        chatBas.add(champChat, BorderLayout.CENTER);
+        chatBas.add(btnEnvoyer, BorderLayout.EAST);
+
+        JPanel chatPanel = new JPanel(new BorderLayout(0, 4));
+        chatPanel.add(scrollChat, BorderLayout.CENTER);
+        chatPanel.add(chatBas, BorderLayout.SOUTH);
+
+        // Colonne droite : systeme (en haut) et  chat (en bas)
+        JPanel coloneDroite = new JPanel( new BorderLayout(0, 8));
+        coloneDroite.add(scrollSystem, BorderLayout.CENTER);
+        coloneDroite.add(chatPanel, BorderLayout.SOUTH);
+
+        fen.add(coloneDroite, BorderLayout.EAST);
+
+        // Ecouteur pour envoyer le chat
+        btnEnvoyer.addActionListener(e -> envoyerChat());
+        champChat.addActionListener(e -> envoyerChat());
+
+        fen.setSize(1000, 800); 
         //fen.pack(); // ajuste la taille selon le contenu
         fen.setLocationRelativeTo(null); // centre la fenêtre à l'écran
-        
         fen.setVisible(true);
     }
 
+    public void envoyerChat() {
+        String message = champChat.getText().trim();
+        if (!message.isEmpty()) {
+            zoneChat.append("Vous: " + message + "\n");
+            champChat.setText("");
+        }
+    }
+
+    // API de la Vue
+    public void afficherMessageSysteme(String msg) {
+        SwingUtilities.invokeLater(() -> {
+            zoneSystem.append(msg + "\n");
+            zoneSystem.setCaretPosition(zoneSystem.getDocument().getLength());
+        });
+    }
+
+    public void afficherMessageChat(String auteur, String msg) {
+        SwingUtilities.invokeLater(() -> {
+            zoneChat.append("[" + auteur + "]: " + msg + "\n");
+            zoneChat.setCaretPosition(zoneChat.getDocument().getLength());
+        });
+    }
+
     @Override
     public void afficherMessage(String message) {
         // Affichage du message dans la fenêtre graphique
@@ -32,8 +100,17 @@ public class VueGraphiqueSwing implements Vue {
 
     @Override
     public Coup demanderCoup(Plateau plateau) {
-        // Demande un coup au joueur
+        while(this.c == null) {
-        return null;
+            try {
+                Thread.sleep(20); // Attendre un court instant avant de vérifier à nouveau
+            } catch (InterruptedException ex) {
+                Thread.currentThread().interrupt();
+                return null;
+            }
+        }
+        Coup r = c;
+        c = null; // pret pour le coup suivant
+        return r;
     }
 
     @Override
@@ -41,4 +118,14 @@ public class VueGraphiqueSwing implements Vue {
         plateauUI.rafraichir();
     }
 
+    public void recevoirCoup(Coup coup) {
+        this.c = coup;
+        System.out.println("Coup reçu : " + coup);
+    }
+
+    @Override
+    public void setDernierCoup(Coup coup) {
+        //this.dernierCoup = coup;
+        plateauUI.applyLastMove(coup);
+    }
 }