init: ADD classe niveauDtaConnect: gestion des niveaux du jeu + décor

.vscode/settings.json

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

linea/Ligne.java

@@ -1,78 +0,0 @@
-package linea;
-
-import java.awt.BasicStroke;
-import java.awt.Color;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.util.ArrayList;
-
-public class Ligne extends ObjetGraphique{// Hérite de la classe ObjetGraphique
-	// Ne pas oublier qu'il y a des propriétés et méthodes reçues par l'héritage
-
-	//-------------------------------------------------------------------------
-	// PROPRIETES
-	//-------------------------------------------------------------------------	
-	
-	// nb de Segments qui composent la ligne
-	protected int nbSegments = 400;
-
-	// position du cercle, pour déterminer quel est le segment courant
-	protected double xCercle = 400; // à modifier
-	
-	// segment qui se trouve au niveau du cercle : on le mémorise pour accélérer les traitements 
-	protected Segment SegCourant;
-	
-	
-	//-------------------------------------------------------------------------
-	// METHODES
-	//-------------------------------------------------------------------------
-	
-	//-------------------------------------------------------------------------
-	// Constructeur de la classe
-	//-------------------------------------------------------------------------	
-	public Ligne(){
-		// Valeurs initiales pour la position de la Ligne
-		double x = 800;
-		double y = 200;
-		double dx,dy;
-		
-		// Création de la liste de segments qui composent la ligne
-		Segment s;
-		for (int i=0; i<nbSegments; i++){
-			// définition d'un nouveau segment
-			dx = Math.random()*20+80;
-			dy = Math.random()*40-20;
-			s = new Segment(x,y,dx,dy);
-			s.setCouleur(new Color(0.2f,0.2f,0.2f));
-			
-			x+=dx;
-			y+=dy;
-		}
-	}
-
-	
-
-	//-------------------------------------------------------------------------	
-	// Redéfinition de la méthode Afficher, spécifiquement pour la classe Ligne
-	//-------------------------------------------------------------------------
-	@Override
-	public void Afficher(Graphics g){
-		
-		// On définit l'épaisseur du trait
-		Graphics2D g2D = (Graphics2D) g;
-		g2D.setStroke(new BasicStroke(3.0f));
-		
-	}
-
-	//-------------------------------------------------------------------------	
-	// Redéfinition de la méthode Animer, spécifiquement pour la classe Ligne
-	//-------------------------------------------------------------------------
-	@Override
-	public void Animer() {
-		
-		// Principe : 
-		// on parcourt tous les segments et on décale chacun de 10 pixels (par exemple)
-		// vers la gauche
-		
-	}
-}

linea/linea/Cercle.java

@@ -3,7 +3,6 @@ package linea;
 import java.awt.BasicStroke;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
-import java.awt.Stroke;
 import java.awt.geom.Arc2D;
 
 public class Cercle extends ObjetGraphique{ // il s'agit plutôt d'arcs de cercle
@@ -64,6 +63,14 @@ public class Cercle extends ObjetGraphique{ // il s'agit plutôt d'arcs de cercl
 		return rayon;
 	}
 	
+	//-------------------------------------------------------------------------
+	// 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(){
+		return y;
+	}
 	
 	//-------------------------------------------------------------------------
 	// Méthode qui note que up a été appuyée

linea/linea/Jeu.java

@@ -5,7 +5,6 @@ import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
-
 import javax.swing.JFrame;
 import javax.swing.JLabel;
 import javax.swing.Timer;
