CAMapange espace fond cercle et difficulté

changement gitignore
liaison ocean
2026-02-23 12:40:31 +01:00 · 2026-02-23 11:45:26 +01:00 · 2026-02-23 11:34:23 +01:00 · 2026-02-23 11:19:09 +01:00 · 2026-02-23 11:16:55 +01:00 · 2026-02-23 11:14:56 +01:00
17 changed files with 876 additions and 218 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -28,3 +28,4 @@ tmp/
 ### --- Système / OS ---
 .DS_Store
 Thumbs.db
 *.db
--- a/Projet_DEV.iml
+++ b/Projet_DEV.iml
@@ -7,5 +7,6 @@
    </content>
    <orderEntry type="inheritedJdk" />
    <orderEntry type="sourceFolder" forTests="false" />
    <orderEntry type="library" name="sqlite-jdbc-3.51.2.0" level="project" />
  </component>
 </module>
--- a/src/linea/CampagneAutoroute.java
+++ b/src/linea/CampagneAutoroute.java
@@ -0,0 +1,61 @@
 package linea;
 import javax.swing.Timer;
 public class CampagneAutoroute {
    protected Jeu jeu;
    public CampagneAutoroute(Jeu j) {
        this.jeu = j;
    }
    public void lancerNiveau(int difficulte) {
        System.out.println("Lancement Autoroute - Difficulté : " + difficulte);
        if(jeu.horloge != null) { jeu.horloge.stop(); }
        jeu.horloge = new Timer(40, jeu);
        jeu.ecran.viderObjets();
        // --- 1. CONFIGURATION DE LA DIFFICULTÉ ---
        double vitesse = 5.0;
        double pente = 30.0;
        if (difficulte == 1) { // FACILE
            vitesse = 4.0;
            pente = 20.0;
        } else if (difficulte == 2) { // MOYEN
            vitesse = 8.0;
            pente = 45.0;
        } else if (difficulte == 3) { // DIFFICILE
            vitesse = 12.0;
            pente = 70.0;
        }
        // --- 2. CRÉATION DES OBJETS AVEC LA MÊME VITESSE ---
        // On passe la vitesse au fond pour qu'il défile au même rythme !
        FondAutoroute fond = new FondAutoroute(vitesse);
        jeu.ecran.ajouterObjet(fond);
        // On passe aussi la vitesse (et la pente) à la ligne
        jeu.laligne = new Ligne(vitesse, pente);
        jeu.ecran.ajouterObjet(jeu.laligne);
        Voiture maVoiture = new Voiture();
        jeu.ecran.ajouterObjet(maVoiture);
        jeu.demiCercleAvant = maVoiture;
        jeu.demiCercleArriere = maVoiture;
        jeu.ecran.setGameOver(false);
        jeu.score = 0;
        jeu.labScore.setText("<html><h3 style='color:white;'>score : 0</h3></html>");
        jeu.layout.show(jeu.conteneurPrincipal, "JEU");
        jeu.ecran.setFocusable(true);
        jeu.ecran.requestFocusInWindow();
        jeu.horloge.start();
    }
 }
--- a/src/linea/CampagneEspace.java
+++ b/src/linea/CampagneEspace.java
@@ -0,0 +1,48 @@
 package linea;
 import javax.swing.Timer;
 public class CampagneEspace {
    protected Jeu jeu;
    public CampagneEspace(Jeu j) {
        this.jeu = j;
    }
    public void lancerNiveauLune(int nivDifficulte) {
        System.out.println("Lancement Espace - Difficulté : " + nivDifficulte);
        if(jeu.horloge != null) {
            jeu.horloge.stop();
        }
        jeu.horloge = new Timer(40, jeu);
        jeu.ecran.viderObjets();
        // 1. Fond étoilé
        FondEspace fond = new FondEspace();
        jeu.ecran.ajouterObjet(fond);
        // 2. Ligne de trajectoire
        jeu.laligne = new Ligne();
        jeu.ecran.ajouterObjet(jeu.laligne);
        // 3. Cercle Espace avec physique Lunaire (niveau 1)
        CercleEspace halo = new CercleEspace(0, 360, 1);
        jeu.ecran.ajouterObjet(halo);
        // Liaisons contrôles
        jeu.demiCercleAvant = halo;
        jeu.demiCercleArriere = halo;
        // UI et lancement
        jeu.ecran.setGameOver(false);
        jeu.score = 0;
        jeu.labScore.setText("<html><h3 style='color:white;'>LUNE - score : 0</h3></html>");
        jeu.layout.show(jeu.conteneurPrincipal, "JEU");
        jeu.ecran.setFocusable(true);
        jeu.ecran.requestFocusInWindow();
        jeu.horloge.start();
    }
 }
--- a/src/linea/CampagneOcean.java
+++ b/src/linea/CampagneOcean.java
@@ -0,0 +1,54 @@
 package linea;
 import javax.swing.Timer;
 import java.awt.Color;
 public class CampagneOcean {
    protected Jeu jeuPrincipal;
    public CampagneOcean(Jeu jeu) {
        this.jeuPrincipal = jeu;
    }
    public void lancerNiveau(int niveau) {
        System.out.println("Lancement du niveau Ocean - Difficulté : " + niveau);
        if (jeuPrincipal.horloge != null) {
            jeuPrincipal.horloge.stop();
        }
        jeuPrincipal.horloge = new Timer(40, jeuPrincipal);
        jeuPrincipal.ecran.viderObjets();
        FondOcean monFond = new FondOcean();
        jeuPrincipal.ecran.ajouterObjet(monFond);
        jeuPrincipal.laligne = new Ligne();
        if (niveau == 1) {
            jeuPrincipal.laligne.setInclinaisonMax(10.0);
        } else if (niveau == 2) {
            jeuPrincipal.laligne.setInclinaisonMax(30.0);
        } else {
            jeuPrincipal.laligne.setInclinaisonMax(55.0);
        }
        jeuPrincipal.ecran.ajouterObjet(jeuPrincipal.laligne);
        Cercle joueur = new Cercle(0, 360);
        joueur.setCouleur(new Color(200, 230, 255));
        jeuPrincipal.ecran.ajouterObjet(joueur);
        jeuPrincipal.demiCercleAvant = joueur;
        jeuPrincipal.demiCercleArriere = joueur;
        jeuPrincipal.ecran.setGameOver(false);
        jeuPrincipal.score = 0;
        jeuPrincipal.labScore.setText("<html><h3 style='color:white;'>Oxygène : 0</h3></html>");
        jeuPrincipal.layout.show(jeuPrincipal.conteneurPrincipal, "JEU");
        jeuPrincipal.ecran.setFocusable(true);
        jeuPrincipal.ecran.requestFocusInWindow();
        jeuPrincipal.horloge.start();
    }
 }
