Adding increase difficulty

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
-		
-	}
-}

ZoneDessin.java

@@ -1,105 +0,0 @@
-package linea;
-
-import java.awt.BorderLayout;
-import java.awt.Color;
-import java.awt.Dimension;
-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 
-
-	private static final long serialVersionUID = 1L;
-	
-	//-------------------------------------------------------------------------
-	// PROPRIETES
-	//-------------------------------------------------------------------------
-	
-	// un booleen qui permet d'arreter l'animation (suspendre)
-	protected boolean estArrete = false;
-	
-	
-	//-------------------------------------------------------------------------
-	// METHODES
-	//-------------------------------------------------------------------------
-	
-	//-------------------------------------------------------------------------
-	// Constructeur de la classe
-	//-------------------------------------------------------------------------	
-	public ZoneDessin(){
-		// on prépare la zone d'affichage
-		setLayout(new BorderLayout());
-		setPreferredSize(new Dimension(800, 600));
-		setBackground(new Color(220,170,0));		
-	}
-
-	
-	//-------------------------------------------------------------------------
-	// Ajout d'un objet graphique à la zonde de dessin
-	//-------------------------------------------------------------------------	
-	public void ajouterObjet(ObjetGraphique 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) {
-			return;
-		}
-		
-		// 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
-		}
-		*/
-		
-		
-		// 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);
-		
-		// à compléter
-	}
-	
-}
-	
-	

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
@@ -98,6 +97,11 @@ public class Cercle extends ObjetGraphique{ // il s'agit plutôt d'arcs de cercl
 		g2D.draw(new Arc2D.Double(x-rayon/2, y-rayon, rayon, rayon*2, debut, fin, Arc2D.OPEN));
 	}
 
+	// Accesseur pour savoir si le joueur maintient la montée
+	public boolean isMontee() {
+		return montee;
+	}
+
 
 	//-------------------------------------------------------------------------	
 	// Redéfinition de la méthode Animer, spécifiquement pour la classe 
@@ -123,9 +127,13 @@ public class Cercle extends ObjetGraphique{ // il s'agit plutôt d'arcs de cercl
 			depY =10;
 		}
 		y+=depY;
+
+		//position
+		if(y<= 0  + rayon){
+			y = 0 + rayon;
+		}else if(y>=600 - rayon){
+			y = 600 - rayon;
+		}
+
 	}
-	
-	
-
-	
 }

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 
+	Ligne ligne = new Ligne();
 
 	// Timer : un objet qui émet des événements à un intervalle choisi, 
 	// il sert à donner le pas de l'animation
@@ -46,12 +46,12 @@ 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);
-	    */
+	    
 	}
 	
 	
@@ -114,6 +114,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);
+		ecran.ajouterObjet(demiCercleArriere);
+		ecran.ajouterObjet(ligne);
+		ecran.ajouterObjet(demiCercleAvant);
 
 
 		// on indique que c'est le jeu qui traitera les appuis sur une touche
@@ -131,6 +134,9 @@ 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(0.8f,0.0f,0.0f));
+		demiCercleAvant.setCouleur(new Color(0.0f,0.8f,0.0f));
 	}
 
 
