ajout ui

src/main/Main.java

@@ -1,10 +1,52 @@
 package main;
 
-import javax.swing.SwingUtilities;
-import view.GameView;
+import model.MenuModel;
+import controller.*;
+import view.*;
+
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.Clip;
+import javax.swing.*;
+import java.net.URL;
 
 public class Main {
     public static void main(String[] args) {
-        SwingUtilities.invokeLater(() -> new GameView());
+        SwingUtilities.invokeLater(() -> {
+            MenuModel model = new MenuModel();
+            MenuView view = new MenuView();
+
+            JFrame frame = new JFrame(" Menu");
+            frame.setSize(1500, 750);                                  
+            frame.setLocation(0, 0);
+            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+            frame.add(view);
+
+            // Créer le contrôleur
+            new MenuController(model, view);
+
+            frame.setVisible(true);
+
+            // Chargement de la musique
+            PlayMusic("/Music/audio.wav");
+        });
+    }
+
+    public static void PlayMusic(String location){
+        try {
+            // Utilisation de getResource pour charger l'audio
+            URL url = Main.class.getResource(location);
+
+            if (url != null) {
+                AudioInputStream audioInput = AudioSystem.getAudioInputStream(url);
+                Clip clip = AudioSystem.getClip();
+                clip.open(audioInput);
+                clip.start();
+            } else {
+                System.out.println("fichier introuvable");
+            }
+        } catch (Exception e) {
+            System.out.println(e);
+        }
     }
 }

src/main/java/Main.java

@@ -1,54 +0,0 @@
-import model.*;
-import controller.*;
-import view.*;
-
-import java.io.File;
-
-import javax.sound.sampled.AudioInputStream;
-import javax.sound.sampled.AudioSystem;
-import javax.sound.sampled.Clip;
-import javax.swing.*;
-
-public class Main {
-    public static void main(String[] args) {
-        SwingUtilities.invokeLater(() -> {
-            MenuModel model = new MenuModel();
-            MenuView view = new MenuView();
-            
-          
-            JFrame frame = new JFrame(" Menu");
-            frame.setSize(1500, 750);                                  
-            frame.setLocation(0, 0);
-            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-            frame.add(view);
-            
-            // Créer le contrôleur
-            new MenuController(model, view);
-
-            frame.setVisible(true);
-            String filepath = "Music/audio.wav";
-            PlayMusic(filepath);
-        });
-    }
-
-    public static void PlayMusic(String location){
-        try {
-           // System.out.println(location);
-            File musicPath = new File(location);
-
-            if(musicPath.exists()){
-
-                AudioInputStream audioInput = AudioSystem.getAudioInputStream(musicPath);
-                Clip clip = AudioSystem.getClip();
-                clip.open(audioInput);
-                clip.start();
-
-
-            } else {
-                System.out.println("fichier introuvable");
-            }
-        } catch (Exception e) {
-            System.out.println(e);
-        }
-    }
-}

src/main/java/controller/CameraController.java