@@ -25,6 +24,7 @@ public class Jeu implements KeyListener, ActionListener{
 	protected Cercle demiCercleArriere = new Cercle(90,180); // celui qui est derrière la ligne
 	
 	// A FAIRE : ajouter les objets graphiques manquants, s'il y en a 
+	protected  Ligne laLigne = new Ligne(); // Ligne infinie du jeu 
 	
 	// Timer : un objet qui émet des événements à un intervalle choisi, 
 	// il sert à donner le pas de l'animation
@@ -36,6 +36,9 @@ public class Jeu implements KeyListener, ActionListener{
 	// un label qui servira à afficher le score
 	protected JLabel labScore; 
 
+	// un label qui servira à afficher le niveau du jeu
+	protected JLabel labLevel;
+	
 	
 	//-------------------------------------------------------------------------
 	// METHODES
@@ -46,12 +49,17 @@ public class Jeu implements KeyListener, ActionListener{
 	//-------------------------------------------------------------------------
 	public Jeu(){
 		// Gestion du score : a réactiver en fin de TP, inutile au début
-		/*
+		// Ajout du niveau du jeu 
+		labLevel = new JLabel();
+		labLevel.setText("<html><h3>niveau : 1</h3></html>");
+		labLevel.setBounds(20, 50, 200, 50);
+	    ecran.add(labLevel);
 		labScore = new JLabel();
 		labScore.setText("<html><h3>score : 0</h3></html>");
 		labScore.setBounds(20, 0, 200, 50);
 	    ecran.add(labScore);
-	    */
+
+	    
 	}
 	
 	
@@ -114,6 +122,9 @@ public class Jeu implements KeyListener, ActionListener{
 		// A FAIRE : 
 		// placer dans l'instance de l'écran tous les objets graphiques nécessaires 
 		// par exemple : ecran.ajouterObjet(demiCerleArriere);
+		this.ecran.ajouterObjet(demiCercleArriere);
+		this.ecran.ajouterObjet(laLigne);
+		this.ecran.ajouterObjet(demiCercleAvant);
 
 
 		// on indique que c'est le jeu qui traitera les appuis sur une touche
@@ -131,15 +142,34 @@ public class Jeu implements KeyListener, ActionListener{
 		
 		// A FAIRE :
 		// donner la couleur des 2 demi-cercles, par exemple :  demiCerleArriere.setCouleur(new Color(0.8f,0.0f,0.0f));
+		demiCercleArriere.setCouleur(new Color(26, 95, 161));
+		demiCercleAvant.setCouleur(new Color(26, 95, 161));
 	}
 
 
-	//-------------------------------------------------------------------------
+	//------------------------------------------------------------------------------------------------
 	// Méthode appelée lorsqu'un événement timer se produit
-	//-------------------------------------------------------------------------
+	// -> C'est ici que la loqique et l'animation du jeu sont traitées
+	// -> C'est ici que la vérification de la collision entre la ligne et le cercle doit être faite
+	//------------------------------------------------------------------------------------------------
 	@Override
 	public void actionPerformed(ActionEvent e) {
+		this.ecran.traiterBoucleAnimation();
+		boolean verification = this.laLigne.estDansCercle(this.demiCercleAvant);
 
+		if(verification){
+			this.score += 5;
+		}else{
+			// Le score reste identique			
+
+			//-------------------------------------------------------------------------------------------------------------------
+			// 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
+			//-------------------------------------------------------------------------------------------------------------------
+			
+		}
+		labScore.setText("<html><h3>score : " + this.score + "</h3></html>");
 	}
 		
 }

linea/linea/Ligne.java

@@ -0,0 +1,163 @@
+package linea;
+
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.util.ArrayList;
+
+public class Ligne extends ObjetGraphique{// Hérite de la classe ObjetGraphique
+	// Ne pas oublier qu'il y a des propriétés et méthodes reçues par l'héritage
+
+	//-------------------------------------------------------------------------
+	// PROPRIETES
+	//-------------------------------------------------------------------------	
+	
+	// nb de Segments qui composent la ligne
+	protected int nbSegments = 400;
+
+	// position du cercle, pour déterminer quel est le segment courant
+	protected double xCercle = 400; // à modifier
+	
+	// segment qui se trouve au niveau du cercle : on le mémorise pour accélérer les traitements 
+	protected Segment SegCourant;
+	
+	// Propriété listes de segements: Une ligne est constitué de plusieurs segments. 
+	// Stockage des segments afin de pouvoir les afficher et les animer plus tard 
+	protected ArrayList<Segment> listeSegments = new ArrayList<>();
+
+	//-------------------------------------------------------------------------
+	// METHODES
+	//-------------------------------------------------------------------------
+	
+	//-------------------------------------------------------------------------
+	// Constructeur de la classe
+	//-------------------------------------------------------------------------	
+	public Ligne(){
+		// Valeurs initiales pour la position de la Ligne
+		double x = 800;
+		double y = 200;
+		double dx,dy;
+		
+		// Création de la liste de segments qui composent la ligne
+		Segment s;
+		for (int i=0; i<nbSegments; i++){
+			// définition d'un nouveau segment
+			dx = Math.random()*20+80;
+			dy = Math.random()*40-20;
+			s = new Segment(x,y,dx,dy);
+			s.setCouleur(new Color(0.2f,0.2f,0.2f));
+			//Ajouter un segment dans la ligne
+			this.listeSegments.add(s);
+			x+=dx;
+			y+=dy;
+		}
+	}
+
+	
+
+	//-------------------------------------------------------------------------	
+	// Redéfinition de la méthode Afficher, spécifiquement pour la classe Ligne
+	//-------------------------------------------------------------------------
+	@Override
+	public void Afficher(Graphics g){
+		
+		// On définit l'épaisseur du trait
+		Graphics2D g2D = (Graphics2D) g;
+		g2D.setStroke(new BasicStroke(3.0f));
+		for(Segment s: this.listeSegments){
+			s.Afficher(g);
+			if(SegCourant == null){
+				if( (xCercle >= s.x) && ( xCercle <= (s.x + s.xLong) ) ){
+					this.SegCourant = s;
+				}
+			}else{
+				if( (this.SegCourant.x + this.SegCourant.xLong) < xCercle ){
+					if( (s.x <= xCercle) && ((s.x + s.xLong) >= xCercle) ){
+						this.SegCourant = s;
+					}
+				}
+			}
+		}
+		
+	}
+
+	//-------------------------------------------------------------------------	
+	// Redéfinition de la méthode Animer, spécifiquement pour la classe Ligne
+	//-------------------------------------------------------------------------
+	@Override
+	public void Animer() {
+		
+		// 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
+	// Principe: On a le rayon du cercle qui ne varie pas 
+	// On parcourt tous les points du segment courant 
+	// Et on calcule la distance entre chacun de ces points et le centre du cercle
+	// Si la distance est supérieure au rayon du cercle, alors le point n'est pas dans le cercle(GAME OVER)
+	// 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
+		// avant le premier paint), on tente de le retrouver ici pour
+		// éviter un NullPointerException qui fige l'EDT.
+		if (this.SegCourant == null) {
+			for (Segment s : this.listeSegments) {
+				if ((s.x <= xCercle) && ((s.x + s.xLong) >= 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);
+				this.SegCourant.setCouleur(Color.BLACK);
+			}
+		}
+
+		// Si toujours null (liste vide), on ne peut pas vérifier
+		if (this.SegCourant == null) {
+			return false;
+		}
+		double yCercle = c.getY();
+		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;
+				// A FAIRE: On doit arrêter le jeu si la ligne n'est pas dans le cercle
+				// PROBLEME: Le jeu s'arrête dès le lancement  car au départ la ligne n'est
+				// pas dans le cercle (la ligne est à droite du cercle, et elle se déplace vers la gauche)
+				// SOLUTION: Le jeu commence quand la ligne est dans le cercle, 
+				// et il s'arrête quand la ligne n'est plus dans le cercle
+				//break;
+			}
+		}
+		return dansCercle;
+	}
+}

linea/linea/NiveauxDataConnect.java

@@ -0,0 +1,123 @@
+package linea;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+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());
+        }
+    }
+
+
+}