@@ -139,7 +145,58 @@ public class Jeu implements KeyListener, ActionListener{
 	//-------------------------------------------------------------------------
 	@Override
 	public void actionPerformed(ActionEvent e) {
+		ecran.traiterBoucleAnimation();
+		if (ecran.aCollision()) {
+			if (horloge != null) horloge.stop();
+			int finalScore = (int) score;
+			Object[] options = {"Relancer", "Quitter"};
+			int choix = javax.swing.JOptionPane.showOptionDialog(null,
+					"Perdu\nScore : " + finalScore,
+					"Perdu",
+					javax.swing.JOptionPane.DEFAULT_OPTION,
+					javax.swing.JOptionPane.INFORMATION_MESSAGE,
+					null,
+					options,
+					options[0]);
+			if (choix == 0) { // Relancer
+				resetLevel();
+			} else {
+				System.exit(0);
+			}
+			return;
+		}
+		score+=(0.05+(0.05*horloge.getDelay()/100.0));
+		labScore.setText("<html><h3>score : "+(int)score+"</h3></html>");
+	}
 
+	// Réinitialise le niveau : recrée les objets, remet le score et redémarre
+	private void resetLevel() {
+		if (horloge != null) horloge.stop();
+		score = 0;
+		labScore.setText("<html><h3>score : 0</h3></html>");
+
+		// Réinitialiser l'écran (vide la liste des objets et les flags)
+		ecran.reinitialiser();
+
+		// recréer les objets
+		demiCercleAvant = new Cercle(90, -180);
+		demiCercleArriere = new Cercle(90, 180);
+		ligne = new Ligne();
+
+		// ré-ajouter les objets
+		ecran.ajouterObjet(demiCercleArriere);
+		ecran.ajouterObjet(ligne);
+		ecran.ajouterObjet(demiCercleAvant);
+
+		demiCercleArriere.setCouleur(new Color(0.8f,0.0f,0.0f));
+		demiCercleAvant.setCouleur(new Color(0.0f,0.8f,0.0f));
+
+		// redémarrer l'horloge
+		horloge = new Timer(40, this);
+		horloge.start();
+
+		// redonner le focus clavier
+		ecran.requestFocusInWindow();
 	}
 		
 }

linea/Ligne.java