--- a/src/linea/Cercle.java
+++ b/src/linea/Cercle.java
@@ -31,7 +31,7 @@ public class Cercle extends ObjetGraphique{ // il s'agit plutôt d'arcs de cercl
 	protected double pas = 0.2;
 	// Valeur de la force (norme) appliquée lorsque le joueur appuie sur up
-	protected double impulsion = 25;
+	protected double impulsion = 20;
 	//-------------------------------------------------------------------------
--- a/src/linea/CercleEspace.java
+++ b/src/linea/CercleEspace.java
@@ -0,0 +1,41 @@
 package linea;
 import java.awt.*;
 import java.awt.geom.Arc2D;
 public class CercleEspace extends Cercle {
    protected double gravite;
    public CercleEspace(double debutArc, double finArc, int niveauEspace) {
        super(debutArc, finArc);
        this.x = 400;
        this.y = 200;
        if (niveauEspace == 1) { // LUNE
            this.gravite = 1.62;
            this.couleur = Color.WHITE;
        }
    }
    @Override
    void Afficher(Graphics g) {
        Graphics2D g2D = (Graphics2D) g;
        // Halo extérieur (lueur)
        g2D.setStroke(new BasicStroke(12.0f));
        Color haloColor = new Color(this.couleur.getRed(), this.couleur.getGreen(), this.couleur.getBlue(), 60);
        g2D.setColor(haloColor);
        g2D.draw(new Arc2D.Double(x-rayon/2, y-rayon, rayon, rayon*2, debut, fin, Arc2D.OPEN));
        // Cercle central brillant
        g2D.setStroke(new BasicStroke(3.0f));
        g2D.setColor(this.couleur);
        g2D.draw(new Arc2D.Double(x-rayon/2, y-rayon, rayon, rayon*2, debut, fin, Arc2D.OPEN));
    }
    @Override
    void Animer() {
        // On conserve la physique de base de Cercle (gravité/impulsion standard)
        super.Animer();
    }
 }
--- a/src/linea/FondAutoroute.java
+++ b/src/linea/FondAutoroute.java
@@ -0,0 +1,49 @@
 package linea;
 import java.awt.Color;
 import java.awt.Graphics;
 public class FondAutoroute extends ObjetGraphique {
    private double decalage = 0;
    // On ajoute une variable pour mémoriser la vitesse
    private double vitesseDefilement;
    // On modifie le constructeur pour accepter la vitesse
    public FondAutoroute(double vitesse) {
        super();
        this.vitesseDefilement = vitesse;
    }
    @Override
    void Afficher(Graphics g) {
        // ... (Garde exactement ton code d'affichage actuel avec les couleurs et les boucles for) ...
        // Ciel de nuit urbaine
        g.setColor(new Color(20, 20, 45));
        g.fillRect(0, 0, 800, 50);
        // Asphalte de l'autoroute en bas
        g.setColor(new Color(30, 30, 30));
        g.fillRect(0, 50, 800, 500);
        // Lignes de séparation de voie qui défilent
        g.setColor(Color.YELLOW);
        for(int i = 0; i < 900; i += 120) {
            for(int j = 0; j < 500; j+=167) {
                g.fillRect(i - (int)decalage, 117+j, 60, 10);
            }
        }
        g.setColor(new Color(20, 20, 45));
        g.fillRect(0, 550, 800, 50);
    }
    @Override
    void Animer() {
        // On utilise la vitesse dynamique au lieu du 5.0 fixe
        decalage += vitesseDefilement;
        if (decalage >= 120) {
            decalage = 0;
        }
    }
 }
--- a/src/linea/FondEspace.java
+++ b/src/linea/FondEspace.java
@@ -0,0 +1,39 @@
 package linea;
 import java.awt.Color;
 import java.awt.Graphics;
 import java.util.Random;
 public class FondEspace extends ObjetGraphique {
    private int[] starX = new int[100];
    private int[] starY = new int[100];
    private Random rand = new Random();
    public FondEspace() {
        for (int i = 0; i < 100; i++) {
            starX[i] = rand.nextInt(800);
            starY[i] = rand.nextInt(600);
        }
    }
    @Override
    void Afficher(Graphics g) {
        // Espace profond
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, 800, 600);
        // Étoiles
        g.setColor(Color.WHITE);
        for (int i = 0; i < 100; i++) {
            g.fillOval(starX[i], starY[i], 2, 2);
        }
    }
    @Override
    void Animer() {
        for (int i = 0; i < 100; i++) {
            starX[i] -= 2; // Défilement vers la gauche
            if (starX[i] < 0) starX[i] = 800;
        }
    }
 }
