Je commme la vue graphique

README.md

@@ -1,13 +1,13 @@
 src/
-├── modele/               ← 🔵 Couche Modèle (logique du jeu)
+├── modele/               Couche Modèle (logique du jeu)
 │   ├── Partie.java
 │   ├── Plateau.java
 │   ├── Case.java
 │   ├── Coup.java
-│   ├── Couleur.java              ← enum
+│   ├── Couleur.java              enum
-│   ├── ModeDeJeu.java            ← enum
+│   ├── ModeDeJeu.java            enum
 │   ├── piece/
-│   │   ├── Piece.java            ← abstraite
+│   │   ├── Piece.java            abstraite
 │   │   ├── Roi.java
 │   │   ├── Reine.java
 │   │   ├── Tour.java
@@ -15,24 +15,24 @@ src/
 │   │   ├── Fou.java
 │   │   └── Pion.java
 │   ├── joueur/
-│   │   ├── Joueur.java           ← abstraite
+│   │   ├── Joueur.java           abstraite
 │   │   ├── JoueurHumain.java
 │   │   ├── JoueurIA.java
 │   │   └── IA.java
 │
-├── vue/                  ← 🟢 Couche Vue (console ou graphique)
+├── vue/                    Couche Vue (console ou graphique)
-│   ├── Vue.java                  ← interface
+│   ├── Vue.java                  interface
 │   ├── VueConsole.java
 │   ├── VueGraphique.java
 │
-├── controleur/           ← 🟠 Couche Contrôleur
+├── controleur/           Couche Contrôleur
 │   ├── ControleurPartie.java
 │   └── ControleurReseau.java
 │
-├── reseau/               ← 🌐 Réseau (mode en ligne)
+├── reseau/               Réseau (mode en ligne)
 │   ├── MessageJeu.java
-│   ├── TypeMessage.java         ← enum
+│   ├── TypeMessage.java         enum
 │   ├── Serveur.java
 │   └── Client.java
 │
-└── Main.java             ← Point d'entrée du jeu
+└── Main.java             Point d'entrée du jeu

src/Compilateur.bat

