bertrana/Projet-Dev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: bertrana:a1f3e4a7d9e6f44d7fec5a2ac20fe688c203e0d1
Branches Tags
bertrana:main
..
compare: bertrana:main
Branches Tags
bertrana:main

5 Commits
a1f3e4a7d9 ... main

Author SHA1 Message Date
Richard3il
cd7d63a610 Adding increase difficulty 2026-02-23 11:10:15 +01:00
Richard3il
83f5b974ab Reset du jeu apres la mort 2026-02-23 09:57:06 +01:00
Richard3il
866bd17e29 Collision entre le cercle et la ligne 2026-02-23 09:41:54 +01:00
Richard3il
c666b02807 change organisation 2026-02-23 08:50:02 +01:00
unknown
c9590593fe prototype 2026-02-10 16:39:21 +01:00
9 changed files with 303 additions and 194 deletions
Expand all files Collapse all files

16
src/Cercle.java → linea/Cercle.java
View File

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

63
src/Jeu.java → linea/Jeu.java
View File

@@ -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();
}
}

118
linea/Ligne.java Normal file
View File

@@ -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);
}
}

1
src/LineaAppli.java → linea/LineaAppli.java
View File

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

0
src/ObjetGraphique.java → linea/ObjetGraphique.java
View File

1
src/Segment.java → linea/Segment.java
View File

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

111
linea/ZoneDessin.java Normal file
View File

@@ -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();
}
}

78
src/Ligne.java
View File

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

105
src/ZoneDessin.java
View File

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