--- a/src/linea/FondOcean.java
+++ b/src/linea/FondOcean.java
@@ -0,0 +1,36 @@
 package linea;
 import java.awt.Color;
 import java.awt.Graphics;
 public class FondOcean extends ObjetGraphique {
    private int[] positionsBullesX = {100, 250, 400, 550, 700, 150, 450};
    private int[] positionsBullesY = {600, 800, 700, 900, 650, 1000, 1100};
    private int vitesseRemonteeDesBulles = 2;
    public FondOcean() {
        super();
    }
    @Override
    void Afficher(Graphics pinceau) {
        pinceau.setColor(new Color(0, 105, 148));
        pinceau.fillRect(0, 0, 800, 600);
        pinceau.setColor(new Color(255, 255, 255, 150));
        for (int i = 0; i < positionsBullesX.length; i++) {
            pinceau.drawOval(positionsBullesX[i], positionsBullesY[i], 10, 10);
        }
    }
    @Override
    void Animer() {
        for (int i = 0; i < positionsBullesY.length; i++) {
            positionsBullesY[i] = positionsBullesY[i] - vitesseRemonteeDesBulles;
            if (positionsBullesY[i] < -20) {
                positionsBullesY[i] = 650;
            }
        }
    }
 }
--- a/src/linea/GestionnaireBDD.java
+++ b/src/linea/GestionnaireBDD.java
@@ -0,0 +1,95 @@
 package linea;
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.sql.Statement;
 public class GestionnaireBDD {
    private Connection conn = null;
    private static final String DB_FILE = "linea_scores.db";
    /**
     * Le constructeur établit la connexion et crée la table si elle n'existe pas.
     */
    public GestionnaireBDD() {
        try {
            // URL de connexion pour SQLite
            String url = "jdbc:sqlite:" + DB_FILE;
            // Établir la connexion
            conn = DriverManager.getConnection(url);
            System.out.println("Connexion à la base de données SQLite établie.");
            // S'assurer que la table pour les scores existe
            creerTableSiNecessaire();
        } catch (SQLException e) {
            System.err.println("Erreur de connexion à la base de données : " + e.getMessage());
        }
    }
    /**
     * Crée la table 'parties' si elle n'est pas déjà présente dans la base de données.
     */
    private void creerTableSiNecessaire() {
        String sql = "CREATE TABLE IF NOT EXISTS parties (\n"
                + " id INTEGER PRIMARY KEY AUTOINCREMENT,\n"
                + " duree_secondes INTEGER NOT NULL,\n"
                + " campagne_id INTEGER NOT NULL,\n"
                + " difficulte_id INTEGER NOT NULL,\n"
                + " score INTEGER NOT NULL,\n"
                + " date_partie TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n"
                + ");";
        // 'try-with-resources' assure que le Statement est bien fermé
        try (Statement stmt = conn.createStatement()) {
            stmt.execute(sql);
        } catch (SQLException e) {
            System.err.println("Erreur lors de la création de la table : " + e.getMessage());
        }
    }
    /**
     * Enregistre les informations d'une partie terminée dans la base de données.
     * Utilise un PreparedStatement pour la sécurité et la performance.
     *
     * @param dureePartie Durée du jeu en secondes.
     * @param idCampagne  ID de la campagne jouée.
     * @param idDifficulte ID de la difficulté choisie.
     * @param score       Score final du joueur.
     */
    public void enregistrerPartie(int dureePartie, int idCampagne, int idDifficulte, int score) {
        if (conn == null) {
            System.err.println("Impossible d'enregistrer la partie : pas de connexion à la BDD.");
            return;
        }
        String sql = "INSERT INTO parties(duree_secondes, campagne_id, difficulte_id, score) VALUES(?,?,?,?)";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, dureePartie);
            pstmt.setInt(2, idCampagne);
            pstmt.setInt(3, idDifficulte);
            pstmt.setInt(4, score);
            pstmt.executeUpdate();
            System.out.println("Partie enregistrée avec succès ! Score : " + score);
        } catch (SQLException e) {
            System.err.println("Erreur lors de l'enregistrement de la partie : " + e.getMessage());
        }
    }
    /**
     * Ferme la connexion à la base de données.
     * Il est important d'appeler cette méthode à la fermeture de l'application.
     */
    public void fermerConnexion() {
        try {
            if (conn != null && !conn.isClosed()) {
                conn.close();
                System.out.println("Connexion à la base de données fermée.");
            }
        } catch (SQLException ex) {
            System.err.println("Erreur lors de la fermeture de la connexion BDD : " + ex.getMessage());
        }
    }
 }
--- a/src/linea/Jeu.java
+++ b/src/linea/Jeu.java
@@ -1,156 +1,193 @@
 package linea;
 import java.awt.*;