@@ -0,0 +1,118 @@
+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{
+
+    private int nbSegments = 400;
+    private double xCercle = 400;
+    private Segment SegCourant;
+    // vitesse de déplacement (augmente légèrement chaque frame)
+    private double vitesse = 5.0;
+    // croissance initiale (fractionnelle) appliquée chaque frame
+    private double croissance = 0.001; // ~0.1% initial
+    // facteur qui amplifie la croissance elle-même (pour accélérer la montée)
+    private double facteurCroissance = 1.00003; // croissance augmente légèrement
+    
+    // liste des segments
+    private ArrayList<Segment> segments = new ArrayList<Segment>();
+
+    public Ligne(){
+        double x = 800;
+        double y = 300;
+        double dx,dy;
+        
+        Segment s;
+        for (int i=0; i<nbSegments; i++){
+            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));
+            
+            segments.add(s);
+            
+            x+=dx;
+            y+=dy;
+        }
+    }
+
+    @Override
+    public void Afficher(Graphics g){
+        Graphics2D g2D = (Graphics2D) g;
+        g2D.setStroke(new BasicStroke(3.0f));
+        
+        for (Segment seg : segments) {
+            seg.Afficher(g);
+        }
+    }
+
+    @Override
+    public void Animer() {
+        // déplace tous les segments vers la gauche
+        double delta = vitesse; // vitesse de déplacement (exponentielle)
+        for (Segment seg : segments) {
+            seg.x -= delta;
+        }
+
+        // appliquer la croissance (vitesse *= 1 + croissance)
+        vitesse *= (1.0 + croissance);
+        // augmenter légèrement la croissance pour que l'accélération s'amplifie
+        croissance *= facteurCroissance;
+    }
+    
+
+    // Indique si l'axe horizontal du cercle (cx) se trouve au niveau
+    // d'un des segments de la ligne -> le cercle est "sur la ligne"
+    public boolean estSurLaLigne(double cx) {
+        for (Segment seg : segments) {
+            double x1 = seg.x;
+            double x2 = seg.x + seg.xLong;
+            if ((cx >= Math.min(x1, x2)) && (cx <= Math.max(x1, x2))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // Vérifie la collision entre la ligne (segments) et un cercle
+    public boolean collisionAvec(Cercle c) {
+        double cx = c.getX();
+        double cy = c.getY();
+        double rayon = c.getRayon();
+
+        for (Segment seg : segments) {
+            double x1 = seg.x;
+            double y1 = seg.y;
+            double x2 = seg.x + seg.xLong;
+            double y2 = seg.y + seg.yLong;
+
+            double dist = pointSegmentDistance(cx, cy, x1, y1, x2, y2);
+            if (dist <= rayon) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // distance minimale entre un point (px,py) et un segment (x1,y1)-(x2,y2)
+    private double pointSegmentDistance(double px, double py, double x1, double y1, double x2, double y2) {
+        double vx = x2 - x1;
+        double vy = y2 - y1;
+        double wx = px - x1;
+        double wy = py - y1;
+        double c = vx*vx + vy*vy;
+        if (c == 0) {
+            return Math.hypot(px - x1, py - y1);
+        }
+        double t = (vx*wx + vy*wy) / c;
+        if (t < 0) t = 0;
+        else if (t > 1) t = 1;
+        double projx = x1 + t * vx;
+        double projy = y1 + t * vy;
+        return Math.hypot(px - projx, py - projy);
+    }
+}

linea/LineaAppli.java

@@ -11,5 +11,4 @@ public class LineaAppli {
 		jeu.demarrer();
 
 	}
-	
 }

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

linea/ZoneDessin.java

@@ -0,0 +1,111 @@
+package linea;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+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 {
+
+    private static final long serialVersionUID = 1L;
+    
+    // un booleen qui permet d'arreter l'animation (suspendre)
+    protected boolean estArrete = false;
+    
+    // liste des objets graphiques
+    private ArrayList<ObjetGraphique> listeObjets = new ArrayList<ObjetGraphique>();
+    // indicateur qu'une défaite (perte de contact) est survenue
+    private boolean collisionOccur = false;
+    // indique si le cercle a déjà été sur la ligne (début de la phase de maintien)
+    private boolean hadBeenOnLine = false;
+    
+    public ZoneDessin(){
+        setLayout(new BorderLayout());
+        setPreferredSize(new Dimension(800, 600));
+        setBackground(new Color(220,170,0));		
+    }
+
+    // Ajout d'un objet graphique à la zone de dessin
+    public void ajouterObjet(ObjetGraphique unObjet) {
+        listeObjets.add(unObjet);
+    }
+    
+    public void arreter(){
+        estArrete = true;
+    }
+    
+    public void demarrer(){
+        estArrete = false;
+    }
+    
+    public void traiterBoucleAnimation(){
+        if (estArrete==true) {
+            return;
+        }
+        
+        // 1. on déplace chaque objet graphique
+        for (ObjetGraphique obj : listeObjets){
+            obj.Animer();
+        }
+        
+        // 2. vérifier collisions entre une Ligne et un Cercle
+        for (ObjetGraphique obj : listeObjets) {
+            if (obj instanceof Ligne) {
+                Ligne l = (Ligne) obj;
+                for (ObjetGraphique other : listeObjets) {
+                    if (other instanceof Cercle) {
+                        Cercle c = (Cercle) other;
+                        // On commence à surveiller une fois que le centre du
+                        // cercle est au-dessus d'un segment (le cercle est "sur la ligne").
+                        if (l.estSurLaLigne(c.getX())) {
+                            hadBeenOnLine = true;
+                            // Si le cercle n'est plus en contact (distance > rayon)
+                            // alors le joueur perd (il doit maintenir le contact).
+                            if (!l.collisionAvec(c)) {
+                                collisionOccur = true;
+                                estArrete = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (estArrete) break;
+            }
+        }
+
+        // 3. on demande à redessiner
+        repaint();	
+    }
+    
+    @Override
+    public void paintComponent(Graphics g) {
+        super.paintComponent(g);		
+
+        Graphics2D g2D = (Graphics2D) g;
+        g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
+        
+        // Afficher tous les objets
+        for (ObjetGraphique obj : listeObjets) {
+            obj.Afficher(g);
+        }
+    }
+
+    // Indique si une collision est survenue
+    public boolean aCollision() {
+        return collisionOccur;
+    }
+
+    // Réinitialise l'état de la zone de dessin et supprime les objets graphiques
+    public void reinitialiser() {
+        listeObjets.clear();
+        estArrete = false;
+        collisionOccur = false;
+        hadBeenOnLine = false;
+        repaint();
+    }
+}