diff --git a/README.md b/README.md index 2884684..d81b5e5 100644 --- a/README.md +++ b/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 -│ ├── ModeDeJeu.java ← enum +│ ├── Couleur.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.java ← interface +├── vue/ Couche Vue (console ou graphique) +│ ├── 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 diff --git a/src/Compilateur.bat b/src/Compilateur.bat new file mode 100644 index 0000000..67b919f --- /dev/null +++ b/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 diff --git a/src/Main.java b/src/Main.java index ded306f..048d091 100644 --- a/src/Main.java +++ b/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(); + } +} diff --git a/src/controleur/ControleurPartie.java b/src/controleur/ControleurPartie.java index 490275b..39a1e8d 100644 --- a/src/controleur/ControleurPartie.java +++ b/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é !"); + } + } diff --git a/src/model/Coup.java b/src/model/Coup.java deleted file mode 100644 index d959129..0000000 --- a/src/model/Coup.java +++ /dev/null @@ -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); - } - -} diff --git a/src/model/ModeDeJeu.java b/src/model/ModeDeJeu.java deleted file mode 100644 index 6d78352..0000000 --- a/src/model/ModeDeJeu.java +++ /dev/null @@ -1,3 +0,0 @@ -public enum ModeDeJeu { - -} diff --git a/src/model/Partie.java b/src/model/Partie.java deleted file mode 100644 index e69de29..0000000 diff --git a/src/model/Plateau.java b/src/model/Plateau.java deleted file mode 100644 index f5e1fc4..0000000 --- a/src/model/Plateau.java +++ /dev/null @@ -1,3 +0,0 @@ -public class Plateau { - -} diff --git a/src/model/joueur/IA.java b/src/model/joueur/IA.java deleted file mode 100644 index 54eb1c9..0000000 --- a/src/model/joueur/IA.java +++ /dev/null @@ -1,5 +0,0 @@ -package joueur; - -public class IA { - -} diff --git a/src/model/joueur/Joueur.java b/src/model/joueur/Joueur.java deleted file mode 100644 index 2b47b54..0000000 --- a/src/model/joueur/Joueur.java +++ /dev/null @@ -1,5 +0,0 @@ -package joueur; - -public class Joueur { - -} diff --git a/src/model/joueur/JoueurHumain.java b/src/model/joueur/JoueurHumain.java deleted file mode 100644 index af11573..0000000 --- a/src/model/joueur/JoueurHumain.java +++ /dev/null @@ -1,5 +0,0 @@ -package joueur; - -public class JoueurHumain { - -} diff --git a/src/model/joueur/JoueurIA.java b/src/model/joueur/JoueurIA.java deleted file mode 100644 index 881a3ff..0000000 --- a/src/model/joueur/JoueurIA.java +++ /dev/null @@ -1,5 +0,0 @@ -package joueur; - -public class JoueurIA { - -} diff --git a/src/model/piece/Cavalier.java b/src/model/piece/Cavalier.java deleted file mode 100644 index 5f64be4..0000000 --- a/src/model/piece/Cavalier.java +++ /dev/null @@ -1,5 +0,0 @@ -package piece; - -public class Cavalier { - -} diff --git a/src/model/piece/Fou.java b/src/model/piece/Fou.java deleted file mode 100644 index adb1668..0000000 --- a/src/model/piece/Fou.java +++ /dev/null @@ -1,5 +0,0 @@ -package piece; - -public class Fou { - -} diff --git a/src/model/piece/Piece.java b/src/model/piece/Piece.java deleted file mode 100644 index 9fe09bd..0000000 --- a/src/model/piece/Piece.java +++ /dev/null @@ -1,3 +0,0 @@ -public class Piece { - -} diff --git a/src/model/piece/Pion.java b/src/model/piece/Pion.java deleted file mode 100644 index 250e85d..0000000 --- a/src/model/piece/Pion.java +++ /dev/null @@ -1,5 +0,0 @@ -package piece; - -public class Pion { - -} diff --git a/src/model/piece/Reine.java b/src/model/piece/Reine.java deleted file mode 100644 index 6439724..0000000 --- a/src/model/piece/Reine.java +++ /dev/null @@ -1,5 +0,0 @@ -package piece; - -public class Reine { - -} diff --git a/src/model/piece/Roi.java b/src/model/piece/Roi.java deleted file mode 100644 index 49b7318..0000000 --- a/src/model/piece/Roi.java +++ /dev/null @@ -1,5 +0,0 @@ -package piece; - -public class Roi { - -} diff --git a/src/model/piece/Tour.java b/src/model/piece/Tour.java deleted file mode 100644 index 6c300d0..0000000 --- a/src/model/piece/Tour.java +++ /dev/null @@ -1,5 +0,0 @@ -package piece; - -public class Tour { - -} diff --git a/src/model/Case.java b/src/modele/Case.java similarity index 74% rename from src/model/Case.java rename to src/modele/Case.java index f76a868..f61bf38 100644 --- a/src/model/Case.java +++ b/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 + ")"; + } + + } diff --git a/src/model/Couleur.java b/src/modele/Couleur.java similarity index 72% rename from src/model/Couleur.java rename to src/modele/Couleur.java index f704115..70e9fb0 100644 --- a/src/model/Couleur.java +++ b/src/modele/Couleur.java @@ -1,4 +1,6 @@ +package modele; public enum Couleur { BLANC, NOIR; + } \ No newline at end of file diff --git a/src/modele/Coup.java b/src/modele/Coup.java new file mode 100644 index 0000000..0f58583 --- /dev/null +++ b/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; + } +} diff --git a/src/modele/ModeDeJeu.java b/src/modele/ModeDeJeu.java new file mode 100644 index 0000000..d12e80f --- /dev/null +++ b/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; +} diff --git a/src/modele/Partie.java b/src/modele/Partie.java new file mode 100644 index 0000000..03a4904 --- /dev/null +++ b/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 historique; + private List listeCapturesBlancs; + private List 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 getCapturesParBlanc() { + return listeCapturesBlancs; + } + + public List getCapturesParNoir() { + return listeCapturesNoires; + } + + public List getHistorique() { + return historique; + } + + public int getNombreCoups() { + return nombreCoups; + } + public Plateau getPlateau() { + return plateau; + } + + public Joueur getJoueurBlanc() { + return joueurBlanc; + } + + public Joueur getJoueurNoir() { + return joueurNoir; + } + +} + + diff --git a/src/modele/Plateau.java b/src/modele/Plateau.java new file mode 100644 index 0000000..5a04ebf --- /dev/null +++ b/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); + + + } +} diff --git a/src/modele/joueur/IA.java b/src/modele/joueur/IA.java new file mode 100644 index 0000000..3df87a1 --- /dev/null +++ b/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 + } +} diff --git a/src/modele/joueur/Joueur.java b/src/modele/joueur/Joueur.java new file mode 100644 index 0000000..32a7b2d --- /dev/null +++ b/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); +} diff --git a/src/modele/joueur/JoueurHumain.java b/src/modele/joueur/JoueurHumain.java new file mode 100644 index 0000000..3249f23 --- /dev/null +++ b/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 + } +} + diff --git a/src/modele/joueur/JoueurIA.java b/src/modele/joueur/JoueurIA.java new file mode 100644 index 0000000..bac5cb2 --- /dev/null +++ b/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; + } + +} diff --git a/src/modele/piece/Cavalier.java b/src/modele/piece/Cavalier.java new file mode 100644 index 0000000..97573ec --- /dev/null +++ b/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(); + } +} \ No newline at end of file diff --git a/src/modele/piece/Fou.java b/src/modele/piece/Fou.java new file mode 100644 index 0000000..a9c2c12 --- /dev/null +++ b/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; + } +} diff --git a/src/modele/piece/Piece.java b/src/modele/piece/Piece.java new file mode 100644 index 0000000..103335a --- /dev/null +++ b/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; + } + + +} diff --git a/src/modele/piece/Pion.java b/src/modele/piece/Pion.java new file mode 100644 index 0000000..b4901de --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/src/modele/piece/Reine.java b/src/modele/piece/Reine.java new file mode 100644 index 0000000..6b947f3 --- /dev/null +++ b/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; + } +} diff --git a/src/modele/piece/Roi.java b/src/modele/piece/Roi.java new file mode 100644 index 0000000..6534784 --- /dev/null +++ b/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; + } +} diff --git a/src/modele/piece/Tour.java b/src/modele/piece/Tour.java new file mode 100644 index 0000000..c565123 --- /dev/null +++ b/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; + } +} diff --git a/src/out/Main.class b/src/out/Main.class new file mode 100644 index 0000000..75a55a3 Binary files /dev/null and b/src/out/Main.class differ diff --git a/src/out/controleur/ControleurPartie.class b/src/out/controleur/ControleurPartie.class new file mode 100644 index 0000000..81056de Binary files /dev/null and b/src/out/controleur/ControleurPartie.class differ diff --git a/src/out/controleur/ControleurReseau.class b/src/out/controleur/ControleurReseau.class new file mode 100644 index 0000000..721ee56 Binary files /dev/null and b/src/out/controleur/ControleurReseau.class differ diff --git a/src/out/modele/Case.class b/src/out/modele/Case.class new file mode 100644 index 0000000..60bc695 Binary files /dev/null and b/src/out/modele/Case.class differ diff --git a/src/out/modele/Couleur.class b/src/out/modele/Couleur.class new file mode 100644 index 0000000..b0ae2de Binary files /dev/null and b/src/out/modele/Couleur.class differ diff --git a/src/out/modele/Coup.class b/src/out/modele/Coup.class new file mode 100644 index 0000000..dc826b0 Binary files /dev/null and b/src/out/modele/Coup.class differ diff --git a/src/out/modele/ModeDeJeu.class b/src/out/modele/ModeDeJeu.class new file mode 100644 index 0000000..9c503e1 Binary files /dev/null and b/src/out/modele/ModeDeJeu.class differ diff --git a/src/out/modele/Partie.class b/src/out/modele/Partie.class new file mode 100644 index 0000000..9bd6344 Binary files /dev/null and b/src/out/modele/Partie.class differ diff --git a/src/out/modele/Plateau.class b/src/out/modele/Plateau.class new file mode 100644 index 0000000..130cd61 Binary files /dev/null and b/src/out/modele/Plateau.class differ diff --git a/src/out/modele/joueur/IA.class b/src/out/modele/joueur/IA.class new file mode 100644 index 0000000..4f92ad2 Binary files /dev/null and b/src/out/modele/joueur/IA.class differ diff --git a/src/out/modele/joueur/Joueur.class b/src/out/modele/joueur/Joueur.class new file mode 100644 index 0000000..edeffc9 Binary files /dev/null and b/src/out/modele/joueur/Joueur.class differ diff --git a/src/out/modele/joueur/JoueurHumain.class b/src/out/modele/joueur/JoueurHumain.class new file mode 100644 index 0000000..0f096f5 Binary files /dev/null and b/src/out/modele/joueur/JoueurHumain.class differ diff --git a/src/out/modele/joueur/JoueurIA.class b/src/out/modele/joueur/JoueurIA.class new file mode 100644 index 0000000..6ac92d0 Binary files /dev/null and b/src/out/modele/joueur/JoueurIA.class differ diff --git a/src/out/modele/piece/Cavalier.class b/src/out/modele/piece/Cavalier.class new file mode 100644 index 0000000..c6896f9 Binary files /dev/null and b/src/out/modele/piece/Cavalier.class differ diff --git a/src/out/modele/piece/Fou.class b/src/out/modele/piece/Fou.class new file mode 100644 index 0000000..ece9d31 Binary files /dev/null and b/src/out/modele/piece/Fou.class differ diff --git a/src/out/modele/piece/Piece.class b/src/out/modele/piece/Piece.class new file mode 100644 index 0000000..c9c929b Binary files /dev/null and b/src/out/modele/piece/Piece.class differ diff --git a/src/out/modele/piece/Pion.class b/src/out/modele/piece/Pion.class new file mode 100644 index 0000000..3e454d6 Binary files /dev/null and b/src/out/modele/piece/Pion.class differ diff --git a/src/out/modele/piece/Reine.class b/src/out/modele/piece/Reine.class new file mode 100644 index 0000000..9c2b03c Binary files /dev/null and b/src/out/modele/piece/Reine.class differ diff --git a/src/out/modele/piece/Roi.class b/src/out/modele/piece/Roi.class new file mode 100644 index 0000000..6a7e538 Binary files /dev/null and b/src/out/modele/piece/Roi.class differ diff --git a/src/out/modele/piece/Tour.class b/src/out/modele/piece/Tour.class new file mode 100644 index 0000000..7d22e55 Binary files /dev/null and b/src/out/modele/piece/Tour.class differ diff --git a/src/out/reseau/Client.class b/src/out/reseau/Client.class new file mode 100644 index 0000000..0fff62b Binary files /dev/null and b/src/out/reseau/Client.class differ diff --git a/src/out/reseau/MessageJeu.class b/src/out/reseau/MessageJeu.class new file mode 100644 index 0000000..cd8fdee Binary files /dev/null and b/src/out/reseau/MessageJeu.class differ diff --git a/src/out/reseau/Serveur.class b/src/out/reseau/Serveur.class new file mode 100644 index 0000000..d0b5b16 Binary files /dev/null and b/src/out/reseau/Serveur.class differ diff --git a/src/out/reseau/TypeMessage.class b/src/out/reseau/TypeMessage.class new file mode 100644 index 0000000..e104126 Binary files /dev/null and b/src/out/reseau/TypeMessage.class differ diff --git a/src/out/vue/CaseSwingUI.class b/src/out/vue/CaseSwingUI.class new file mode 100644 index 0000000..e0e6be7 Binary files /dev/null and b/src/out/vue/CaseSwingUI.class differ diff --git a/src/out/vue/PlateauSwingUI.class b/src/out/vue/PlateauSwingUI.class new file mode 100644 index 0000000..15e29af Binary files /dev/null and b/src/out/vue/PlateauSwingUI.class differ diff --git a/src/out/vue/Vue.class b/src/out/vue/Vue.class new file mode 100644 index 0000000..df4f12e Binary files /dev/null and b/src/out/vue/Vue.class differ diff --git a/src/out/vue/VueConsole.class b/src/out/vue/VueConsole.class new file mode 100644 index 0000000..b895161 Binary files /dev/null and b/src/out/vue/VueConsole.class differ diff --git a/src/out/vue/VueGraphiqueSwing.class b/src/out/vue/VueGraphiqueSwing.class new file mode 100644 index 0000000..94c9efb Binary files /dev/null and b/src/out/vue/VueGraphiqueSwing.class differ diff --git a/src/vue/CaseSwingUI.java b/src/vue/CaseSwingUI.java new file mode 100644 index 0000000..d089dc8 --- /dev/null +++ b/src/vue/CaseSwingUI.java @@ -0,0 +1,94 @@ +package vue; + +import modele.piece.Piece; +import java.awt.*; +import java.lang.ref.Reference; +import modele.Case; +import javax.swing.*; + +public class CaseSwingUI extends JPanel { + private int ligne; + private int colonne; + + private Color couleurdeFond; + 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) { + this.couleurdeFond = couleurdeFond; + this.ligne = ligne; + this.colonne = colonne; + this.caseModele = caseModele; + + 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)); + add(label, BorderLayout.CENTER); + + this.setBorder(BorderFactory.createLineBorder(Color.DARK_GRAY, 2)); + this.updateFromModel(); // Mise à jour de l'affichage à partir du modèle + } + + @Override + protected void paintComponent(Graphics pinceaux) { + super.paintComponent(pinceaux); // Pour effacer l'ancien objet + + // Couleur de fond (jaune) + if(selectionnee){ + this.setBackground(new Color(255, 215, 0)); // Jaune doux sélectionnée + }else{ + this.setBackground(this.couleurdeFond); + } + } + + // 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); + repaint(); + } + + private String toUnicode(Piece piece) { + // Conversion du symbole en caractère Unicode + if (piece == null) return ""; + String symbole = piece.getSymbole(); + return switch (symbole) { + case "BP" -> "♙"; + case "BC" -> "♘"; + case "BF" -> "♗"; + case "BT" -> "♖"; + case "BQ" -> "♕"; + case "BK" -> "♔"; + case "NP" -> "♟"; + case "NC" -> "♞"; + case "NF" -> "♝"; + case "NT" -> "♜"; + case "NQ" -> "♛"; + case "NK" -> "♚"; + default -> symbole; + }; + } + + + // Getters/setters utiles pour l'IHM + public Piece getPiece() { return piece; } + public void setPiece(Piece piece) { this.piece = piece; } + + 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)); + // Repaint pour mettre à jour la couleur de fond + repaint(); + } + public int getLigne() { return ligne; } + public int getColonne() { return colonne; } +} \ No newline at end of file diff --git a/src/vue/PlateauSwingUI.java b/src/vue/PlateauSwingUI.java new file mode 100644 index 0000000..e913972 --- /dev/null +++ b/src/vue/PlateauSwingUI.java @@ -0,0 +1,44 @@ +package vue; +import modele.Case; +import modele.Plateau; +import javax.swing.*; +import java.awt.*; + +public class PlateauSwingUI extends JPanel { + private final CaseSwingUI[][] cases = new CaseSwingUI[8][8]; + private final Plateau plateauModele; + + 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); + 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); + cases[ligne][colonne] = caseUI; // Stockage de la case dans le tableau + add(caseUI); + } + } + } + + // pour rafraîchir l'affichage + public void rafraichir() { + for (int ligne = 0; ligne < 8; ligne++) { + for (int colonne = 0; colonne < 8; colonne++) { + // Mettre à jour l'état de chaque case + cases[ligne][colonne].updateFromModel(); + } + } + revalidate(); // vérifie la disposition des composants + repaint(); + } + + public CaseSwingUI getCase(int ligne, int colonne) { + return cases[ligne][colonne]; + s} diff --git a/src/vue/Vue.java b/src/vue/Vue.java index 2345bad..a18a3d8 100644 --- a/src/vue/Vue.java +++ b/src/vue/Vue.java @@ -1,5 +1,10 @@ package vue; -public class Vue { - +import modele.Coup; +import modele.Plateau; + +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) } diff --git a/src/vue/VueConsole.java b/src/vue/VueConsole.java index ef52fac..8da6540 100644 --- a/src/vue/VueConsole.java +++ b/src/vue/VueConsole.java @@ -1,5 +1,75 @@ package vue; -public class VueConsole { +import java.util.Scanner; +import modele.Case; +import modele.Coup; +import modele.Plateau; +import modele.piece.Piece; +public class VueConsole implements Vue { + + + @Override + public Coup demanderCoup(Plateau plateau) { + // Implémentation pour demander un coup à l'utilisateur + Scanner scanner = new Scanner(System.in); + System.out.print("Entrez votre coup (ex: e2 e4) : "); + String input = scanner.nextLine(); + + // Traitement de l'entrée de l'utilisateur + String[] positions = input.split(" "); + if (positions.length != 2) { + System.out.println("Format de coup invalide."); + return null; + } + + String positionDepart = positions[0]; + String positionArrivee = positions[1]; + int[] coordDepart = convertirPositionEnCoordonnees(positionDepart); + int[] coordArrivee = convertirPositionEnCoordonnees(positionArrivee); + // covertion en colonne et ligne + int ligneDepart = coordDepart[0]; // c'est le y + int colonneDepart = coordDepart[1]; // c'est le x + int ligneArrivee = coordArrivee[0]; // c'est le y + int colonneArrivee = coordArrivee[1]; // c'est le x + + // Création du coup + return new Coup(ligneDepart, colonneDepart, ligneArrivee, colonneArrivee); + } + + @Override + public void afficherPlateau(Plateau plateau) { + System.out.println("\n a b c d e f g h"); + System.out.println(" +----+----+----+----+----+----+----+----+"); + + for (int ligne = 0; ligne < 8; ligne++) { + System.out.print((ligne) + " |"); + for (int col = 0; col < 8; col++) { + Case caseActuelle = plateau.getCase(ligne, col); + if (caseActuelle.estVide()) { + System.out.print(" |"); + } else { + Piece piece = caseActuelle.getPiece(); + System.out.print(" " + piece.getSymbole() + " |"); + } + } + System.out.println(" " + ligne); + System.out.println(" +----+----+----+----+----+----+----+----+"); + } + + System.out.println(" a b c d e f g h\n"); + } + + + + @Override + public void afficherMessage(String message) { + System.out.println(message); // Affiche le message dans la console + } + + private int[] convertirPositionEnCoordonnees(String position) { + int col = position.charAt(0) - 'a'; // Convertit 'a' à 'h' en 0 à 7 + int ligne = Character.getNumericValue(position.charAt(1)); // Convertit '0' à '7' + return new int[]{ligne, col}; + } } diff --git a/src/vue/VueGraphique.java b/src/vue/VueGraphique.java deleted file mode 100644 index 3d8acc3..0000000 --- a/src/vue/VueGraphique.java +++ /dev/null @@ -1,5 +0,0 @@ -package vue; - -public class VueGraphique { - -} diff --git a/src/vue/VueGraphiqueSwing.java b/src/vue/VueGraphiqueSwing.java new file mode 100644 index 0000000..422dca3 --- /dev/null +++ b/src/vue/VueGraphiqueSwing.java @@ -0,0 +1,44 @@ +package vue; + +import javax.swing.JFrame; +import java.awt.*; + +import modele.Coup; +import modele.Plateau; + + +public class VueGraphiqueSwing implements Vue { + JFrame fen = new JFrame("CHESS GAME"); + private final PlateauSwingUI plateauUI; + + public VueGraphiqueSwing(Plateau plateau) { + fen.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + fen.setResizable(false); + + plateauUI = new PlateauSwingUI(plateau); // Passe le modèle + fen.add(plateauUI, BorderLayout.CENTER); + + fen.setSize(800, 800); + //fen.pack(); // ajuste la taille selon le contenu + fen.setLocationRelativeTo(null); // centre la fenêtre à l'écran + + fen.setVisible(true); + } + + @Override + public void afficherMessage(String message) { + // Affichage du message dans la fenêtre graphique + } + + @Override + public Coup demanderCoup(Plateau plateau) { + // Demande un coup au joueur + return null; + } + + @Override + public void afficherPlateau(Plateau plateau) { + plateauUI.rafraichir(); + } + +} \ No newline at end of file