@@ -0,0 +1,127 @@
+@echo off
+setlocal EnableExtensions EnableDelayedExpansion
+pushd "%~dp0"
+
+:: === CONFIGURATION ===
+set "OUT=out"
+set "MAIN_CLASS=Main"   :: Si Main est dans un package, ex: monpackage.Main
+:: =====================
+
+if "%~1"=="" goto :help
+
+if /I "%~1"=="help" goto :help
+if /I "%~1"=="clean" goto :clean
+if /I "%~1"=="build" goto :build
+if /I "%~1"=="run" goto :run
+if /I "%~1"=="count" goto :count
+if /I "%~1"=="watch" goto :watch
+if /I "%~1"=="purge" goto :purge
+if /I "%~1"=="rebuild" goto :rebuild
+
+goto :help
+
+:clean
+    if exist "%OUT%" (
+        echo Suppression du dossier "%OUT%"...
+        rmdir /S /Q "%OUT%"
+    ) else (
+        echo Aucun dossier "%OUT%" a supprimer.
+    )
+    goto :eof
+
+
+
+:build
+    where javac >nul 2>nul || (echo([ERREUR] javac introuvable dans le PATH & goto :eof)
+
+    if not exist "%OUT%" mkdir "%OUT%"
+
+    echo(Creation de la liste des sources...
+    dir /s /b *.java > "%TEMP%\sources.txt"
+
+    for /f %%I in ('find /c /v "" ^< "%TEMP%\sources.txt"') do set COUNT=%%I
+    if "%COUNT%"=="0" (
+        echo([ERREUR] Aucun fichier .java trouve dans %cd%
+        del "%TEMP%\sources.txt" >nul 2>nul
+        goto :eof
+    )
+
+    echo(%COUNT% fichiers trouves. Compilation...
+    javac -d "%OUT%" @"%TEMP%\sources.txt"
+    set ERR=%ERRORLEVEL%
+    del "%TEMP%\sources.txt" >nul 2>nul
+
+    if %ERR% EQU 0 (
+        echo(Compilation reussie !
+    ) else (
+        echo([ERREUR] Compilation (code %ERR%)
+    )
+    goto :eof
+ 
+
+
+
+
+:run
+    call :build
+    if %ERR% EQU 0 (
+        echo(
+        echo(Execution de %MAIN_CLASS% ...
+        java -cp "%OUT%" %MAIN_CLASS%
+    )
+    goto :eof
+
+
+:count
+    for /f %%I in ('dir /s /b *.java ^| find /c /v ""') do set COUNT=%%I
+    echo %COUNT% fichiers Java trouves.
+    
+    :: Compte le nombre de ligne des fichier java
+    set /a LIGNES=0
+    for /f "delims=" %%F in ('dir /s /b *.java') do (
+        for /f %%N in ('type "%%F" ^| find /v /c ""') do set /a LIGNES+=%%N
+    )
+    echo %LIGNES% lignes Java trouvees.
+    goto :eof
+
+
+:watch
+    echo Mode surveillance active : recompilation a chaque changement detecte
+    echo Appuie sur Ctrl+C pour quitter.
+    set "LASTSTATE="
+    :loop
+        for /f %%A in ('dir /s /b /a-d *.java') do (
+            set "CURRENTSTATE=!CURRENTSTATE!%%~tA"
+        )
+        if "!CURRENTSTATE!" NEQ "!LASTSTATE!" (
+            set "LASTSTATE=!CURRENTSTATE!"
+            call :build
+        )
+        set "CURRENTSTATE="
+        timeout /t 2 >nul
+        goto loop
+
+:purge
+    echo Suppression des .class hors de "%OUT%"...
+    for /f "delims=" %%C in ('dir /s /b *.class ^| findstr /vi /c:"\%OUT%\"') do del /q "%%C"
+    goto :eof
+
+:rebuild
+    call :clean
+    call :purge
+    call :build
+    goto :eof
+
+
+:help
+    echo Usage: build.bat [option]
+    echo.
+    echo   build   - Compile le projet
+    echo   clean   - Supprime le dossier de sortie "%OUT%"
+    echo   run     - Compile puis lance %MAIN_CLASS%
+    echo   count   - Compte le nombre de fichiers Java
+    echo   watch   - Recompile automatiquement si un fichier change
+    echo   help    - Affiche cette aide
+    echo   purge   - Supprime les .class hors de "%OUT%"
+    echo   rebuild - Nettoie, purge et recompile le projet
+    goto :eof

src/Main.java

@@ -1,4 +1,68 @@
-public class Main {
+import controleur.ControleurPartie;
-    
+import controleur.ControleurReseau;
-}
 
+import modele.ModeDeJeu;
+import modele.Partie;
+import modele.Couleur;
+
+import vue.Vue;
+import vue.VueConsole;
+import vue.VueGraphiqueSwing;
+
+import modele.joueur.Joueur;
+import modele.joueur.JoueurHumain;
+
+
+public class Main {
+    public static void main(String[] args) {
+        // Déclaration des variables nécessaires
+        Vue vue;
+        Joueur joueurBlanc;
+        Joueur joueurNoir;
+        ModeDeJeu modeDeJeu;
+        ControleurReseau controleurReseau = null; // À initialiser si tu utilises le réseau
+
+        int choixMode = 1; // à remplacer par Scanner plus tard
+        int choixAffichage = 3; // 1: Console, 2: JavaFX, 3: Swing
+
+        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);
+
+        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,5 +1,63 @@
 package controleur;
 
+import modele.joueur.*;
+import modele.Coup;
+import modele.Partie;
+import modele.Plateau;
+import modele.ModeDeJeu;
+import vue.Vue;
+
+
 public class ControleurPartie {
-    
+    private Partie partie;
+    private Vue vue;
+    private ControleurReseau controleurReseau;
+    private ModeDeJeu modeDeJeu;
+
+    public ControleurPartie(Partie partie, Vue vue, ControleurReseau controleurReseau, ModeDeJeu modeDeJeu) {
+        this.partie = partie;
+        this.vue = vue;
+        this.controleurReseau = controleurReseau;
+        this.modeDeJeu = modeDeJeu;
+    }
+
+    public void lancerPartie(){
+        System.out.println("===============================");
+        System.out.println("BIENVENUE AU JEU D'ÉCHECS");
+        System.out.println("===============================\n");
+
+
+        vue.afficherMessage("Mode de jeu : " + modeDeJeu);
+        vue.afficherMessage("Joueurs : " + partie.getJoueurBlanc().getNom() + " (Blancs) vs " + partie.getJoueurNoir().getNom() + " (Noirs)");
+        vue.afficherMessage("Les pions Noirs sont en bas. Les pions Blancs sont en haut. \n");
+
+        vue.afficherMessage("------- La Partie commence ! -------");
+        vue.afficherPlateau(partie.getPlateau());
+        //System.out.print("\n");
+        vue.afficherMessage("C'est au tour de " + partie.getJoueurActif().getNom() + " de jouer.");
+        boucleDeJeu();
+    }
+
+    public void boucleDeJeu(){
+        // Boucle principale de la partie
+        while(!partie.estFini()) {
+            try {
+                Joueur joueurPrecedent = partie.getJoueurActif(); // AVANT le tour
+                partie.jouerTour(); // Moteur de jeu
+                Coup dernierCoup = partie.getHistorique().get(partie.getHistorique().size() - 1);
+                vue.afficherPlateau(partie.getPlateau());
+                //System.out.println("");
+                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());
+            }
+        }
+
+        vue.afficherMessage("La partie est terminée !");
+        vue.afficherMessage("Si vous souhaitez rejouer, relancez le programme.");
+        vue.afficherMessage("Si vous souhaitez voir l'historique des coups taper 1. Si vous souhaitez voir les captures taper 2.");
+        vue.afficherMessage("Merci d'avoir joué !");
+    }
+
 }

src/model/Coup.java

@@ -1,23 +0,0 @@
-import  java.awt.Point;
-
-public class Coup {
-    private int xDepart;
-    private int xArrivee;
-    private int yDepart;
-    private int yArrivee;
-
-    public Coup(int xDepart, int yDepart, int xArrivee, int yArrivee) {
-        this.xDepart = xDepart;
-        this.yDepart = yDepart;
-        this.xArrivee = xArrivee;
-        this.yArrivee = yArrivee;
-    }
-
-    public Point getOrigine(){
-        return new Point(xDepart, yDepart);
-    }
-    public Point getDestination(){
-        return new Point(xArrivee, yArrivee);
-    }
-
-}

src/model/ModeDeJeu.java

@@ -1,3 +0,0 @@
-public enum ModeDeJeu {
-    
-}

src/model/Plateau.java

@@ -1,3 +0,0 @@
-public class Plateau {
-    
-}

src/model/joueur/IA.java

@@ -1,5 +0,0 @@
-package joueur;
-
-public class IA {
-    
-}

src/model/joueur/Joueur.java

@@ -1,5 +0,0 @@
-package joueur;
-
-public class Joueur {
-    
-}

src/model/joueur/JoueurHumain.java

@@ -1,5 +0,0 @@
-package joueur;
-
-public class JoueurHumain {
-    
-}

src/model/joueur/JoueurIA.java

@@ -1,5 +0,0 @@
-package joueur;
-
-public class JoueurIA {
-    
-}

src/model/piece/Cavalier.java

@@ -1,5 +0,0 @@
-package piece;
-
-public class Cavalier {
-    
-}

src/model/piece/Fou.java

@@ -1,5 +0,0 @@
-package piece;
-
-public class Fou {
-    
-}

src/model/piece/Piece.java

@@ -1,3 +0,0 @@
-public class Piece {
-    
-}

src/model/piece/Pion.java

@@ -1,5 +0,0 @@
-package piece;
-
-public class Pion {
-    
-}

src/model/piece/Reine.java

@@ -1,5 +0,0 @@
-package piece;
-
-public class Reine {
-    
-}

src/model/piece/Roi.java

@@ -1,5 +0,0 @@
-package piece;
-
-public class Roi {
-    
-}

src/model/piece/Tour.java

@@ -1,5 +0,0 @@
-package piece;
-
-public class Tour {
-    
-}

src/modele/Case.java

@@ -1,3 +1,6 @@
+package modele;
+import  modele.piece.Piece;
+import java.awt.Point;
 
 public class Case {
     private int x;
@@ -25,4 +28,11 @@ public class Case {
     public boolean estVide() {
         return piece == null;
     }
+
+    @Override
+    public String toString() {
+        return "(" + x + "," + y + ")";
+    }
+    
+    
 }

src/modele/Couleur.java

@@ -1,4 +1,6 @@
+package modele;
 public enum Couleur {
     BLANC,
     NOIR;
+
 }

src/modele/Coup.java

@@ -0,0 +1,72 @@
+// package modele;
+// import java.awt.Point;
+// public class Coup {
+//     private int xDepart;
+//     private int xArrivee;
+//     private int yDepart;
+//     private int yArrivee;
+
+//     public Coup(int xDepart, int yDepart, int xArrivee, int yArrivee) {
+//         this.colDepart = colDepart;
+//         this.yDepart = yDepart;
+//         this.xArrivee = xArrivee;
+//         this.yArrivee = yArrivee;
+//     }
+
+//     public Point getOrigine(){
+//         return new Point(xDepart, yDepart);
+//     }
+//     public Point getDestination(){
+//         return new Point(xArrivee, yArrivee);
+//     }
+
+//    @Override
+//     public String toString() {
+//         Point origine = getOrigine();
+//         Point destination = getDestination();
+        
+//         char colOrigine = (char) ('a' + origine.y); // y = colonne
+//         int ligneOrigine = 8 - origine.x;           // x = ligne
+
+//         char colDest = (char) ('a' + destination.y); // y = colonne
+//         int ligneDest = 8 - destination.x;           // x = ligne
+
+//         return " " + colOrigine + ligneOrigine + " -> " + colDest + ligneDest;
+//     }
+
+
+// }
+
+package modele;
+
+import java.awt.Point;
+
+public class Coup {
+    private int ligneDepart;
+    private int colDepart;
+    private int ligneArrivee;
+    private int colArrivee;
+
+    public Coup(int ligneDepart, int colDepart, int ligneArrivee, int colArrivee) {
+        this.ligneDepart = ligneDepart;
+        this.colDepart = colDepart;
+        this.ligneArrivee = ligneArrivee;
+        this.colArrivee = colArrivee;
+    }
+
+    public Point getOrigine() {
+        return new Point(ligneDepart, colDepart); // ligne = x, colonne = y
+    }
+
+    public Point getDestination() {
+        return new Point(ligneArrivee, colArrivee);
+    }
+
+    @Override
+    public String toString() {
+        char colOrigineChar = (char) ('a' + colDepart);
+        char colDestChar = (char) ('a' + colArrivee);
+
+        return " " + colOrigineChar + ligneDepart + " -> " + colDestChar + ligneArrivee;
+    }
+}

src/modele/ModeDeJeu.java

@@ -0,0 +1,8 @@
+package modele;
+public enum ModeDeJeu {
+    IA_VS_HUMAIN,
+    HUMAIN_VS_HUMAIN,
+    RESEAU_SERVEUR,
+    RESEAU_CLIENT,
+    IA_VS_IA;
+}

src/modele/Partie.java

@@ -0,0 +1,139 @@
+package modele;
+
+import modele.piece.Piece;
+import modele.joueur.*;
+
+import java.util.List;
+import java.awt.Point;
+import java.util.ArrayList;
+
+public class Partie{
+    private Plateau plateau;
+    private int nombreCoups;
+    public ModeDeJeu modeDeJeu;
+    
+    private Joueur joueurBlanc;
+    private Joueur joueurNoir;
+    private Joueur joueurActif;
+
+    private List<Coup> historique;
+    private List<Piece> listeCapturesBlancs;
+    private List<Piece> listeCapturesNoires;
+
+    public Partie(Joueur joueurBlanc, Joueur joueurNoir) {
+        plateau = new Plateau();
+        nombreCoups = 0;
+        historique = new ArrayList<>();
+        listeCapturesBlancs = new ArrayList<>();
+        listeCapturesNoires = new ArrayList<>();
+
+        this.joueurBlanc = joueurBlanc;
+        this.joueurNoir = joueurNoir;
+        this.joueurActif = joueurBlanc;
+    }
+
+    public void jouerTour() {
+        // Logique pour jouer un tour
+        Coup coup = joueurActif.jouerCoup(plateau); 
+        Piece piece = plateau.getCase((int)coup.getOrigine().getX(), (int)coup.getOrigine().getY()).getPiece();
+
+        // System.out.println("");
+        // System.out.println("Origine du coup : " + coup.getOrigine());
+        // System.out.println("Destination du coup : " + coup.getDestination());
+        // System.out.println("Contenu de la case d'origine : " + plateau.getCase(coup.getOrigine()).getPiece().getSymbole());
+
+
+        if(piece == null) {
+            throw new IllegalArgumentException("Aucune pièce à la position d'origine.");
+        }
+        if(piece.getCouleur() != joueurActif.getCouleur()) {
+            throw new IllegalArgumentException("Ce n'est pas votre pièce.");
+        }
+        if(!piece.estDeplacementValide(coup, plateau)) {
+            System.out.println("ICI");
+            throw new IllegalArgumentException("Déplacement invalide.");      
+        }
+        // System.out.println("sortie dans partie");
+
+        // Verifie si une capture a lieu
+        Point dest = coup.getDestination();
+        Case caseDestination = plateau.getCase((int) dest.getX(), (int) dest.getY());
+
+        if(caseDestination.getPiece() != null) {
+            Piece pieceCapturee = caseDestination.getPiece();
+            if(pieceCapturee.getCouleur() == joueurActif.getCouleur()) {
+                throw new IllegalArgumentException("Vous ne pouvez pas capturer votre propre pièce.");
+            }
+            
+            // Ajouter la pièce capturée à la liste des captures
+            if(pieceCapturee.getCouleur() == Couleur.BLANC) {
+                listeCapturesBlancs.add(pieceCapturee);
+            } else {
+                listeCapturesNoires.add(pieceCapturee);
+            }
+        }
+
+        // Déplacer la pièce
+        plateau.deplacer(coup);
+        // Ajouter le coup à l'historique
+        ajouterCoup(coup);
+        // Changer de joueur
+        changerJoueur();
+
+    }
+
+    public boolean estFini() {
+        // Logique pour vérifier si la partie est terminée
+        return false;
+    }
+
+    public void changerJoueur() {
+        // Logique pour changer le joueur courant
+        // Par exemple, si le joueur courant est blanc, le changer en noir et vice versa
+        if (joueurActif == joueurBlanc) {
+            joueurActif = joueurNoir;
+        } else {
+            joueurActif = joueurBlanc;
+        }
+    }
+
+    public void ajouterCoup(Coup coup) {
+        // Ajouter le coup à l'historique
+        historique.add(coup);
+        nombreCoups++;
+    }
+
+    public Joueur getJoueurActif() {
+        return joueurActif;
+    }
+
+    public List<Piece> getCapturesParBlanc() {
+        return listeCapturesBlancs;
+    }
+
+    public List<Piece> getCapturesParNoir() {
+        return listeCapturesNoires;
+    }
+
+    public List<Coup> getHistorique() {
+        return historique;
+    }
+
+    public int getNombreCoups() {
+        return nombreCoups;
+    }
+    public Plateau getPlateau() {
+        return plateau;
+    }
+
+    public Joueur getJoueurBlanc() {
+        return joueurBlanc;
+    }
+
+    public Joueur getJoueurNoir() {
+        return joueurNoir;
+    }
+
+}
+
+

src/modele/Plateau.java

@@ -0,0 +1,125 @@
+package modele;
+import java.awt.Point;
+import modele.piece.*;
+
+public class Plateau {
+    Case[][] cases;
+
+    public Plateau(){
+        // Création du plateau de jeu avec 64 cases
+        cases = new Case[8][8];
+        for (int i = 0; i < 8; i++) {
+            for (int j = 0; j < 8; j++) {
+                cases[i][j] = new Case(i, j);
+                //System.out.print("|" + cases[i][j]+ "|");
+            }
+            //System.out.println();
+        }
+
+        // Initialisation du plateau avec les pièces en debut de partie au bon endroit
+        this.initialiser();
+
+    }
+    
+    // public Case getCase(Point position){
+    //     int x = (int) position.getX();
+    //     int y = (int) position.getY();
+    //     return cases[x][y];
+    // }
+
+    // public Case getCase(Point position){
+    //     int x = (int) position.getX(); // colonne
+    //     int y = (int) position.getY(); // ligne
+    //     return cases[y][x]; // et non cases[x][y]
+    // }
+
+    public Case getCase(int ligne, int colonne){
+        return cases[ligne][colonne];
+    }
+
+
+
+    private void initialiser() {
+        // Mise en place des pièces sur le plateau
+        
+        // Placement des pions noirs et blancs
+        for (int i = 0; i < 8; i++) {
+            cases[1][i].setPiece(new modele.piece.Pion(Couleur.BLANC));
+            cases[6][i].setPiece(new modele.piece.Pion(Couleur.NOIR));
+        }
+
+        // Placement des tours noirs et blancs
+        cases[7][0].setPiece(new Tour(Couleur.NOIR));
+        cases[7][7].setPiece(new Tour(Couleur.NOIR));
+        cases[0][0].setPiece(new Tour(Couleur.BLANC));
+        cases[0][7].setPiece(new Tour(Couleur.BLANC));
+
+        // Placement des cavaliers noirs et blancs
+        cases[7][1].setPiece(new Cavalier(Couleur.NOIR));
+        cases[7][6].setPiece(new Cavalier(Couleur.NOIR));
+        cases[0][1].setPiece(new Cavalier(Couleur.BLANC));
+        cases[0][6].setPiece(new Cavalier(Couleur.BLANC));
+
+        // Placement des fous noirs et blancs
+        cases[7][2].setPiece(new Fou(Couleur.NOIR));
+        cases[7][5].setPiece(new Fou(Couleur.NOIR));
+        cases[0][2].setPiece(new Fou(Couleur.BLANC));
+        cases[0][5].setPiece(new Fou(Couleur.BLANC));
+
+        // Placement des rois et reines noirs et blancs
+        cases[7][3].setPiece(new Reine(Couleur.NOIR));
+        cases[7][4].setPiece(new Roi(Couleur.NOIR));
+        cases[0][3].setPiece(new Reine(Couleur.BLANC));
+        cases[0][4].setPiece(new Roi(Couleur.BLANC));
+
+       
+        // Initialisation des cases vides
+        for (int i = 2; i < 6; i++) {
+            for(int j= 0; j < 8; j++) {
+                cases[i][j].setPiece(null);
+                
+            } 
+        }
+
+        // Affichage du plateau après initialisation
+        // System.out.println("Plateau initialisé :");
+        // for (int i = 0; i < 8; i++) {
+        //     System.out.print("Ligne " + (i ) + ": ");
+        //     for (int j = 0; j < 8; j++) {
+        //         System.out.print("|" + cases[i][j] + "|");
+        //     }
+        //     System.out.println();
+        // }
+
+        // System.out.println(cases[0][0]);
+        // System.out.println(cases[0][1]);
+        // System.out.println("");
+
+
+    }
+
+    public void deplacer(Coup coup){
+        Point origine = coup.getOrigine();
+        Point destination = coup.getDestination();
+
+        Case caseOrigine = getCase((int) origine.getX(), (int) origine.getY());
+        Case caseDestination = getCase((int) destination.getX(), (int) destination.getY());
+
+        System.out.println("case origine: "+ caseOrigine);
+        System.out.println("case destination: "+ caseDestination);
+
+        Piece piece = caseOrigine.getPiece();
+        if(piece == null) {
+            throw new IllegalArgumentException("Aucune pièce à la position d'origine.");
+        }
+        // if(!piece.estDeplacementValide(coup, this)) {
+        //     throw new IllegalArgumentException("Déplacement invalide.");
+        // }
+
+        // Déplacer la pièce de la case d'origine à la case de destination
+        caseDestination.setPiece(piece);
+        caseOrigine.setPiece(null);
+
+      
+    }
+}

src/modele/joueur/IA.java

@@ -0,0 +1,20 @@
+package modele.joueur;
+
+import modele.Plateau;
+import modele.Coup;
+
+
+public class IA {
+    private final int profondeur ; // Profondeur maximale de recherche pour l'IA
+
+    public IA(int profondeur) {
+        this.profondeur = profondeur;
+    }
+
+
+    public Coup meilleurCoup(Plateau plateau) {
+        // Implémentation de la logique de l'IA pour calculer le coup
+        // Pour l'instant, on retourne null ou un coup par défaut
+        return null; // Placeholder, à remplacer par la logique d'IA réelle
+    }
+}

src/modele/joueur/Joueur.java

@@ -0,0 +1,30 @@
+package modele.joueur;
+
+import modele.Couleur;
+import modele.Coup;
+import modele.Plateau;
+
+public abstract class Joueur {
+    private final Couleur couleur;
+    private String nom;
+
+    public Joueur(Couleur couleur, String nom) {
+        this.couleur = couleur;
+        this.nom = nom;
+    }
+
+    public Couleur getCouleur() {
+       return couleur;
+    }
+
+    public String getNom() {
+        return nom;
+    }
+
+    public boolean  estReseau() {
+        return false; // Par défaut, le joueur n'est pas un réseau
+    }
+
+
+    public abstract Coup jouerCoup(Plateau plateau);
+}

src/modele/joueur/JoueurHumain.java

@@ -0,0 +1,28 @@
+package modele.joueur;
+
+import vue.Vue;
+import modele.Couleur;
+import modele.Coup;
+import modele.Plateau;
+
+public class JoueurHumain extends Joueur {
+    private Vue vue; 
+    private boolean reseau;
+
+    public JoueurHumain(Couleur couleur, Vue vue, boolean reseau, String nom) {
+        super(couleur, nom);
+        this.vue = vue;
+        this.reseau = reseau;
+    }
+
+    @Override
+    public boolean estReseau() {
+        return reseau;
+    }
+
+    @Override
+    public Coup jouerCoup(Plateau plateau) {
+        return vue.demanderCoup(plateau); // la vue s'adapte si c'est réseau ou pas
+    }
+}
+

src/modele/joueur/JoueurIA.java

@@ -0,0 +1,28 @@
+package modele.joueur;
+
+import vue.Vue;
+import modele.Couleur;
+import modele.Coup;
+import modele.Plateau;
+
+public class JoueurIA extends Joueur {
+    private Vue vue; 
+    private IA ia;
+
+    public JoueurIA(Couleur couleur, Vue vue) {
+        super(couleur, "IA");
+        this.vue = vue;
+        this.ia = new IA(3); // Valeur par défaut pour la profondeur maximale
+    }
+
+    @Override
+    public Coup jouerCoup(Plateau plateau) {
+        return ia.meilleurCoup(plateau);
+    }
+
+    @Override
+    public boolean estReseau() {
+        return false;
+    }
+
+}

src/modele/piece/Cavalier.java

@@ -0,0 +1,47 @@
+package modele.piece;
+import java.awt.*;
+
+import modele.Case;
+import modele.Couleur;
+import modele.Coup;
+import modele.Plateau;
+
+public class Cavalier extends Piece{
+    public Cavalier(Couleur couleur) {
+        super(couleur);
+        if(couleur == Couleur.BLANC) {
+            this.symbole = "BC"; // Symbole pour le cavalier blanc
+        } else {
+            this.symbole = "NC"; // Symbole pour le cavalier noir
+        }
+    }
+
+    @Override
+    public boolean estDeplacementValide(Coup coup, Plateau plateau) {
+        Point origine = coup.getOrigine();
+        Point destination = coup.getDestination();
+
+        // Conventions : Point.x = ligne, Point.y = colonne
+        int ligneOrigine = origine.x;
+        int colOrigine   = origine.y;
+        int ligneDest    = destination.x;
+        int colDest      = destination.y;
+
+        // bornes de plateau
+        if (ligneDest < 0 || ligneDest > 7 || colDest < 0 || colDest > 7) return false;
+
+        int deltaLigne = Math.abs(ligneDest - ligneOrigine);
+        int deltaCol   = Math.abs(colDest   - colOrigine);
+
+        // mouvement en "L"
+        boolean enL = (deltaLigne == 2 && deltaCol == 1) || (deltaLigne == 1 && deltaCol == 2);
+        if (!enL) return false;
+
+        // Etat de la case de destination
+        Case caseDest = plateau.getCase(ligneDest, colDest);
+        if (caseDest.estVide()) return true;
+
+        // si la case est occupée
+        return caseDest.getPiece().getCouleur() != this.getCouleur(); 
+    }
+}

src/modele/piece/Fou.java

@@ -0,0 +1,21 @@
+package modele.piece;
+import modele.Couleur;
+import modele.Coup;
+import modele.Plateau;
+
+public class Fou extends Piece{
+    public Fou(Couleur couleur) {
+        super(couleur);
+        if(couleur == Couleur.BLANC) {
+            this.symbole = "BF"; // Symbole pour le fou blanc
+        } else {
+            this.symbole = "NF"; // Symbole pour le fou noir
+        }
+    }
+
+    @Override    
+    public boolean estDeplacementValide(Coup coup, Plateau plateau) {
+        // Implémentation de la validation du déplacement pour le fou
+        return false;
+    } 
+}

src/modele/piece/Piece.java

@@ -0,0 +1,34 @@
+package modele.piece;
+
+import modele.Couleur;
+import modele.Coup;
+import modele.Plateau;
+
+public abstract class Piece {
+    private final Couleur couleur;
+    protected String symbole;
+
+    public Piece(Couleur couleur) {
+        this.couleur = couleur;
+        this.symbole = ""; // Symbole par défaut, redéfini dans les sous-classes
+    }
+
+
+    public Couleur getCouleur() {
+        return this.couleur;
+    }
+
+    public String getSymbole() {
+        return symbole;
+    }
+
+    public abstract boolean estDeplacementValide(Coup coup, Plateau plateau);
+
+
+    @Override
+    public String toString() {
+        return this.getClass().getSimpleName() + " " + this.couleur;
+    }
+
+
+}

src/modele/piece/Pion.java

@@ -0,0 +1,77 @@
+package modele.piece;
+
+import java.awt.Point;
+import modele.Couleur;
+import modele.Coup;
+import modele.Plateau;
+
+public class Pion extends Piece {
+    
+    public Pion(Couleur couleur){
+        super(couleur); 
+        if(couleur == Couleur.BLANC) {
+            this.symbole = "BP"; // Symbole pour le pion blanc
+        } else {
+            this.symbole = "NP"; // Symbole pour le pion noir
+        }
+    }
+
+
+    @Override
+    public boolean estDeplacementValide(Coup coup, Plateau plateau) {
+        //System.out.println("\nsuis dans estDeplacement valide\n");
+
+        Point origine = coup.getOrigine();
+        Point destination = coup.getDestination();
+
+        int ligneOrigine = (int) origine.getX();
+        int colOrigine = (int) origine.getY();
+        int ligneDestination = (int) destination.getX();
+        int colDestination = (int) destination.getY();
+
+        int deltaLigne = (ligneDestination - ligneOrigine);
+        int deltaCol = (colDestination - colOrigine);
+
+        int direction = (this.getCouleur() == Couleur.BLANC) ? 1 : -1;
+
+        boolean ligneDepart = (this.getCouleur() == Couleur.BLANC && ligneOrigine == 1) ||
+                            (this.getCouleur() == Couleur.NOIR && ligneOrigine == 6);
+
+        boolean deplacementVertical = deltaCol == 0 && deltaLigne == direction;
+        boolean deplacementVerticalDouble = deltaCol == 0 && deltaLigne == 2 * direction;
+
+        /*
+        System.out.println("Origine : ligne = " + ligneOrigine + ", col = " + colOrigine);
+        System.out.println("Destination : ligne = " + ligneDestination + ", col = " + colDestination);
+        System.out.println("deltaLigne = " + deltaLigne);
+        System.out.println("deltaCol = " + deltaCol);
+        System.out.println("Direction = " + direction);
+        System.out.println("Contenu destination : " + plateau.getCase(ligneDestination, colDestination).getPiece());
+        */
+
+        // Déplacement simple
+        if (deplacementVertical && plateau.getCase(ligneDestination, colDestination).estVide()) {
+            return true;
+        }
+
+        // Déplacement double
+        if (deplacementVerticalDouble && ligneDepart) {
+            int ligneIntermediaire = ligneOrigine + direction;
+            if (plateau.getCase(ligneDestination, colDestination).estVide() &&
+                plateau.getCase(ligneIntermediaire, colDestination).estVide()) {
+                return true;
+            }
+        }
+
+        // Capture en diagonale
+        if (Math.abs(deltaCol) == 1 && deltaLigne == direction) {
+            Piece pieceCible = plateau.getCase(ligneDestination, colDestination).getPiece();
+            if (pieceCible != null && pieceCible.getCouleur() != this.getCouleur()) {
+                return true;
+            }
+        }
+
+        //System.out.println("\nJe sors de estDeplacementValide\n");
+        return false;
+    }
+}

src/modele/piece/Reine.java

@@ -0,0 +1,22 @@
+package modele.piece;
+import modele.Couleur;
+import modele.Coup;
+import modele.Plateau;
+
+public class Reine extends Piece{
+    public Reine(Couleur couleur) {
+        super(couleur);
+        if(couleur == Couleur.BLANC) {
+            this.symbole = "BR"; // Symbole pour la reine blanche
+        } else {
+            this.symbole = "NR"; // Symbole pour la reine noire
+        }
+    }
+
+
+    @Override
+    public boolean estDeplacementValide(Coup coup, Plateau plateau) {
+        // Implémentation de la validation du déplacement pour la reine
+        return false;
+    }
+}

src/modele/piece/Roi.java

@@ -0,0 +1,17 @@
+package modele.piece;
+import modele.Couleur;
+import modele.Coup;
+import modele.Plateau;
+
+public class Roi extends Piece{
+    public Roi(Couleur couleur) {
+        super(couleur);
+        this.symbole = (couleur == Couleur.BLANC) ? "BO" : "NO"; // Symbole pour le roi blanc et noir
+    }
+
+    @Override    
+    public boolean estDeplacementValide(Coup coup, Plateau plateau) {
+        // Implémentation de la validation du déplacement pour le roi
+        return false;
+    } 
+}

src/modele/piece/Tour.java

@@ -0,0 +1,21 @@
+package modele.piece;
+import modele.Couleur;
+import modele.Coup;
+import modele.Plateau;
+
+public class Tour extends Piece{
+    public Tour(Couleur couleur) {
+        super(couleur);
+        if(couleur == Couleur.BLANC) {
+            this.symbole = "BT"; // Symbole pour la tour blanche
+        } else {
+            this.symbole = "NT"; // Symbole pour la tour noire
+        }
+    }
+
+    @Override    
+    public boolean estDeplacementValide(Coup coup, Plateau plateau) {
+        // Implémentation de la validation du déplacement pour la tour
+        return false;
+    } 
+}