update: collision ligne-cercle

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "java.project.sourcePaths": [
+        "linea"
+    ],
+    "java.project.referencedLibraries": [
+        "sqlite-jdbc-3.49.1.0.jar"
+    ]
+}

README.md

@@ -1,2 +1 @@
-# Projet_Dev_Java
+# Projet_Dev_Java
-

linea/linea/Cercle.java

@@ -64,7 +64,8 @@ public class Cercle extends ObjetGraphique{ // il s'agit plutôt d'arcs de cercl
 	}
 	
 	//-------------------------------------------------------------------------
-	// Méthode qui retourne la position du cercle en y (utile pour la classe qui vérifiera si la ligne passe dans le cercle)
+	// Méthode qui retourne la position du cercle en y 
+	// (utile pour la classe qui vérifiera si la ligne passe dans le cercle)
 	//-------------------------------------------------------------------------
 	@Override
 	public double getY(){

linea/linea/GestionBDD.java

@@ -0,0 +1,96 @@
+package linea;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public class GestionBDD {
+
+    private static final String URL = "jdbc:sqlite:score.db";
+
+    //connexion bdd
+    private static Connection connecter() throws SQLException {
+        return DriverManager.getConnection(URL);
+    }
+
+    //creation de la table score a ca premiere execution
+    public static void creerTableSiAbsente() {
+
+        String sql = """
+                CREATE TABLE IF NOT EXISTS scores (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    score INTEGER NOT NULL,
+                    date TEXT NOT NULL
+                );
+                """;
+
+        try (Connection connexion = connecter();
+             Statement statement = connexion.createStatement()) {
+
+            statement.execute(sql);
+
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // Ajouter un score a la fin de la partie 
+    public static void ajouterScore(int score) {
+
+        String sql = "INSERT INTO scores(score, date) VALUES(?, ?)";
+
+        try (Connection connexion = connecter();
+             PreparedStatement requete = connexion.prepareStatement(sql)) {
+
+            requete.setInt(1, score);
+            requete.setString(2, java.time.LocalDate.now().toString());
+
+            requete.executeUpdate();
+
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // Récupérer tous les scores
+    public static List<Integer> recupererTousLesScores() {
+
+        List<Integer> listeScores = new ArrayList<>();
+
+        String sql = "SELECT score FROM scores ORDER BY date DESC";
+
+        try (Connection connexion = connecter();
+             Statement statement = connexion.createStatement();
+             ResultSet resultat = statement.executeQuery(sql)) {
+
+            while (resultat.next()) {
+                listeScores.add(resultat.getInt("score"));
+            }
+
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+
+        return listeScores;
+    }
+
+    // Récupérer le meilleur score
+    public static int recupererMeilleurScore() {
+
+        String sql = "SELECT MAX(score) AS meilleur FROM scores";
+
+        try (Connection connexion = connecter();
+             Statement statement = connexion.createStatement();
+             ResultSet resultat = statement.executeQuery(sql)) {
+
+            if (resultat.next()) {
+                return resultat.getInt("meilleur");
+            }
+
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+
+        return 0;
+    }
+}

linea/linea/Jeu.java

@@ -34,8 +34,9 @@ public class Jeu implements KeyListener, ActionListener{
 	protected double score=0; 
 	
 	// un label qui servira à afficher le score
-	protected JLabel labScore; 
+	protected JLabel labScore;
-	
+
+	protected boolean jeuCommence = false;
 	
 	//-------------------------------------------------------------------------
 	// METHODES
@@ -46,12 +47,13 @@ public class Jeu implements KeyListener, ActionListener{
 	//-------------------------------------------------------------------------
 	public Jeu(){
 		// Gestion du score : a réactiver en fin de TP, inutile au début
-		/*
+
 		labScore = new JLabel();
 		labScore.setText("<html><h3>score : 0</h3></html>");
 		labScore.setBounds(20, 0, 200, 50);
 	    ecran.add(labScore);
-	    */
+
+	    
 	}
 	
 	
@@ -128,6 +130,45 @@ public class Jeu implements KeyListener, ActionListener{
 		fenetre.setVisible(true);
 		fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
+		// 🔹 Création du bouton Voir Scores
+		javax.swing.JButton boutonScores = new javax.swing.JButton("Voir mes scores");
+		boutonScores.setBackground(Color.BLACK);      // Couleur fond
+		boutonScores.setForeground(Color.WHITE);     // Couleur texte
+		//boutonScores.setFont(new Font("Arial", Font.BOLD, 14));  // Police
+
+		// Position du bouton
+		boutonScores.setBounds(300, 20, 160, 30);
+
+		// Action quand on clique
+		boutonScores.addActionListener(new ActionListener() {
+			@Override
+			public void actionPerformed(ActionEvent e) {
+
+				java.util.List<Integer> scores = GestionBDD.recupererTousLesScores();
+				int meilleurScore = GestionBDD.recupererMeilleurScore();
+
+				StringBuilder message = new StringBuilder();
+				message.append("Meilleur score : ").append(meilleurScore).append("\n\n");
+				message.append("Tous les scores :\n");
+
+				for (int score : scores) {
+					message.append(score).append("\n");
+				}
+
+				javax.swing.JOptionPane.showMessageDialog(
+						fenetre,
+						message.toString(),
+						"Mes Scores",
+						javax.swing.JOptionPane.INFORMATION_MESSAGE
+				);
+			}
+		});
+
+		// affichier le bouton à l'écran
+		ecran.setLayout(null);
+		ecran.add(boutonScores);
+
+
 		// Démarrage du timer, qui rythmera l'animation
 		horloge = new Timer(40, this);
 		horloge.start();
@@ -148,14 +189,28 @@ public class Jeu implements KeyListener, ActionListener{
 	public void actionPerformed(ActionEvent e) {
 		this.ecran.traiterBoucleAnimation();
 		boolean verification = this.laLigne.estDansCercle(this.demiCercleAvant);
-		/*if(verification == false){
+
-			//horloge.stop();
+		if(verification){
-			System.out.println("Perdu ! Votre score est de : " + this.score);		
+			// Ajouter les points continuellement tant que le segment est vert (cyan)
-		} 
+			this.score += 5;
-		else{
+			this.jeuCommence = true;
-			this.score += 1;
+		}else{
-			System.out.println("Score : " + this.score);
+			//-------------------------------------------------------------------------------------------------------------------
-		}*/
+			// A FAIRE: Le jeu peut s'arrêter si la ligne n'est pas dans le cercle
+			// NB: Le jeu commence quand la ligne est dans le cercle
+			// Au début le ligne n'est pas dans le cercle car la ligne est à droite du cercle, et elle se déplace vers la gauche
+			//-------------------------------------------------------------------------------------------------------------------
+			if (this.jeuCommence) {
+				this.horloge.stop();        // 1. Arrêter le temps
+				this.ecran.partiePerdue = true; // 2. Signaler à l'écran
+				this.ecran.repaint();       // 3. Forcer l'affichage du texte
+				
+				GestionBDD.ajouterScore((int)this.score);// enregistrement du score dans la base de donne
+			}
+		}
+		
+		labScore.setText("<html><h3>score : " + this.score + "</h3></html>");
+		
 	}
 		
 }

linea/linea/Ligne.java

@@ -12,7 +12,7 @@ public class Ligne extends ObjetGraphique{// Hérite de la classe ObjetGraphique
 	//-------------------------------------------------------------------------
 	// PROPRIETES
 	//-------------------------------------------------------------------------	
-	
+
 	// nb de Segments qui composent la ligne
 	protected int nbSegments = 400;
 
@@ -91,64 +91,40 @@ public class Ligne extends ObjetGraphique{// Hérite de la classe ObjetGraphique
 		// Principe : 
 		// on parcourt tous les segments et on décale chacun de 10 pixels (par exemple)
 		// vers la gauche
+		// On modifiera cette méthode en fonction du niveau de jeu
 		for(Segment s: this.listeSegments){
 			s.x -= 5;
 		}
 		
 	}
 
-	//---------------------------------------------------------------------------------------
+	//-------------------------------------------------------------------------
-	// Méthode permettant de vérifier si la ligne est à l'intérieur du cercle
+	// Méthode qui vérifie si la ligne est dans le cercle
-	// Principe: On a le rayon du cercle qui ne varie pas 
+	// Principe:
-	// On parcourt tous les points du segment courant 
+	// 1- On détermine la hauteur du point du segment qui se trouve au niveau du cercle
-	// Et on calcule la distance entre chacun de ces points et le centre du cercle
+	// 2- On calcule la distane entre ce point et le centre du cercle
-	// Si la distance est supérieure au rayon du cercle, alors le point n'est pas dans le cercle
+	// 3- On compare cette distance avec le rayon du cercle  
-	// Sinon le segment courant est dans le cercle
+	//-------------------------------------------------------------------------
-	// Remarque: On a définit la position du cercle grâce à son centre
-	// Autrement dit, les coordonnées du centre du cercle sont la position du cercle
-	// Raison pour laquelle au début la ligne est toujours dans le cercle
-	// Car yCercle = yLigne = 200 (Voir et lire le code attentivement) !!!! 
-	// Formule de la distance : d = sqrt( (x2-x1)^2 + (y2-y1)^2 )
-	// !!! Attention: il faut vérifier si le segment courant existe avant de faire les calculs 
-	// Sinon l'écran rique de se figer à cause d'un nullPointerException
-	//----------------------------------------------------------------------------------------
 	public boolean estDansCercle(Cercle c){
 		boolean dansCercle = false;
-		// Si aucun segment courant n'a encore été déterminé (peut arriver
+		if(this.SegCourant != null){
-		// avant le premier paint), on tente de le retrouver ici pour
+			// 1- On détermine la hauteur du point du segment qui se trouve au niveau du cercle
-		// éviter un NullPointerException qui fige l'EDT.
+			// En utilisant la formule de Thales
-		if (this.SegCourant == null) {
+			// Ce point se touve à la position xPoint = xCercle
-			for (Segment s : this.listeSegments) {
+			double yPoint = this.SegCourant.y + (this.SegCourant.yLong / this.SegCourant.xLong) * (this.xCercle - this.SegCourant.x);
-				if ((s.x <= xCercle) && ((s.x + s.xLong) >= xCercle)) {
+			double xPoint = this.xCercle;
-					this.SegCourant = s;
-					// On peut s'arrêter dès qu'on a trouvé le segment courant
-					break;
-				}
-			}
-			// fallback : prendre le premier segment si aucune correspondance
-			if (this.SegCourant == null && !this.listeSegments.isEmpty()) {
-				this.SegCourant = this.listeSegments.get(0);
-			}
-		}
 
-		// Si toujours null (liste vide), on ne peut pas vérifier
+			// 2- On calcule la distance entre ce point et le centre du cercle
-		if (this.SegCourant == null) {
+			double distance = Math.sqrt(Math.pow(xPoint - c.x, 2) + Math.pow(yPoint - c.y, 2));
-			return false;
+
-		}
+			// 3- On compare cette distance avec le rayon du cercle
-		double yCercle = c.getY();
+			if(distance <= c.rayon){
-		for(int i = 0; i <= 50; i++){
-			double xPoint = this.SegCourant.x + (i/50.0)*this.SegCourant.xLong;
-			double yPoint = this.SegCourant.y + (i/50.0)*this.SegCourant.yLong;
-			double distance = Math.sqrt(Math.pow((xCercle - xPoint), 2) + Math.pow((yCercle - yPoint), 2));
-			if(distance <= c.getRayon()){
-				// Le point i du segment courant est dans le cercle, on peut continuer à vérifier les autres points du segment
 				this.SegCourant.setCouleur(Color.GREEN);
 				dansCercle = true;
 			}else{
-				// On peut s'arrêter dès qu'on trouve un point hors du cercle, car le segment courant n'est plus dans le cercle
 				this.SegCourant.setCouleur(Color.RED);
 				dansCercle = false;
-				break;
+				
 			}
 		}
 		return dansCercle;

linea/linea/LineaAppli.java

@@ -1,11 +1,14 @@
 package linea;
 
-public class LineaAppli {
+
+public class LineaAppli { 
 	//-------------------------------------------------------------------------
 	// Classe de base de l'application, rien à modifier ici
 	//-------------------------------------------------------------------------	
 	public static void main(String[] arg) {
 
+		GestionBDD.creerTableSiAbsente();
+
 		Jeu jeu = new Jeu();  
 		
 		jeu.demarrer();

linea/linea/Niveau.java

@@ -0,0 +1,53 @@
+package linea;
+
+public class Niveau {
+    // Propriétés d'un niveau
+    private int id;
+    private String nom;
+    private int vitesseLigne;
+    private int nbSegments;
+    private String image;
+    private int multiplicateurScore;
+    private String couleurCercle;
+
+    // Constructeur de la classe Niveau
+    public Niveau(int id, String nom, int vitesseLigne, int nbSegments, String image, int multiplicateurScore, String couleurCercle) {
+        this.id = id;
+        this.nom = nom;
+        this.vitesseLigne = vitesseLigne;
+        this.nbSegments = nbSegments;
+        this.image = image;
+        this.multiplicateurScore = multiplicateurScore;
+        this.couleurCercle = couleurCercle;
+    }
+
+    // Getters pour les propriétés du niveau
+    public int getId() {
+        return id;
+    }
+
+    public String getNom() {
+        return nom;
+    }
+
+    public int getVitesseLigne() {
+        return vitesseLigne;
+    }
+
+    public int getNbSegments() {
+        return nbSegments;
+    }
+
+    public String getImage() {
+        return image;
+    }
+
+    public int getMultiplicateurScore() {
+        return multiplicateurScore;
+    }
+
+    public String getCouleurCercle() {
+        return couleurCercle;
+    }
+    
+}

linea/linea/NiveauxDataConnect.java

@@ -0,0 +1,151 @@
+package linea;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+
+// Cette classe est celle qui gère la connexion à la base de données Niveaux.db
+public class NiveauxDataConnect {
+    //Création d'une variable de connexion à la base de données
+    private static final String url = "jdbc:sqlite:Niveaux.db";
+    private static boolean tablesCreees = false; // Variable pour vérifier si les tables ont été créées
+
+
+
+    // ------------- Constructeur de la classe ------------------------
+    // Il initialise la connexion à la base de données
+    // Il crée la table niveau si elle n'existe pas déjà
+    // Il insérer les niveaux dans la table niveau directement
+    // Pour éviter à le faire à chaque fois que le jeu est lancé
+    // ----------------------------------------------------------------
+    public NiveauxDataConnect() throws ClassNotFoundException {
+        // Initialisation de la connexion à la base de données
+        Connection conn = getConnection();
+        if (conn != null) {
+            System.out.println("Connexion à la base de données réussie !");
+        } else {
+            System.out.println("Connexion échouée !");
+        }
+    }
+
+
+    // -------------------------------------------------------------------------
+    // Méthode de connexion à la base de données Niveaux.db
+    // -------------------------------------------------------------------------
+    public static Connection getConnection() {
+        try {
+            Connection conn = DriverManager.getConnection(url);
+            System.out.println("Connexion à la base de données réussie !");
+
+            // Vérifier si les tables ont déjà été créées pour éviter de les recréer à chaque connexion
+            if (!tablesCreees) {
+                // Créer la table niveau si elle n'existe pas déjà
+                CreerTableNiveaux(conn);
+                tablesCreees = true; // Marquer les tables comme créées
+                // Insérer les niveaux dans la table niveau
+                insererNiveau(conn);
+            }
+
+            return conn;
+        } catch (SQLException  e) {
+            System.out.println("Erreur lors de la connexion à la base de données : " + e.getMessage());
+            return null;
+        }
+    }
+
+
+    // -------------------------------------------------------------------------
+    // Méthode pour créer la table Niveaux si elle n'existe pas déjà
+    // -------------------------------------------------------------------------
+    private static void CreerTableNiveaux(Connection conn) {
+    
+        String sql = "CREATE TABLE IF NOT EXISTS niveau( "
+           + "id INTEGER PRIMARY KEY AUTOINCREMENT, "
+           + "nom TEXT NOT NULL, " /*nom du niveau*/
+           + "vitesse_ligne INTEGER NOT NULL, " /*vitesse de la ligne*/
+           + "nb_segments INTEGER NOT NULL, "  /*nombre de segments à faire passer au joueur pour réussir le niveau*/
+           + "image TEXT NOT NULL, " /*image du niveau*/
+           + "multiplicateur_score INTEGER, " /*multiplier le score en fonction du niveau*/
+           + "couleur_cercle TEXT NOT NULL, " /*Couleur du cercle en fonctiond du niveau */
+           +");" ;  
+
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute(sql);
+            stmt.close();
+        } catch (SQLException e) {
+            System.err.println("Erreur lors de la création de la table Niveaux : " + e.getMessage());
+            System.out.println("Connexion échouée !");
+            e.printStackTrace();
+        }
+
+    }
+
+
+    // -------------------------------------------------------------------------
+    // Méthode pour insérer les niveaux dans la base de données
+    // Les niveaux sont connus à l'avance et sont insérés directement
+    // dans la base de données pour éviter de les insérer à chaque fois que 
+    // le jeu est lancé
+    // --------------------------------Niveau 1 -------------------------------- 
+    // nom = "Facile", vitesse_ligne = 5, nb_segments = 50, image = "images\ciel.jpeg", multiplicateur_score = 1, couleur_cercle = "bleu"
+    // --------------------------------Niveau 2 -------------------------------- 
+    // nom = "intermédaire", vitesse_ligne = 2, nb_segments = 100, image = "images\montagnes.jpg", multiplicateur_score = 2, couleur_cercle = "gris"
+    // --------------------------------Niveau 3 -------------------------------- 
+    // nom = "Difficile", vitesse_ligne = 3, nb_segments = 100, image = "images\volcan.jpg", multiplicateur_score = 3, couleur_cercle = "marron"
+    // --------------------------------Niveau 4 -------------------------------- 
+    // nom = "Ultime", vitesse_ligne = 4, nb_segments = 150, image = "images\espace.jpg", multiplicateur_score = 4, couleur_cercle = "violet"
+    // -------------------------------------------------------------------------
+    public static void insererNiveau(Connection conn) {
+        String query1 = "INSERT INTO niveau(nom, vitesse_ligne, nb_segments, image, multiplicateur_score, couleur_cercle) " 
+                        + "VALUES('Facile', 5, 50, 'images\\ciel.jpeg', 1, '#0000FF');";
+                
+        String query2 = "INSERT INTO niveau(nom, vitesse_ligne, nb_segments, image, multiplicateur_score, couleur_cercle) "
+                        + "VALUES('Intermédiaire', 2, 100, 'images\\montagnes.jpg', 2, '#808080');";
+        String query3 = "INSERT INTO niveau(nom, vitesse_ligne, nb_segments, image, multiplicateur_score, couleur_cercle) "
+                        + "VALUES('Difficile', 3, 100, 'images\\volcan.jpg', 3, '#8B4513');";
+        String query4 = "INSERT INTO niveau(nom, vitesse_ligne, nb_segments, image, multiplicateur_score, couleur_cercle) "
+                        + "VALUES('Ultime', 4, 150, 'images\\espace.jpg', 4, '#9400D3');";
+
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute(query1);
+            stmt.execute(query2);
+            stmt.execute(query3);
+            stmt.execute(query4);
+            stmt.close();
+        } catch (SQLException e) {
+            System.err.println("Erreur lors de l'insertion des niveaux : " + e.getMessage());
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Méthode pour récupérer les niveaux depuis la base de données
+    // Elle retourne un niveau en fonction de son id
+    // -------------------------------------------------------------------------    
+    public static Niveau recupererNiveau(Connection conn, int id) {
+        Niveau niveauRecup = null;
+        String sql = "SELECT * FROM niveau WHERE id = ?;";
+        
+        try (Statement stmt = conn.createStatement();
+             ResultSet rs = stmt.executeQuery(sql)) {
+            while (rs.next()) {
+                int id1 = rs.getInt("id");
+                String nom = rs.getString("nom");
+                int vitesse_ligne = rs.getInt("vitesse_ligne");
+                int nb_segments = rs.getInt("nb_segments");
+                String image = rs.getString("image");
+                int multiplicateur_score = rs.getInt("multiplicateur_score");
+                String couleur_cercle = rs.getString("couleur_cercle");
+                niveauRecup = new Niveau(id1, nom, vitesse_ligne, nb_segments, image, multiplicateur_score, couleur_cercle);
+            }
+
+        } catch (SQLException e) {
+            System.err.println("Erreur lors de la récupération des niveaux : " + e.getMessage());
+        }
+        return niveauRecup;
+    }
+
+
+}

linea/linea/ZoneDessin.java

@@ -16,7 +16,7 @@ public class ZoneDessin extends JPanel { // hérite d'une classe du frameWork st
 	//-------------------------------------------------------------------------
 	// PROPRIETES
 	//-------------------------------------------------------------------------
-	
+	public boolean partiePerdue = false;
 	// un booleen qui permet d'arreter l'animation (suspendre)
 	protected boolean estArrete = false;
 	
@@ -104,6 +104,11 @@ public class ZoneDessin extends JPanel { // hérite d'une classe du frameWork st
 		for(ObjetGraphique obj: listeObjets){
 			obj.Afficher(g); //Chaque objet se dessine lui-même
 		}
+		if (this.partiePerdue) {
+			g.setColor(Color.RED);
+			g.setFont(new java.awt.Font("Arial", java.awt.Font.BOLD, 50));
+			g.drawString("GAME OVER", 250, 300);
+    	}
 	}
 	
 }