@@ -8,12 +8,12 @@ public class CameraController {
     private Point mouseDragStart = null;  // Stocke la position de départ du clic droit
     private Point viewOffset = new Point(0, 0); // Stocke le décalage actuel de la vue
     private JPanel gridPanel;
-    private GameContext context;  // Ajout de GameContext
+    private GameContext context;
 
     public CameraController(JPanel gridPanel, GameContext context) {
         this.gridPanel = gridPanel;
-        this.context = context;  // Initialisation du contexte
-        setupMouseDragToMove();
+        this.context = context;
+        setupMouseDragToMove(); // Initialise les écouteurs pour gérer le déplacement
     }
 
     public Point getViewOffset() {
@@ -21,15 +21,14 @@ public class CameraController {
     }
 
     public void updateViewOffset(int deltaX, int deltaY) {
-        viewOffset.translate(deltaX, deltaY); // Mettre à jour le décalage de la vue
-        gridPanel.setLocation(viewOffset); // Déplacer le panneau en fonction du décalage
+        viewOffset.translate(deltaX, deltaY);
+        gridPanel.setLocation(viewOffset);
     }
 
     private void setupMouseDragToMove() {
-        // Utilisation de GameContext dans les gestionnaires de la souris
         MousePressHandler mousePressHandler = new MousePressHandler(this, context);
         MouseDragHandler mouseDragHandler = new MouseDragHandler(this, context);
-    
+
         gridPanel.addMouseListener(mousePressHandler);
         gridPanel.addMouseMotionListener(mouseDragHandler);
     }

src/main/java/controller/GameContext.java

@@ -1,21 +1,39 @@
 package controller;
 
 import view.HexagonTile;
+
 import java.awt.*;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 
 public class GameContext {
-    public Map<Point, HexagonTile> hexagonMap;
-    public GameController gameController;
-    public Set<Point> availablePositions;
-    public CameraController cameraController;
+    private Map<Point, HexagonTile> hexagonMap;  // Stocke la grille
+    private Set<Point> availablePositions;  // Positions libres pour les placeholders
+    private Point offset;  // Offset global pour la grille
 
-    public GameContext(Map<Point, HexagonTile> hexagonMap, GameController gameController, 
-                       Set<Point> availablePositions, CameraController cameraController) {
-        this.hexagonMap = hexagonMap;
-        this.gameController = gameController;
-        this.availablePositions = availablePositions;
-        this.cameraController = cameraController;
+    public GameContext() {
+        this.hexagonMap = new HashMap<>();
+        this.availablePositions = new HashSet<>();
+        this.offset = new Point(0, 0);  // Initialisation de l’offset à (0, 0)
+    }
+
+    // Getters pour la grille, les positions et l'offset
+    public Map<Point, HexagonTile> getHexagonMap() {
+        return hexagonMap;
+    }
+
+    public Set<Point> getAvailablePositions() {
+        return availablePositions;
+    }
+
+    public Point getOffset() {
+        return offset;
+    }
+
+    // Méthode pour mettre à jour l'offset de la grille
+    public void updateOffset(int deltaX, int deltaY) {
+        offset.translate(deltaX, deltaY);
     }
 }

src/main/java/controller/GameController.java

@@ -3,98 +3,65 @@ package controller;
 import model.Tile;
 import view.HexagonTile;
 
+import javax.swing.*;
 import java.awt.*;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
-import javax.swing.JPanel;
 
 public class GameController {
-    private Map<Point, HexagonTile> hexagonMap;
-    private Set<Point> availablePositions;
-    private Tile nextTile;
-    private HexagonTile nextTilePreview;
+    private Map<Point, HexagonTile> hexagonMap; // Carte pour stocker les tuiles par position
+    private Set<Point> availablePositions;      // Ensemble pour suivre les positions disponibles
     private JPanel gridPanel;
 
-    public GameController(Map<Point, HexagonTile> hexagonMap, Set<Point> availablePositions, JPanel gridPanel, Tile nextTile, HexagonTile nextTilePreview) {
-        this.hexagonMap = hexagonMap;
-        this.availablePositions = availablePositions;
+    public GameController(GameContext gameContext, JPanel gridPanel, Tile nextTile, HexagonTile nextTilePreview) {
         this.gridPanel = gridPanel;
-        this.nextTile = nextTile;
-        this.nextTilePreview = nextTilePreview;
+
+        // Initialiser hexagonMap et availablePositions
+        this.hexagonMap = new HashMap<>();
+        this.availablePositions = new HashSet<>();
     }
 
-    public void placeInitialTile(Point position, CameraController cameraController) {
-        addHexagonTile(position, gridPanel, 50, cameraController); // Utilise CameraController
+    public void placeInitialTile(Point position, CameraController cameraController, Tile tile) {
+        // Place la première tuile pleine au point central
+        addHexagonTile(position, gridPanel, 50, cameraController, tile); 
         availablePositions.remove(position);
 
+        // Ajouter des placeholders autour de la première tuile
         Point[] adjacentPositions = getAdjacentPositions(position);
         for (Point adj : adjacentPositions) {
             if (!hexagonMap.containsKey(adj)) {
                 availablePositions.add(adj);
-                addHexagonTile(adj, gridPanel, 50, cameraController); // Utilise CameraController
+                addHexagonTile(adj, gridPanel, 50, cameraController, null); // Passer `null` pour les placeholders
             }
         }
     }
 
-    public void placeTile(Point position, CameraController cameraController) {
-        if (availablePositions.contains(position)) {
-            HexagonTile hexTile = hexagonMap.get(position);
-            if (hexTile != null && !hexTile.isFilled()) {
-                hexTile.setTile(nextTile);  // Placer la tuile
-                gridPanel.revalidate();  // Forcer le rafraîchissement de l'interface graphique
-                gridPanel.repaint();
-                
-                // Générer une nouvelle tuile et mettre à jour la prévisualisation
-                nextTile = generateRandomTile();
-                nextTilePreview.setTile(nextTile);
-                
-                // Mettre à jour les positions adjacentes
-                updateAdjacentPositions(position, cameraController);
-                
-                // Supprimer la position de la liste des positions disponibles
-                availablePositions.remove(position);
-            }
-        }
-    }
-
-    public void addHexagonTile(Point position, JPanel panel, int hexSize, CameraController cameraController) {
+    public void addHexagonTile(Point position, JPanel panel, int hexSize, CameraController cameraController, Tile tile) {
         int xOffset = position.x * (int) (hexSize * 3 / 2);
         int yOffset = position.y * (int) (Math.sqrt(3) * hexSize);
-    
+
         Point viewOffset = cameraController.getViewOffset();
         xOffset += viewOffset.x;
         yOffset += viewOffset.y;
-    
+
         if (position.x % 2 != 0) {
             yOffset += (int) (Math.sqrt(3) * hexSize / 2);
         }
-    
+
         HexagonTile hexTile = new HexagonTile(position);
+        hexTile.setTile(tile); // Place la tuile fournie, ou null pour un placeholder
         hexTile.setBounds(xOffset, yOffset, hexSize, hexSize);
-    
+
         // Ajout de l'écouteur pour gérer le clic sur l'hexagone
         hexTile.addMouseListener(new HexagonMouseListener(hexTile, this, availablePositions, cameraController));
-    
+
         hexagonMap.put(position, hexTile);
         panel.add(hexTile);
         panel.revalidate();
         panel.repaint();
     }
-    
-    
-    
-    
-
-    private void updateAdjacentPositions(Point position, CameraController cameraController) {
-        Point[] adjacentPositions = getAdjacentPositions(position);
-        for (Point adj : adjacentPositions) {
-            if (!hexagonMap.containsKey(adj)) {
-                availablePositions.add(adj);
-                addHexagonTile(adj, gridPanel, 50, cameraController); // Utilise les nouvelles positions logiques
-            }
-        }
-    }
-    
 
     private Point[] getAdjacentPositions(Point position) {
         return new Point[]{
@@ -106,8 +73,4 @@ public class GameController {
                 new Point(position.x - 1, position.y + 1)
         };
     }
-
-    private Tile generateRandomTile() {
-        return new Tile();
-    }
 }

src/main/java/controller/HexagonMouseListener.java

@@ -9,15 +9,11 @@ import java.util.Set;
 public class HexagonMouseListener extends MouseAdapter {
 
     private final HexagonTile hexTile;
-    private final GameController gameController;
     private final Set<Point> availablePositions;
-    private final CameraController cameraController; // Ajouter CameraController
 
     public HexagonMouseListener(HexagonTile hexTile, GameController gameController, Set<Point> availablePositions, CameraController cameraController) {
         this.hexTile = hexTile;
-        this.gameController = gameController;
         this.availablePositions = availablePositions;
-        this.cameraController = cameraController; // Initialiser CameraController
     }
 
     @Override
@@ -25,12 +21,10 @@ public class HexagonMouseListener extends MouseAdapter {
         Point position = hexTile.getPosition();
         if (availablePositions.contains(position)) {
             System.out.println("Hexagone cliqué à la position : " + position);
-            gameController.placeTile(position, cameraController);  // Appelle la méthode pour placer une tuile
+            // Logique de placement de la tuile ou appel à GameController ici si nécessaire
+            // Par exemple, nous pourrions générer la tuile suivante directement ici
         } else {
             System.out.println("Position non disponible pour le placement");
         }
     }
-
-
-
 }

src/main/java/controller/MouseDragHandler.java

@@ -1,18 +1,15 @@
 package controller;
 
 import view.HexagonTile;
-
-import javax.swing.*;
-import java.awt.*;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.util.HashMap;
-import java.util.Map;
+import java.awt.Point;
+import javax.swing.SwingUtilities;
 
 public class MouseDragHandler extends MouseAdapter {
 
     private CameraController controller;
-    private GameContext context;  // Utiliser GameContext pour regrouper les données
+    private GameContext context;
 
     public MouseDragHandler(CameraController controller, GameContext context) {
         this.controller = controller;
@@ -26,8 +23,8 @@ public class MouseDragHandler extends MouseAdapter {
             int deltaX = current.x - controller.getMouseDragStart().x;
             int deltaY = current.y - controller.getMouseDragStart().y;
 
-            // Déplacer uniquement les coordonnées visuelles, pas les coordonnées logiques
-            for (HexagonTile hexTile : context.hexagonMap.values()) {
+            // Déplace chaque tuile dans le contexte de la grille
+            for (HexagonTile hexTile : context.getHexagonMap().values()) {
                 Point currentPos = hexTile.getLocation();
                 hexTile.setLocation(currentPos.x + deltaX, currentPos.y + deltaY);
             }
@@ -44,37 +41,7 @@ public class MouseDragHandler extends MouseAdapter {
     @Override
     public void mouseReleased(MouseEvent e) {
         if (SwingUtilities.isRightMouseButton(e)) {
-            // Recalculer les positions logiques lorsque la souris est relâchée
-            Map<Point, HexagonTile> newHexagonMap = new HashMap<>();
-            
-            for (Map.Entry<Point, HexagonTile> entry : context.hexagonMap.entrySet()) {
-                HexagonTile hexTile = entry.getValue();
-                Point newLogicalPosition = calculateNewLogicalPosition(hexTile.getLocation());
-
-                // Mettre à jour les écouteurs de la souris
-                hexTile.removeMouseListener(hexTile.getMouseListeners()[0]);  // Supprimer l'ancien écouteur
-                hexTile.addMouseListener(new HexagonMouseListener(hexTile, context.gameController, context.availablePositions, context.cameraController));
-
-                // Ajouter la nouvelle position logique dans la nouvelle carte
-                newHexagonMap.put(newLogicalPosition, hexTile);
-            }
-
-            // Remplacer la carte hexagonMap avec la nouvelle carte
-            context.hexagonMap.clear();
-            context.hexagonMap.putAll(newHexagonMap);
-
             controller.resetMouseDragStart();
         }
     }
-
-    private Point calculateNewLogicalPosition(Point visualPosition) {
-        int logicalX = visualPosition.x / (int) (50 * 3 / 2);  // Ajuste pour la largeur de l'hexagone
-        int logicalY = visualPosition.y / (int) (Math.sqrt(3) * 50);  // Ajuste pour la hauteur de l'hexagone
-    
-        if (logicalX % 2 != 0) {
-            logicalY -= (int) (Math.sqrt(3) * 50 / 2);  // Ajustement pour les colonnes impaires
-        }
-
-        return new Point(logicalX, logicalY);
-    }
 }

src/main/java/controller/MousePressHandler.java

@@ -1,22 +1,14 @@
 package controller;
-
-import view.HexagonTile;
-import java.awt.Point;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.util.HashMap;
-import java.util.Map;
-
 import javax.swing.SwingUtilities;
 
 public class MousePressHandler extends MouseAdapter {
 
     private CameraController controller;
-    private GameContext context;  // Ajout du GameContext
 
     public MousePressHandler(CameraController controller, GameContext context) {
         this.controller = controller;
-        this.context = context;  // Utilisation du contexte
     }
     
     @Override
@@ -28,37 +20,9 @@ public class MousePressHandler extends MouseAdapter {
     }
 
     @Override
-public void mouseReleased(MouseEvent e) {
-    if (SwingUtilities.isRightMouseButton(e)) {
-        // Créer une nouvelle carte pour stocker les nouvelles positions logiques
-        Map<Point, HexagonTile> newHexagonMap = new HashMap<>();
-        
-        for (Map.Entry<Point, HexagonTile> entry : context.hexagonMap.entrySet()) {
-            HexagonTile hexTile = entry.getValue();
-            Point newLogicalPosition = calculateNewLogicalPosition(hexTile.getLocation());
-
-            // Ajouter la nouvelle position logique dans la nouvelle carte
-            newHexagonMap.put(newLogicalPosition, hexTile);
+    public void mouseReleased(MouseEvent e) {
+        if (SwingUtilities.isRightMouseButton(e)) {
+            controller.resetMouseDragStart();
         }
-
-        // Remplacer l'ancienne carte après avoir terminé l'itération
-        Map<Point, HexagonTile> oldHexagonMap = context.hexagonMap;  // Sauvegarder l'ancienne référence
-        context.hexagonMap = newHexagonMap;  // Réassigner la nouvelle carte
-
-        oldHexagonMap.clear();  // Vider l'ancienne carte (maintenant non utilisée)
-        controller.resetMouseDragStart();
-    }
-}
-
-
-    private Point calculateNewLogicalPosition(Point visualPosition) {
-        int logicalX = visualPosition.x / (int) (50 * 3 / 2);
-        int logicalY = visualPosition.y / (int) (Math.sqrt(3) * 50);
-
-        if (logicalX % 2 != 0) {
-            logicalY -= (int) (Math.sqrt(3) * 50 / 2);
-        }
-
-        return new Point(logicalX, logicalY);
     }
 }

src/main/java/controller/ResListener.java

@@ -2,10 +2,14 @@ package controller;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
+import javax.swing.SwingUtilities;
+
+import view.GameView;
+
 public class ResListener implements ActionListener {
     @Override
     public void actionPerformed(ActionEvent e) {
-        System.out.println("Juste pour tester ");
+        SwingUtilities.invokeLater(() -> new GameView());
         
     }
 }

src/main/java/view/GameView.java

@@ -7,90 +7,90 @@ import model.Tile;
 
 import javax.swing.*;
 import java.awt.*;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
 
 public class GameView extends JFrame {
-
     private JPanel gridPanel;
-    private Map<Point, HexagonTile> hexagonMap;
-    private Set<Point> availablePositions;
     private Tile nextTile;
     private HexagonTile nextTilePreview;
     private GameController gameController;
     private CameraController cameraController;
+    private GameContext gameContext;
 
     public GameView() {
-        this.hexagonMap = new HashMap<>();
-        this.availablePositions = new HashSet<>();
-
         setTitle("Jeu de Tuiles");
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         setLayout(new BorderLayout());
+        setSize(1500, 750); 
+        setLocationRelativeTo(null);
 
-        // Générer la première tuile aléatoire
-        nextTile = generateRandomTile();
+        // Initialiser le contexte de jeu
+        gameContext = new GameContext();
 
-        // Créer la grille d'hexagones à gauche
+        // Créer la grille d'hexagones
         gridPanel = createHexagonGrid();
-        gridPanel.setLayout(null);  // Permet de placer les éléments sans layout manager
-        gridPanel.setPreferredSize(new Dimension(800, 800));  // Taille de la grille adaptée
+        
+        // Calculer et centrer la grille dans GameView
+        centerGridPanel();
 
-        // Ajout de la grille sans JScrollPane
         add(gridPanel, BorderLayout.CENTER);
 
         // Créer le panneau de contrôle à droite
         JPanel controlPanel = createControlPanel();
-        controlPanel.setPreferredSize(new Dimension(200, 600));  // Taille fixe pour le panneau de contrôle
+        controlPanel.setPreferredSize(new Dimension(200, 600));
         add(controlPanel, BorderLayout.EAST);
 
-        // Initialiser GameContext
-        GameContext context = new GameContext(hexagonMap, gameController, availablePositions, cameraController);
+        // Initialiser les contrôleurs avec le contexte de jeu
+        gameController = new GameController(gameContext, gridPanel, nextTile, nextTilePreview);
+        cameraController = new CameraController(gridPanel, gameContext);
 
-        // Initialiser le contrôleur du jeu avec le contexte
-        gameController = new GameController(hexagonMap, availablePositions, gridPanel, nextTile, nextTilePreview);
+        // Générer une première tuile pleine et la placer au centre
+        placeInitialTileWithRandomTile();
 
-        // Initialiser le contrôleur de la souris pour le glissement de la grille avec le contexte
-        cameraController = new CameraController(gridPanel, context);
-
-        // Placer la première tuile au centre en passant CameraController
-        Point initialPosition = new Point(0, 0);
-        gameController.placeInitialTile(initialPosition, cameraController);
-
-        pack();
-        setLocationRelativeTo(null);
         setVisible(true);
     }
 
     private JPanel createHexagonGrid() {
         JPanel panel = new JPanel();
-        panel.setLayout(null);  // Layout libre pour placer les hexagones
-        panel.setBackground(Color.WHITE);  // S'assurer que le fond est blanc pour mieux voir les hexagones
-        panel.setPreferredSize(new Dimension(1000, 1000));  // Taille initiale suffisamment grande
+        panel.setLayout(null);
+        panel.setBackground(Color.WHITE);
+        panel.setPreferredSize(new Dimension(800, 800));
         return panel;
     }
 
+    private void centerGridPanel() {
+        int gridX = (getWidth() - gridPanel.getPreferredSize().width) / 2;
+        int gridY = (getHeight() - gridPanel.getPreferredSize().height) / 2;
+
+        gridPanel.setLocation(gridX, gridY);
+        gameContext.updateOffset(gridX, gridY);  // Mettre à jour l'offset dans GameContext
+    }
+
     private Tile generateRandomTile() {
-        return new Tile();
+        return new Tile(); // Génère une tuile aléatoire avec des caractéristiques définies dans Tile.java
+    }
+
+    private void placeInitialTileWithRandomTile() {
+        // Générer une première tuile pleine de manière aléatoire
+        Tile initialTile = generateRandomTile();
+
+        // Utiliser `placeInitialTile` pour placer cette tuile au centre de la grille
+        Point initialPosition = new Point(0, 0);
+        gameController.placeInitialTile(initialPosition, cameraController, initialTile);
     }
 
     private JPanel createControlPanel() {
         JPanel panel = new JPanel();
         panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
-        panel.setBackground(Color.LIGHT_GRAY);  // Améliorer la visibilité du panneau de contrôle
-        panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));  // Ajout d'espacement interne
+        panel.setBackground(Color.LIGHT_GRAY);
+        panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
 
         panel.add(new JLabel("Prochaine tuile : "));
         panel.add(Box.createRigidArea(new Dimension(0, 10)));
 
-        // Afficher la prévisualisation de la prochaine tuile
         nextTilePreview = new HexagonTile(null);
-        nextTilePreview.setPreferredSize(new Dimension(150, 150));  // Augmenter la taille pour la prévisualisation
+        nextTilePreview.setPreferredSize(new Dimension(150, 150));
         nextTilePreview.setBackground(Color.GRAY);
-        nextTilePreview.setOpaque(true);  // Rendre le fond opaque pour une meilleure visibilité
-        nextTilePreview.setTile(nextTile);
+        nextTilePreview.setOpaque(true);
         panel.add(nextTilePreview);
 
         return panel;

src/main/java/view/MenuView.java

@@ -3,7 +3,6 @@ package view;
 import javax.swing.*;
 import java.awt.*;
 
-
 public class MenuView extends JComponent {
     private BtnPerso resumeButton;
     private BtnPerso newGameButton;
@@ -14,42 +13,38 @@ public class MenuView extends JComponent {
     private ImageIcon quit;
     private JPanel panelCoté;
     private JLabel labelImg;
-    
-    
-   
 
-    public MenuView(){
+    public MenuView() {
 
-         panelCoté = new JPanel(new GridBagLayout());
+        panelCoté = new JPanel(new GridBagLayout());
         GridBagConstraints gbc = new GridBagConstraints();
-        panelCoté.setBackground(new Color(243,171,115,150));
-        panelCoté.setPreferredSize(new Dimension(300,0));
+        panelCoté.setBackground(new Color(243, 171, 115, 150));
+        panelCoté.setPreferredSize(new Dimension(300, 0));
 
-        backgroundImage = new ImageIcon("./view/img/bg.png").getImage();
-        logo = new ImageIcon("\\\\wsl.localhost\\Ubuntu-24.04\\home\\topb\\DEV\\SAE31_2024\\src\\main\\java\\view\\img\\D.png");
-        quit = new ImageIcon("\\\\wsl.localhost\\Ubuntu-24.04\\home\\topb\\DEV\\SAE31_2024\\src\\main\\java\\view\\img\\quit.png");
+        // Utilisation de getResource pour charger les images
+        backgroundImage = new ImageIcon(getClass().getResource("/view/img/bg.png")).getImage();
+        logo = new ImageIcon(getClass().getResource("/view/img/D.png"));
+        quit = new ImageIcon(getClass().getResource("/view/img/quit.png"));
+
+        // Redimensionnement des images
         Image quit1 = quit.getImage();
         Image lg = logo.getImage();
         Image resizedlg = lg.getScaledInstance(300, 300, Image.SCALE_SMOOTH);
         ImageIcon logoIcon = new ImageIcon(resizedlg);
 
-
-
         labelImg = new JLabel(logoIcon);
-    
-
 
         resumeButton = new BtnPerso("RESUME");
         newGameButton = new BtnPerso("NEW GAME");
-        
+
         int buttonWidth = 65;
         int buttonHeight = 40;
-        Image resizedImage = quit1.getScaledInstance(buttonWidth, buttonHeight, Image.SCALE_SMOOTH); 
+        Image resizedImage = quit1.getScaledInstance(buttonWidth, buttonHeight, Image.SCALE_SMOOTH);
         ImageIcon resizedIcon = new ImageIcon(resizedImage);
 
         quitButton = new JButton(resizedIcon);
         quitButton.setPreferredSize(new Dimension(buttonWidth, buttonHeight));
-        quitButton.setPreferredSize(new Dimension(50,50));
+        quitButton.setPreferredSize(new Dimension(50, 50));
         quitButton.setBackground(new Color(243, 171, 115, 150));
         quitButton.setBorderPainted(false);
         quitButton.setOpaque(true);
@@ -66,13 +61,11 @@ public class MenuView extends JComponent {
 
         gbc.gridx = 0;
         gbc.gridy = 0;
-       
-        panelCoté.add(labelImg,gbc); 
-        
+
+        panelCoté.add(labelImg, gbc);
 
         gbc.gridy = 1;
-        panelCoté.add(resumeButton,gbc);
-        
+        panelCoté.add(resumeButton, gbc);
 
         gbc.gridy = 2;
         panelCoté.add(newGameButton, gbc);
@@ -80,12 +73,8 @@ public class MenuView extends JComponent {
         gbc.gridy = 3;
         panelCoté.add(quitButton, gbc);
 
-
         setLayout(new BorderLayout());
-        add(panelCoté,BorderLayout.WEST);
-      
-        
-
+        add(panelCoté, BorderLayout.WEST);
     }
 
     @Override
@@ -93,6 +82,7 @@ public class MenuView extends JComponent {
         super.paintComponent(g);
         g.drawImage(backgroundImage, 0, 0, getWidth(), getHeight(), this);
     }
+
     public BtnPerso getResumeButton() {
         return resumeButton;
     }
@@ -101,8 +91,7 @@ public class MenuView extends JComponent {
         return newGameButton;
     }
 
-    public JButton getQuiButton(){
+    public JButton getQuiButton() {
         return quitButton;
     }
-
 }