linea/linea/Segment.java

@@ -1,6 +1,5 @@
 package linea;
 
-import java.awt.BasicStroke;
 import java.awt.Graphics;
 
 public class Segment extends ObjetGraphique { // Hérite de la classe ObjetGraphique
@@ -52,7 +51,6 @@ public class Segment extends ObjetGraphique { // Hérite de la classe ObjetGraph
 	//-------------------------------------------------------------------------	
 	@Override
 	void Animer() {
-		// TODO Auto-generated method stub
 			
 	}
 	

linea/linea/ZoneDessin.java

@@ -7,7 +7,6 @@ import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.RenderingHints;
 import java.util.ArrayList;
-
 import javax.swing.JPanel;
 
 public class ZoneDessin extends JPanel { // hérite d'une classe du frameWork standard 
@@ -21,6 +20,9 @@ public class ZoneDessin extends JPanel { // hérite d'une classe du frameWork st
 	// un booleen qui permet d'arreter l'animation (suspendre)
 	protected boolean estArrete = false;
 	
+	// Une liste d'objets graphique
+	// Pour permettre à traiterBoucleAnimation() de parcourir les objets sans distinction pour les animer
+	protected  ArrayList<ObjetGraphique> listeObjets = new ArrayList<>();
 	
 	//-------------------------------------------------------------------------
 	// METHODES
@@ -41,7 +43,7 @@ public class ZoneDessin extends JPanel { // hérite d'une classe du frameWork st
 	// Ajout d'un objet graphique à la zonde de dessin
 	//-------------------------------------------------------------------------	
 	public void ajouterObjet(ObjetGraphique unObjet) {
-
+		this.listeObjets.add(unObjet);
 	}
 	
 	
@@ -71,11 +73,12 @@ public class ZoneDessin extends JPanel { // hérite d'une classe du frameWork st
 		
 		// 1. on déplace chaque objet graphique
 		// A FAIRE : décommenter lorsque cela devienda exécutable, et compléter
-		/*
+		
 		for (ObjetGraphique obj : listeObjets){
 			// A FAIRE : demander à obj de s'animer
+			obj.Animer();
 		}
-		*/
+		
 		
 		
 		// 2. on demande à redessiner, ce qui déclenchera automatiquement 
@@ -98,6 +101,9 @@ public class ZoneDessin extends JPanel { // hérite d'une classe du frameWork st
 		g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
 		
 		// à compléter
+		for(ObjetGraphique obj: listeObjets){
+			obj.Afficher(g); //Chaque objet se dessine lui-même
+		}
 	}
 	
 }

linea/linea/tempCodeRunnerFile.java

@@ -0,0 +1 @@
+package linea;