-import java.awt.event.ActionEvent;
+import java.awt.event.*;
-import java.awt.event.ActionListener;
+import javax.swing.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import javax.swing.JFrame;
 import javax.swing.JLabel;
 import javax.swing.Timer;
 public class Jeu implements KeyListener, ActionListener {
-	//-------------------------------------------------------------------------
+	protected JFrame fenetre;
-	// PROPRIETES
+	protected JPanel conteneurPrincipal;
-	//-------------------------------------------------------------------------
+	protected CardLayout layout;
 	// Ecran : instance de ZoneDessin, qui contiendra tous les objets graphiques
 	// et les animera
 	protected ZoneDessin ecran = new ZoneDessin();
-	// Le cercle : en fait 2 demis-cercles, un qui passera sous la ligne
+	// MENUS
-	// un qui passera dessus
+	protected MenuPrincipal menu;
-	protected Cercle demiCercleAvant = new Cercle(90,-180); // celui qui est sur la ligne
+	protected MenuCampagne menuCampagne;
 	protected Cercle demiCercleArriere = new Cercle(90,180); // celui qui est derrière la ligne
 	Ligne laligne = new Ligne();
-	// A FAIRE : ajouter les objets graphiques manquants, s'il y en a 
+	protected Cercle demiCercleAvant;
-
+	protected Cercle demiCercleArriere;
-	// Timer : un objet qui émet des événements à un intervalle choisi, 
+	protected Ligne laligne = new Ligne();
 	// il sert à donner le pas de l'animation
 	protected Timer horloge;
 	// Une variable qui contiendra le score 
 	protected double score=0; 
 	// un label qui servira à afficher le score
 	protected JLabel labScore;
 	protected int score;
 	//base de données
 	protected GestionnaireBDD bdd = new GestionnaireBDD();
-	//-------------------------------------------------------------------------
+	public int idCampagneActive = 0;  // Retient la campagne (1 = Autoroute, etc.)
-	// METHODES
+	public int difficulteActive = 0;  // Retient la difficulté (1=Facile, 2=Moyen, 3=Difficile)
 	//-------------------------------------------------------------------------
 	//-------------------------------------------------------------------------
 	// Constructeur de la classe
 	//-------------------------------------------------------------------------
 	public Jeu(){
-		// Gestion du score : a réactiver en fin de TP, inutile au début
+		score = 0;
-		labScore = new JLabel();
+		labScore = new JLabel("<html><h3>score : 0</h3></html>");
-		labScore.setText("<html><h3>score : 0</h3></html>");
+		labScore.setBounds(20, 540, 200, 50);
 		labScore.setBounds(20, 0, 200, 50);
 		ecran.add(labScore);
 	}
 	//-------------------------------------------------------------------------
 	// Méthodes qu'il faut implémenter pour être 
 	// conforme à un KeyListener
 	//-------------------------------------------------------------------------
 	//-------------------------------------------------------------------------
 	// Appui sur une touche
 	// -> l'événement est émis lorsqu'on appuie, puis selon le rythme de 
 	// répétition du clavier
 	//-------------------------------------------------------------------------
 	@Override
 	public  void keyPressed(KeyEvent e){
 		//keyCode 38 : up
 		// keyCode 40 : down
 		int keyCode = e.getKeyCode();
 		if (keyCode==38){ // touche "flèche vers le haut"
 			// On demande aux deux demi-cercle de  "monter"
 			demiCercleAvant.Monter();
 			demiCercleArriere.Monter();
 		}		
 	}
 	//-------------------------------------------------------------------------
 	// Relâchement de la touche 
 	//-------------------------------------------------------------------------
 	@Override
 	public  void keyReleased(KeyEvent e){
 		// keyCode 38 : up
 		// keyCode 40 : down
 		int keyCode = e.getKeyCode();
 		if (keyCode==38){
 			// On demande aux deux demi-cercle "d'arrêter de monter"
 			demiCercleAvant.ArreterMonter();
 			demiCercleArriere.ArreterMonter();
 		}
 	}
 	//-------------------------------------------------------------------------
 	// Une méthode que nous n'utilisons pas
 	//-------------------------------------------------------------------------
 	@Override
 	public void keyTyped(KeyEvent e) {
 		// TODO Auto-generated method stub
 	}
 	//-------------------------------------------------------------------------
 	// Démarrage du jeu : 
 	//	création de diverses instances et 
 	//-------------------------------------------------------------------------
 	public void demarrer() {
-		// Création d'une fenêtre
+		fenetre = new JFrame("Linea");
-		JFrame fenetre = new JFrame();
+		layout = new CardLayout();
 		conteneurPrincipal = new JPanel(layout);
 		score = 0;
 		menu = new MenuPrincipal(this);
 		menuCampagne = new MenuCampagne(this);
 		// Initialisation initiale
 		resetPartie();
 		// On ajoute l'action au bouton "Retour" de la ZoneDessin (Game Over)
 		ecran.btnRetour.addActionListener(new ActionListener() {
 			@Override
 			public void actionPerformed(ActionEvent e) {
 				afficherMenuPrincipal();
 			}
 		});
 		ecran.addKeyListener(this);
 		conteneurPrincipal.add(menu, "MENU");
 		conteneurPrincipal.add(menuCampagne, "CAMPAGNE");
 		conteneurPrincipal.add(ecran, "JEU");
 		fenetre.setContentPane(conteneurPrincipal);
 		fenetre.pack();
 		fenetre.setLocationRelativeTo(null);
 		fenetre.setVisible(true);
 		// Ajout d'un écouteur pour fermer la connexion BDD en quittant
 		fenetre.addWindowListener(new java.awt.event.WindowAdapter() {
 			@Override
 			public void windowClosing(java.awt.event.WindowEvent windowEvent) {
 				System.out.println("Fermeture de l'application, fermeture de la connexion BDD.");
 				bdd.fermerConnexion();
 			}
 		});
 		fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 	}
 	public void afficherMenuCampagne() {
 		layout.show(conteneurPrincipal, "CAMPAGNE");
 	}
 	public void afficherMenuPrincipal() {
 		layout.show(conteneurPrincipal, "MENU");
 	}
 	public void lancerNiveau(int numeroNiveau) {
 		this.difficulteActive = numeroNiveau;
 		if (idCampagneActive == 1) {
 			CampagneAutoroute campagne = new CampagneAutoroute(this);
 			campagne.lancerNiveau(numeroNiveau);
 		} else if (idCampagneActive == 2) {
 			CampagneEspace campagne = new CampagneEspace(this);
 			campagne.lancerNiveauLune(numeroNiveau);
 		}
 		else if (idCampagneActive == 3) {
 			CampagneOcean campagne = new CampagneOcean(this);
 			campagne.lancerNiveau(numeroNiveau);
 		}
 		else {
 			lancerPartie();
 		}
 	}
 	public void lancerPartie() {
 		resetPartie();
 		layout.show(conteneurPrincipal, "JEU");
 		ecran.setFocusable(true);
 		ecran.requestFocusInWindow();
 		horloge.start();
 	}
 	private void resetPartie() {
 		if(horloge != null) {
 			horloge.stop();
 		}
 		horloge = new Timer(40, this);
 		demiCercleAvant = new Cercle(90, -180);
 		demiCercleArriere = new Cercle(90, 180);
 		laligne = new Ligne();
 		demiCercleArriere.setCouleur(new Color(0.8f, 0.0f, 0.0f));
 		demiCercleAvant.setCouleur(new Color(1.0f, 0.2f, 0.2f));
 		ecran.viderObjets();
 		ecran.ajouterObjet(demiCercleArriere);
 		ecran.ajouterObjet(demiCercleAvant);
 		ecran.ajouterObjet(laligne);
 		ecran.setGameOver(false);
-		// on indique que c'est le jeu qui traitera les appuis sur une touche
+		score = 0;
-		ecran.addKeyListener(this);
+		labScore.setText("<html><h3>score : 0</h3></html>");
 		ecran.setFocusable(true);
 		fenetre.setContentPane(ecran);
 		fenetre.pack();
 		fenetre.setLocation(100, 100);
 		fenetre.setVisible(true);
 		fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 		// Démarrage du timer, qui rythmera l'animation
 		horloge = new Timer(40, this);
 		horloge.start();
 		demiCercleArriere.setCouleur(new Color(0.8f, 0.0f, 0.0f));
 		demiCercleAvant.setCouleur(new Color(1.0f, 0.2f, 0.2f));
 	}
 	//-------------------------------------------------------------------------
 	// Méthode appelée lorsqu'un événement timer se produit
 	//-------------------------------------------------------------------------
 	@Override
 	public void actionPerformed(ActionEvent e) {
 		ecran.traiterBoucleAnimation();
-		double yLigne = laligne.getHauteurLigneA(400);
+		score ++;
 		double yCercle = demiCercleAvant.getY();
-		if (Math.abs(yLigne - yCercle) > 30) {
+		labScore.setText("<html><h3>score : " + score+"</h3></html>");
 		// Gestion collision simple
 		double hauteurLigne = laligne.getHauteurLigneA(400);
 		if (hauteurLigne != -1) {
 			// calcule de la distance entre le centre du cercle et la ligne
 			double distance = Math.abs(hauteurLigne - demiCercleAvant.getY());
 			// Si cette distance est strictement supérieure au rayon du bouclier,
 			// cela signifie que la ligne est sortie de la bulle !
 			if (distance > demiCercleAvant.getRayon()) {
 				gameOver();
 			}
 		} else {
 			// Si on arrive au bout de la ligne
 			gameOver();
 		}
 	}
 	public void gameOver() {
-		horloge.stop(); // On arrête le Timer
+		horloge.stop();
-		ecran.setGameOver(true); // On prévient la zone de dessin
+		ecran.setGameOver(true); // Affiche "Game Over" et le bouton Retour
 		int dureePartie = score / 25; // Exemple : 25 frames par seconde
 		// On utilise nos deux variables pour la sauvegarde !
 		// L'appel est maintenant plus robuste grâce au nouveau GestionnaireBDD
 		bdd.enregistrerPartie(dureePartie, idCampagneActive, difficulteActive, score);
 	}
 	// Gestion touches...
 	@Override
 	public void keyPressed(KeyEvent e) {
 		if (e.getKeyCode() == 38) {
 			demiCercleAvant.Monter();
 			demiCercleArriere.Monter();
 		}
 	}
 	@Override
 	public void keyReleased(KeyEvent e) {
 		if (e.getKeyCode() == 38) {
 			demiCercleAvant.ArreterMonter();
 			demiCercleArriere.ArreterMonter();
 		}
 	}
 	@Override public void keyTyped(KeyEvent e) {}
 }
--- a/src/linea/Ligne.java
+++ b/src/linea/Ligne.java
@@ -13,9 +13,15 @@ public class Ligne extends ObjetGraphique{// Hérite de la classe ObjetGraphique
 	// PROPRIETES
 	//-------------------------------------------------------------------------
 	protected double vitesseDefilement = 5.0;
 	// nb de Segments qui composent la ligne
 	protected int nbSegments = 400;
 	// amplitude maximale de l'inclinaison verticale des segments (dy)
 	protected double inclinaisonMax = 30.0;
 	// position du cercle, pour déterminer quel est le segment courant
 	protected double xCercle = 400; // à modifier
@@ -33,23 +39,29 @@ public class Ligne extends ObjetGraphique{// Hérite de la classe ObjetGraphique
 	// Constructeur de la classe
 	//-------------------------------------------------------------------------
 	public Ligne() {
-		// Valeurs initiales pour la position de la Ligne
+		// Par défaut, si on ne précise rien, on met vitesse 5 et pente 30
 		this(5.0, 30.0);
 	}
 	public Ligne(double vitesse, double penteMax) {
 		this.vitesseDefilement = vitesse;
 		this.inclinaisonMax = penteMax;
 		double x = 400;
 		double y = 200;
 		double xCourant = x;
 		double yCourant = y;
 		double dx = 0, dy = 0;
 		Segment s = new Segment(x, y, dx, dy);
 		listSegments.add(s);
-		// Création de la liste de segments qui composent la ligne
+		for (int i=1; i<nbSegments; i++) {
 		Segment s = new Segment(xCourant,yCourant,dx,dy);
 		for (int i=0; i<nbSegments; i++){
 			// définition d'un nouveau segment
 			dx = (Math.random()*20)+80;
-			dy = (Math.random()*60)-30;
+			dy = (Math.random() * (2.0 * inclinaisonMax)) - inclinaisonMax;
 			if (y + dy < 0 || y + dy > 600) {
 				dy = -dy;
 			}
 			s = new Segment(x,y,dx,dy);
 			s.setCouleur(new Color(0.2f,0.2f,0.2f));
@@ -59,6 +71,15 @@ public class Ligne extends ObjetGraphique{// Hérite de la classe ObjetGraphique
 		}
 	}
 	public void setInclinaisonMax(double valeur) {
 		if (valeur < 0) valeur = -valeur;
 		this.inclinaisonMax = valeur;
 	}
 	public double getInclinaisonMax() {
 		return this.inclinaisonMax;
 	}
 	//-------------------------------------------------------------------------	
@@ -82,17 +103,13 @@ public class Ligne extends ObjetGraphique{// Hérite de la classe ObjetGraphique
 	//-------------------------------------------------------------------------
 	@Override
 	void Animer() {
 		// On déplace chaque segment vers la gauche (vitesse arbitraire de 5)
 		double vitesseDefilement = 5.0;
 		// On met à jour le x de la ligne (utilisé pour le calcul de position)
 		this.x -= vitesseDefilement;
 		// On répercute sur chaque segment
 		for (Segment s : listSegments) {
 			s.setX(s.getX() - vitesseDefilement);
 		}
 	}
 	public double getHauteurLigneA(double xCercle) {
 		for (Segment s : listSegments) {
 			// Si le segment couvre la position X du cercle
--- a/src/linea/MenuCampagne.java
+++ b/src/linea/MenuCampagne.java
@@ -0,0 +1,108 @@
 package linea;
 import java.awt.*;
 import java.awt.event.ActionListener;
 import javax.swing.*;
 public class MenuCampagne extends JPanel {
    public MenuCampagne(Jeu jeu) {
        setLayout(new BorderLayout());
        setBackground(new Color(45, 45, 45));
        CardLayout cartes = new CardLayout();
        JPanel panneauCartes = new JPanel(cartes);
        JPanel listeCampagnes = new JPanel();
        listeCampagnes.setLayout(new BoxLayout(listeCampagnes, BoxLayout.Y_AXIS));
        listeCampagnes.setBackground(new Color(45, 45, 45));
        JLabel titre = new JLabel("CAMPAGNES");
        titre.setForeground(Color.WHITE);
        titre.setFont(new Font("SansSerif", Font.BOLD, 40));
        titre.setAlignmentX(Component.CENTER_ALIGNMENT);
        JButton btnC1 = creerBouton("CAMPAGNE 1");
        JButton btnC2 = creerBouton("CAMPAGNE 2");
        JButton btnC3 = creerBouton("CAMPAGNE 3");
        JButton btnRetour = creerBouton("RETOUR");
        listeCampagnes.add(Box.createVerticalGlue());
        listeCampagnes.add(titre);
        listeCampagnes.add(Box.createRigidArea(new Dimension(0, 40)));
        listeCampagnes.add(btnC1);
        listeCampagnes.add(Box.createRigidArea(new Dimension(0, 10)));
        listeCampagnes.add(btnC2);
        listeCampagnes.add(Box.createRigidArea(new Dimension(0, 10)));
        listeCampagnes.add(btnC3);
        listeCampagnes.add(Box.createRigidArea(new Dimension(0, 30)));
        listeCampagnes.add(btnRetour);
        listeCampagnes.add(Box.createVerticalGlue());
        // ---- Carte : sélection des niveaux ----
        JPanel selectionNiveaux = new JPanel();
        selectionNiveaux.setLayout(new BoxLayout(selectionNiveaux, BoxLayout.Y_AXIS));
        selectionNiveaux.setBackground(new Color(45, 45, 45));
        JLabel titreNiveaux = new JLabel("CHOISISSEZ UN NIVEAU");
        titreNiveaux.setForeground(Color.WHITE);
        titreNiveaux.setFont(new Font("SansSerif", Font.BOLD, 32));
        titreNiveaux.setAlignmentX(Component.CENTER_ALIGNMENT);
        JButton btnN1 = creerBouton("FACILE");
        JButton btnN2 = creerBouton("MOYEN");
        JButton btnN3 = creerBouton("DIFFICILE");
        JButton btnRetourCampagnes = creerBouton("RETOUR AUX CAMPAGNES");
        selectionNiveaux.add(Box.createVerticalGlue());
        selectionNiveaux.add(titreNiveaux);
        selectionNiveaux.add(Box.createRigidArea(new Dimension(0, 30)));
        selectionNiveaux.add(btnN1);
        selectionNiveaux.add(Box.createRigidArea(new Dimension(0, 10)));
        selectionNiveaux.add(btnN2);
        selectionNiveaux.add(Box.createRigidArea(new Dimension(0, 10)));
        selectionNiveaux.add(btnN3);
        selectionNiveaux.add(Box.createRigidArea(new Dimension(0, 30)));
        selectionNiveaux.add(btnRetourCampagnes);
        selectionNiveaux.add(Box.createVerticalGlue());
        panneauCartes.add(listeCampagnes, "LISTE");
        panneauCartes.add(selectionNiveaux, "NIVEAUX");
        btnRetour.addActionListener(e -> jeu.afficherMenuPrincipal());
        btnC1.addActionListener(e -> {
            jeu.idCampagneActive = 1; // On retient qu'on joue à la campagne 1 (Autoroute)
            cartes.show(panneauCartes, "NIVEAUX"); // On affiche Facile/Moyen/Difficile
        });
        btnC2.addActionListener(e -> {
            jeu.idCampagneActive = 2;
            cartes.show(panneauCartes, "NIVEAUX");
        });
        btnC3.addActionListener(e -> {
            jeu.idCampagneActive = 3;
            cartes.show(panneauCartes, "NIVEAUX");
        });
        btnRetourCampagnes.addActionListener(e -> cartes.show(panneauCartes, "LISTE"));
        btnN1.addActionListener(e -> jeu.lancerNiveau(1));
        btnN2.addActionListener(e -> jeu.lancerNiveau(2));
        btnN3.addActionListener(e -> jeu.lancerNiveau(3));
        add(panneauCartes, BorderLayout.CENTER);
    }
    private JButton creerBouton(String texte) {
        JButton b = new JButton(texte);
        b.setFont(new Font("SansSerif", Font.PLAIN, 18));
        b.setAlignmentX(Component.CENTER_ALIGNMENT);
        b.setMaximumSize(new Dimension(240, 45));
        b.setFocusable(false);
        return b;
    }
 }
--- a/src/linea/MenuPrincipal.java
+++ b/src/linea/MenuPrincipal.java
@@ -0,0 +1,60 @@
 package linea;
 import java.awt.*;
 import javax.swing.*;
 public class MenuPrincipal extends JPanel {
    private JButton btnPlay;
    private JButton btnCampaign; // Nouveau bouton
    private JButton btnSettings;
    private JButton btnQuit;
    public MenuPrincipal(Jeu jeu) {
        setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
        setBackground(new Color(45, 45, 45)); // Gris foncé
        // Titre
        JLabel titre = new JLabel("LINEA");
        titre.setForeground(Color.WHITE);
        titre.setFont(new Font("SansSerif", Font.BOLD, 60));
        titre.setAlignmentX(Component.CENTER_ALIGNMENT);
        // Création des Boutons
        btnPlay = creerBouton("PLAY");
        btnCampaign = creerBouton("CAMPAGNES"); // Création
        btnSettings = creerBouton("SETTINGS");
        btnQuit = creerBouton("QUIT");
        // Actions
        btnPlay.addActionListener(e -> jeu.lancerPartie());
        // Action pour aller vers le menu campagne
        // (Assure-toi d'avoir cette méthode dans ta classe Jeu)
        btnCampaign.addActionListener(e -> jeu.afficherMenuCampagne());
        btnSettings.addActionListener(e -> JOptionPane.showMessageDialog(this, "Options bientôt disponibles !"));
        btnQuit.addActionListener(e -> System.exit(0));
        // Mise en page (espacement vertical)
        add(Box.createVerticalGlue());
        add(titre);
        add(Box.createRigidArea(new Dimension(0, 50)));
        add(btnPlay);
        add(Box.createRigidArea(new Dimension(0, 15)));
        add(btnCampaign); // Ajout à l'affichage
        add(Box.createRigidArea(new Dimension(0, 15)));
        add(btnSettings);
        add(Box.createRigidArea(new Dimension(0, 15)));
        add(btnQuit);
        add(Box.createVerticalGlue());
    }
    private JButton creerBouton(String texte) {
        JButton b = new JButton(texte);
        b.setFont(new Font("SansSerif", Font.PLAIN, 20));
        b.setAlignmentX(Component.CENTER_ALIGNMENT);
        b.setMaximumSize(new Dimension(200, 50));
        b.setFocusable(false);
        return b;
    }
 }
--- a/src/linea/Voiture.java
+++ b/src/linea/Voiture.java
@@ -0,0 +1,48 @@
 package linea;
 import java.awt.BasicStroke;
 import java.awt.Color;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.geom.Arc2D;
 public class Voiture extends Cercle {
    // On définit les couleurs directement ici pour simplifier
    private Color couleurArriere = Color.GRAY;
    private Color couleurAvant = Color.GRAY;
    public Voiture() {
        super();
        this.rayon = 25;
    }
    @Override
    void Afficher(Graphics g) {
        Graphics2D g2D = (Graphics2D) g;
        g2D.setStroke(new BasicStroke(5.0f));
        // DESSINER LE DEMI-CERCLE ARRIERE (Au fond)
        g2D.setColor(couleurArriere);
        // Utilisation de rayon*2 pour la largeur et hauteur (cercle parfait)
        g2D.draw(new Arc2D.Double(x - rayon, y - rayon, rayon * 2, rayon * 2, 90, 180, Arc2D.OPEN));
        // DESSINER LA VOITURE (Au milieu)
        g.setColor(new Color(150, 50, 200));
        g.fillRect((int)x - 20, (int)y - 5, 40, 12);
        g.setColor(Color.CYAN);
        g.fillRect((int)x - 10, (int)y - 15, 20, 10);
        g.setColor(Color.DARK_GRAY);
        g.fillOval((int)x - 15, (int)y + 3, 10, 10);
        g.fillOval((int)x + 5, (int)y + 3, 10, 10);
        g.setColor(Color.YELLOW);
        g.fillOval((int)x + 15, (int)y - 2, 6, 6);
        // DESSINER LE DEMI-CERCLE AVANT (Par-dessus)
        g2D.setColor(couleurAvant);
        g2D.draw(new Arc2D.Double(x - rayon, y - rayon, rayon * 2, rayon * 2, 90, -180, Arc2D.OPEN));
    }
 }
--- a/src/linea/ZoneDessin.java
+++ b/src/linea/ZoneDessin.java
@@ -2,113 +2,76 @@ package linea;
 import java.awt.*;
 import java.util.ArrayList;
 import javax.swing.*;
-import javax.swing.JPanel;
+public class ZoneDessin extends JPanel {
 public class ZoneDessin extends JPanel { // hérite d'une classe du frameWork standard 
 	private static final long serialVersionUID = 1L;
 	protected ArrayList<ObjetGraphique> listeObjets = new ArrayList<ObjetGraphique>();
-	//-------------------------------------------------------------------------
+	// Etats du jeu
 	// PROPRIETES
 	//-------------------------------------------------------------------------
 	// un booleen qui permet d'arreter l'animation (suspendre)
 	protected boolean estArrete = false;
 	protected boolean isGameOver = false;
 	// LE BOUTON DOIT ÊTRE PUBLIC POUR ÊTRE ACCESSIBLE DEPUIS JEU.JAVA
 	public JButton btnRetour;
 	//-------------------------------------------------------------------------
 	// METHODES
 	//-------------------------------------------------------------------------
 	//-------------------------------------------------------------------------
 	// Constructeur de la classe
 	//-------------------------------------------------------------------------	
 	public ZoneDessin(){
-		// on prépare la zone d'affichage
+		// Layout null pour positionner le bouton pixel par pixel
-		setLayout(new BorderLayout());
+		setLayout(null);
 		setPreferredSize(new Dimension(800, 600));
-		setBackground(new Color(220,170,0));		
+		setBackground(new Color(100,100,100));
 		// 2. Création et configuration du bouton
 		btnRetour = new JButton("Back to Menu");
 		// x, y, largeur, hauteur (centré horizontalement pour une fenêtre de 800px)
 		btnRetour.setBounds(300, 350, 200, 50);
 		btnRetour.setFont(new Font("Arial", Font.BOLD, 16));
 		btnRetour.setFocusable(false); // Important pour ne pas gêner le clavier
 		btnRetour.setVisible(false);   // Caché au début
 		this.add(btnRetour);
 	}
 	// ... (méthodes ajouterObjet, viderObjets, arreter, demarrer restent pareilles) ...
 	public void ajouterObjet(ObjetGraphique unObjet) { this.listeObjets.add(unObjet); }
 	public void viderObjets() { this.listeObjets.clear(); }
 	//-------------------------------------------------------------------------
 	// Ajout d'un objet graphique à la zonde de dessin
 	//-------------------------------------------------------------------------	
 	public void ajouterObjet(ObjetGraphique unObjet) {
 		this.listeObjets.add(unObjet);
 	}
 	//-------------------------------------------------------------------------
 	// Mettre en pause et redémarrer
 	//-------------------------------------------------------------------------	
 	public void arreter(){
 		estArrete = true;
 	}
 	public void demarrer(){
 		estArrete = false;
 	}
 	//-------------------------------------------------------------------------
 	// Boucle d'animation : 
 	// 	- appelée par exemple 25 fois par seconde
 	//	- à chaque appel :
 	//		- on anime (déplace) chaque objet
 	//		- on redessine tout : appel à paintComponent, déclenché par repaint
 	//-------------------------------------------------------------------------	
 	public void traiterBoucleAnimation(){
-		if (estArrete==true) {
+		if (estArrete || isGameOver) return;
 			return;
 		}
 		// 1. on déplace chaque objet graphique
 		// A FAIRE : décommenter lorsque cela devienda exécutable, et compléter
 		for (ObjetGraphique obj : listeObjets){
 			obj.Animer();
 		}
 		// 2. on demande à redessiner, ce qui déclenchera automatiquement 
 		//  l'appel à la méthode paintComponent, qui est ci-dessous
 		repaint();
 	}
 	//-------------------------------------------------------------------------
 	// Dessin, déclenché par le repaint() de la méthode ci-dessus 
 	//-------------------------------------------------------------------------
 	public void paintComponent(Graphics g) {
 		// On demande à la super-classe (JPanel) de se redessiner
 		super.paintComponent(g);
 		// Puis on ajoute ce qui est spécifique à la classe
 		// on indique qu'il faut de l'antialiasing 
 		Graphics2D g2D = (Graphics2D) g;
 		g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
 		for (ObjetGraphique obj : listeObjets){
 			obj.Afficher(g);
 		}
 		// Affichage de l'écran Game Over
 		if (isGameOver) {
-			g2D.setColor(new Color(0, 0, 0, 150)); // Fond noir transparent
+			g2D.setColor(new Color(0, 0, 0, 150)); // Fond sombre
 			g2D.fillRect(0, 0, getWidth(), getHeight());
 			g2D.setColor(Color.WHITE);
 			g2D.setFont(new Font("Arial", Font.BOLD, 50));
 			String msg = "GAME OVER";
-			int largeurTexte = g2D.getFontMetrics().stringWidth(msg);
+			int largeur = g2D.getFontMetrics().stringWidth(msg);
-			g2D.drawString(msg, (getWidth() - largeurTexte) / 2, getHeight() / 2);
+			g2D.drawString(msg, (getWidth() - largeur) / 2, getHeight() / 2 - 50);
 		}
 	}
 	public void setGameOver(boolean state) {
 		this.isGameOver = state;
 		// 3. C'est ici qu'on affiche ou cache le bouton
 		btnRetour.setVisible(state);
 		repaint();
 	}
 }
Author	SHA1	Message	Date
Gw3nd4l	263711cff3	CAMapange espace fond cercle et difficulté	2026-02-23 12:40:31 +01:00
matthew-java	5ad0874d53	changement gitignore	2026-02-23 11:45:26 +01:00
incentV	840689e488	liaison ocean	2026-02-23 11:34:23 +01:00
matthew-java	0dae2808c7	lancerNiveaux	2026-02-23 11:19:09 +01:00
incentV	f1d2f92aae	Merge branch '201002222'	2026-02-23 11:16:55 +01:00
matthew-java	67bfa58457	gestion difficulté + niveaux + bdd(buggé)	2026-02-23 11:14:56 +01:00
incentV	0eea417ad2	cercle qui marche	2026-02-23 11:00:08 +01:00
incentV	008e45bb68	test cercle	2026-02-23 10:59:57 +01:00
incentV	44ac782380	campagne fonctionne	2026-02-23 10:59:28 +01:00
incentV	26850ca823	animer bulle	2026-02-23 10:52:31 +01:00
incentV	7f63cdf089	fond et bulle modif pour la campagne	2026-02-23 10:51:50 +01:00
incentV	dce34ed607	classe campOcean	2026-02-23 10:50:31 +01:00
incentV	56d4764773	creation fond ocean	2026-02-23 10:43:36 +01:00
incentV	08e68ad1ba	fix campagne 4	2026-02-23 09:24:24 +01:00
incentV	6feffb79d9	Maj	2026-02-23 09:19:11 +01:00
incentV	5a974ce7ac	ligne et modif bouton niveaux	2026-02-23 09:17:36 +01:00
matthew-java	bbb26bcb3d	suppresion de bordures rouges	2026-02-23 08:59:04 +01:00
matthew-java	dcd4cd3d07	clear	2026-02-23 08:55:29 +01:00
matthew-java	cb3b3d0e35	-fill campagne autoroute	2026-02-22 21:57:02 +01:00
incentV	7bb44b019e	Bordures	2026-02-16 19:12:07 +01:00
incentV	da1962145a	ligne sort plus	2026-02-16 19:04:07 +01:00
matthew-java	647276be0d	Score fonctionnelle	2026-02-14 21:25:31 +01:00
incentV	d10578c313	bouton campagne	2026-02-10 16:34:22 +01:00
matthew-java	c52547120b	-fix bug bouton back to menu when play after game launching where game over	2026-02-10 16:12:27 +01:00
matthew-java	2721516b0b	Changement langue bouton back to menu	2026-02-10 16:03:23 +01:00
matthew-java	8f39b0ad7f	bouton back to menu	2026-02-10 16:02:29 +01:00
matthew-java	27f8f60bed	-implementation menu	2026-02-10 15:44:59 +01:00