✅ Jeu un peu fonctionnel

Co-authored-by: Juliette Charpentier <juliette1.charpentier@etu.u-pec.fr>

LancerDorfJavaTik.ps1

@@ -5,8 +5,11 @@ $binPath = "$projectPath\bin"
 # Naviguer au répertoire racine du projet
 cd $projectPath
 
+# Afficher un message de lancement
+Write-Host "Jeu lancé."
+
 # Exécuter la classe principale
 java -classpath $binPath com.charpentierbalocchi.dorfjavatik.main.DorfJavaTik
 
 # Afficher un message de fin
-Write-Host "Application lancée."
+Write-Host "Jeu fermé."

src/com/charpentierbalocchi/dorfjavatik/controller/ControleurJeu.java

@@ -1,56 +1,60 @@
 package com.charpentierbalocchi.dorfjavatik.controller;
 
+import com.charpentierbalocchi.dorfjavatik.view.FenetreJeu;
 import com.charpentierbalocchi.dorfjavatik.model.Plateau;
 import com.charpentierbalocchi.dorfjavatik.model.Tuile;
 import com.charpentierbalocchi.dorfjavatik.util.GenerateurTuile;
-import com.charpentierbalocchi.dorfjavatik.view.FenetreJeu;
 
 public class ControleurJeu {
     private FenetreJeu fenetreJeu;
     private Plateau plateau;
     private GenerateurTuile generateurTuile;
+    private int score;
 
     public ControleurJeu(FenetreJeu fenetreJeu) {
         this.fenetreJeu = fenetreJeu;
         this.plateau = new Plateau(); // Assurez-vous que Plateau a une implémentation appropriée.
         this.generateurTuile = new GenerateurTuile(); // Génère des tuiles avec des biomes aléatoires.
+        this.score = 0;
         initGame();
     }
 
+    public void setFenetreJeu(FenetreJeu fenetreJeu) {
+        this.fenetreJeu = fenetreJeu;
+    }
+
     private void initGame() {
         // Initialiser le jeu, par exemple, placer la première tuile aléatoire ou
         // configurer le plateau.
-        placeRandomTile();
+        // Affichez une tuile initiale sur l'interface utilisateur si nécessaire.
+        Tuile tuileInitiale = generateurTuile.genererTuileAleatoire();
+        fenetreJeu.setTuileCourante(tuileInitiale);
     }
 
     // Gérer le placement d'une tuile sur le plateau
-    private void placeRandomTile() {
-        Tuile tuile = generateurTuile.genererTuileAleatoire();
-        // Logique pour placer la tuile sur le plateau et mettre à jour l'interface
-        // utilisateur.
-        // Ici vous pouvez implémenter la logique pour choisir la position ou pour
-        // réagir à un choix de l'utilisateur.
-    }
-
     public void handleTilePlacement(int x, int y) {
-        Tuile tuile = generateurTuile.genererTuileAleatoire();
+        Tuile tuileCourante = fenetreJeu.getTuileCourante();
-        if (plateau.placeTile(tuile, x, y)) { // Vérifie si la tuile peut être placée à la position x, y
+        if (plateau.placeTile(tuileCourante, x, y)) { // Vérifie si la tuile peut être placée à la position x, y
-            fenetreJeu.updateBoard(x, y, tuile); // Mettre à jour la vue avec la nouvelle tuile placée
+            fenetreJeu.updateBoard(x, y, tuileCourante); // Mettre à jour la vue avec la nouvelle tuile placée
-            updateScore(); // Mettre à jour le score après le placement
+            updateScore(x, y, tuileCourante); // Mettre à jour le score après le placement
+            if (!plateau.estComplet()) {
+                // Générer et afficher une nouvelle tuile aléatoire
+                Tuile nouvelleTuile = generateurTuile.genererTuileAleatoire();
+                fenetreJeu.setTuileCourante(nouvelleTuile);
+            } else {
+                // Le plateau est complet, fin du jeu
+                fenetreJeu.afficherMessage("Le jeu est terminé. Score final: " + score);
+            }
         } else {
-            System.out.println("Placement invalide");
+            fenetreJeu.afficherMessage("Placement invalide. Veuillez choisir une autre case.");
         }
     }
 
-    private void updateScore() {
+    private void updateScore(int x, int y, Tuile tuile) {
-        // Calculez le nouveau score et mettez-le à jour dans FenetreJeu
+        // Calculez le score basé sur les règles du jeu
-        int newScore = calculateScore();
+        int points = plateau.calculerScore(x, y, tuile);
-        fenetreJeu.setScore(newScore);
+        score += points;
-    }
+        fenetreJeu.setScore(score);
-
-    private int calculateScore() {
-        // Implémentez la logique de calcul du score basé sur les règles du jeu.
-        return 0; // Retourne le score calculé
     }
 
     // Méthode pour démarrer le jeu (peut être appelée depuis une interface

src/com/charpentierbalocchi/dorfjavatik/main/DorfJavaTik.java

@@ -1,19 +1,21 @@
 package com.charpentierbalocchi.dorfjavatik.main;
 
-import com.charpentierbalocchi.dorfjavatik.controller.ControleurJeu;
 import com.charpentierbalocchi.dorfjavatik.view.FenetreJeu;
+import com.charpentierbalocchi.dorfjavatik.controller.ControleurJeu;
 
 public class DorfJavaTik {
     public static void main(String[] args) {
-        // Créez l'instance de la fenêtre de jeu
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
-        FenetreJeu fenetreJeu = new FenetreJeu();
+            public void run() {
-
+                // Créez d'abord une instance de FenetreJeu avec une instance de ControleurJeu
-        // Créez l'instance du contrôleur de jeu et passez la fenêtre de jeu en
+                FenetreJeu fenetreJeu = new FenetreJeu(null);
-        // paramètre
+                // Créez ensuite une instance de ControleurJeu en passant FenetreJeu
-        ControleurJeu controleurJeu = new ControleurJeu(fenetreJeu);
+                ControleurJeu controleurJeu = new ControleurJeu(fenetreJeu);
-
+                // Assurez-vous de lier correctement les deux
-        // Configurez la fenêtre de jeu pour qu'elle soit visible
+                fenetreJeu.setControleurJeu(controleurJeu);
-
+                // Rendre la fenêtre visible
-        fenetreJeu.setVisible(true);
+                fenetreJeu.setVisible(true);
+            }
+        });
     }
 }

src/com/charpentierbalocchi/dorfjavatik/view/FenetreJeu.java

@@ -1,36 +1,51 @@
 package com.charpentierbalocchi.dorfjavatik.view;
 
-import javax.swing.*;
+import com.charpentierbalocchi.dorfjavatik.controller.ControleurJeu;
-
 import com.charpentierbalocchi.dorfjavatik.model.Tuile;
 
+import javax.swing.*;
 import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
 
 public class FenetreJeu extends JFrame {
     private static final int TAILLE_PLATEAU = 5; // Taille du plateau 5x5
-    private JButton[][] boutons; // Boutons représentant les cases du plateau
+    private TileButton[][] boutons; // Boutons représentant les cases du plateau
     private JLabel labelScore; // Label pour afficher le score
+    private Tuile tuileCourante; // La tuile actuellement proposée
+    private ControleurJeu controleurJeu; // Instance du contrôleur de jeu
 
-    public FenetreJeu() {
+    public FenetreJeu(ControleurJeu controleurJeu) {
         super("DorfJavaTik"); // Titre de la fenêtre
+        this.controleurJeu = controleurJeu;
         initUI();
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Ferme l'application à la fermeture de la fenêtre
         setLocationRelativeTo(null); // Centre la fenêtre sur l'écran
         pack(); // Ajuste la taille de la fenêtre en fonction des composants
     }
 
+    public void setControleurJeu(ControleurJeu controleurJeu) {
+        this.controleurJeu = controleurJeu;
+    }
+
     private void initUI() {
         // Panel principal
         JPanel panelPrincipal = new JPanel(new BorderLayout());
 
         // Panel pour le plateau de jeu
         JPanel plateau = new JPanel(new GridLayout(TAILLE_PLATEAU, TAILLE_PLATEAU));
-        plateau.setSize(1000, 1000);
+        boutons = new TileButton[TAILLE_PLATEAU][TAILLE_PLATEAU];
-        plateau.setLocation(0, 0);
-        boutons = new JButton[TAILLE_PLATEAU][TAILLE_PLATEAU];
         for (int i = 0; i < TAILLE_PLATEAU; i++) {
             for (int j = 0; j < TAILLE_PLATEAU; j++) {
-                JButton bouton = new JButton();
+                TileButton bouton = new TileButton();
+                final int x = i;
+                final int y = j;
+                bouton.addActionListener(new ActionListener() {
+                    public void actionPerformed(ActionEvent e) {
+                        // Logique de placement d'une tuile
+                        controleurJeu.handleTilePlacement(x, y);
+                    }
+                });
                 boutons[i][j] = bouton;
                 plateau.add(bouton);
             }
@@ -46,14 +61,106 @@ public class FenetreJeu extends JFrame {
 
     // Méthode pour mettre à jour le plateau après placement d'une tuile
     public void updateBoard(int x, int y, Tuile tuile) {
-        JButton bouton = boutons[x][y];
+        TileButton bouton = boutons[x][y];
-        bouton.setText(tuile.toString()); // Utilisez toString ou une autre méthode pour représenter visuellement la
+        bouton.setTuile(tuile); // Mettre à jour la tuile sur le bouton
-                                          // tuile
+        bouton.setEnabled(false); // Désactiver le bouton pour éviter le placement d'une autre tuile à cette
-        bouton.setEnabled(false); // Désactive le bouton pour éviter le placement d'une autre tuile à cette
                                   // position
     }
 
     public void setScore(int score) {
         labelScore.setText("Score: " + score);
     }
+
+    public Tuile getTuileCourante() {
+        return tuileCourante;
+    }
+
+    public void setTuileCourante(Tuile tuile) {
+        this.tuileCourante = tuile;
+        // Affichez la tuile courante dans l'interface utilisateur si nécessaire
+    }
+
+    public void afficherMessage(String message) {
+        JOptionPane.showMessageDialog(this, message);
+    }
+
+    // Classe interne pour représenter un bouton avec une tuile
+    private class TileButton extends JButton {
+        private Tuile tuile;
+
+        public TileButton() {
+            this.tuile = null;
+        }
+
+        public void setTuile(Tuile tuile) {
+            this.tuile = tuile;
+            repaint();
+        }
+
+        @Override
+        protected void paintComponent(Graphics g) {
+            super.paintComponent(g);
+            if (tuile != null) {
+                Graphics2D g2d = (Graphics2D) g.create();
+                int width = getWidth();
+                int height = getHeight();
+
+                // Dessiner le triangle nord
+                g2d.setColor(getColorForBiome(tuile.getNord()));
+                int[] xPointsNord = { 0, width / 2, width };
+                int[] yPointsNord = { 0, height / 2, 0 };
+                g2d.fillPolygon(xPointsNord, yPointsNord, 3);
+
+                // Dessiner le triangle sud
+                g2d.setColor(getColorForBiome(tuile.getSud()));
+                int[] xPointsSud = { 0, width / 2, width };
+                int[] yPointsSud = { height, height / 2, height };
+                g2d.fillPolygon(xPointsSud, yPointsSud, 3);
+
+                // Dessiner le triangle est
+                g2d.setColor(getColorForBiome(tuile.getEst()));
+                int[] xPointsEst = { width, width / 2, width };
+                int[] yPointsEst = { 0, height / 2, height };
+                g2d.fillPolygon(xPointsEst, yPointsEst, 3);
+
+                // Dessiner le triangle ouest
+                g2d.setColor(getColorForBiome(tuile.getOuest()));
+                int[] xPointsOuest = { 0, width / 2, 0 };
+                int[] yPointsOuest = { 0, height / 2, height };
+                g2d.fillPolygon(xPointsOuest, yPointsOuest, 3);
+
+                g2d.dispose();
+            }
+        }
+
+        private Color getColorForBiome(Tuile.Biome biome) {
+            switch (biome) {
+                case RIVIERE:
+                    return Color.BLUE;
+                case FORET:
+                    return Color.GREEN;
+                case CHAMP:
+                    return Color.YELLOW;
+                case VILLAGE:
+                    return Color.RED;
+                case MONTAGNE:
+                    return Color.GRAY;
+                default:
+                    return Color.BLACK;
+            }
+        }
+    }
+
+    // Méthode principale pour tester la fenêtre
+    public static void main(String[] args) {
+        javax.swing.SwingUtilities.invokeLater(new Runnable() {
+            public void run() {
+                ControleurJeu controleurJeu = new ControleurJeu(null); // Vous devez initialiser le contrôleur ici avec
+                                                                       // une instance de FenetreJeu
+                FenetreJeu fenetreJeu = new FenetreJeu(controleurJeu);
+                controleurJeu.setFenetreJeu(fenetreJeu);
+                fenetreJeu.setVisible(true);
+            }
+        });
+    }
 }