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

change organisation

Browse Source
This commit is contained in:
Richard3il
2026-02-23 08:50:02 +01:00
parent c9590593fe
commit c666b02807
7 changed files with 0 additions and 590 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
src/Cercle.java
View File

@@ -1,131 +0,0 @@
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
// 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
//-------------------------------------------------------------------------
protected double rayon = 30;
protected double depY = 0; // déplacement
// début et fin de l'arc, en degrés
protected double debut = 0;
protected double fin = 360;
// Est-ce que le joueur est en train d'appuyer sur "up"
protected boolean montee = false;
// Vitesse du cercle
protected double vitesse = -1.0;
// Un pas pour l'application des forces, permet de régler
// un peu la jouabilité
protected double pas = 0.2;
// Valeur de la force (norme) appliquée lorsque le joueur appuie sur up
protected double impulsion = 25;
//-------------------------------------------------------------------------
// METHODES
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// Constructeurs de la classe
//-------------------------------------------------------------------------
public Cercle(){
x=400;
y=200;
}
public Cercle(double debutArc, double finArc){
x=400;
y=200;
debut = debutArc;
fin = finArc;
}
//-------------------------------------------------------------------------
// Méthode d'accès en lecture au rayon, peut être utile
// par exemple pour la classe qui vérifiera si la ligne passe dans le
// cercle
//-------------------------------------------------------------------------
public double getRayon(){
return rayon;
}
//-------------------------------------------------------------------------
// Méthode qui note que up a été appuyée
// -> le booléen permet de ne plus être tributaire
// de la vitesse de répétition du clavier
//-------------------------------------------------------------------------
public void Monter(){
montee = true;
}
//-------------------------------------------------------------------------
// Méthode qui note que up a été relâchée
//-------------------------------------------------------------------------
public void ArreterMonter(){
montee = false;
}
//-------------------------------------------------------------------------
// Redéfinition de la méthode Afficher, spécifiquement pour la classe
//-------------------------------------------------------------------------
@Override
void Afficher(Graphics g) {
// choix de la couleur et de l'épaisseur
Graphics2D g2D = (Graphics2D) g;
g2D.setStroke(new BasicStroke(5.0f));
g.setColor(this.couleur);
// dessin de l'arc
g2D.draw(new Arc2D.Double(x-rayon/2, y-rayon, rayon, rayon*2, debut, fin, Arc2D.OPEN));
}
//-------------------------------------------------------------------------
// Redéfinition de la méthode Animer, spécifiquement pour la classe
//-------------------------------------------------------------------------
@Override
void Animer() {
// pas est à prendre comme un "delta t"
// chute libre
vitesse = vitesse + 9.81 * pas;
// impulsion
if (montee==true) {
vitesse = vitesse - impulsion *pas;
}
depY = 1/2 * 9.81 + vitesse * pas;
if (depY<-10) {
depY=-10;
}
if (depY>10){
depY =10;
}
y+=depY;
}
}

145
src/Jeu.java
View File

@@ -1,145 +0,0 @@
package linea;
import java.awt.Color;
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;
public class Jeu implements KeyListener, ActionListener{
//-------------------------------------------------------------------------
// PROPRIETES
//-------------------------------------------------------------------------
// 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
// un qui passera dessus
protected Cercle demiCercleAvant = new Cercle(90,-180); // celui qui est sur la ligne
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
// Timer : un objet qui émet des événements à un intervalle choisi,
// 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;
//-------------------------------------------------------------------------
// METHODES
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// Constructeur de la classe
//-------------------------------------------------------------------------
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);
*/
}
//-------------------------------------------------------------------------
// 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
JFrame fenetre = new JFrame();
// A FAIRE :
// placer dans l'instance de l'écran tous les objets graphiques nécessaires
// par exemple : ecran.ajouterObjet(demiCerleArriere);
// on indique que c'est le jeu qui traitera les appuis sur une touche
ecran.addKeyListener(this);
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();
// A FAIRE :
// donner la couleur des 2 demi-cercles, par exemple : demiCerleArriere.setCouleur(new Color(0.8f,0.0f,0.0f));
}
//-------------------------------------------------------------------------
// Méthode appelée lorsqu'un événement timer se produit
//-------------------------------------------------------------------------
@Override
public void actionPerformed(ActionEvent e) {
}
}

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

15
src/LineaAppli.java
View File

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

56
src/ObjetGraphique.java
View File

@@ -1,56 +0,0 @@
package linea;
import java.awt.Color;
import java.awt.Graphics;
//-------------------------------------------------------------------------
// ObjetGraphique :
// classe abstraite, qui ne peut donc pas être instanciée
//-------------------------------------------------------------------------
abstract class ObjetGraphique {
//-------------------------------------------------------------------------
// PROPRIETES
//-------------------------------------------------------------------------
// Position
protected double x;
protected double y;
protected Color couleur = new Color(0.0f,0.2f,0.2f);
//-------------------------------------------------------------------------
// METHODES
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// Constructeur : rien à faire
//-------------------------------------------------------------------------
public ObjetGraphique(){
}
//-------------------------------------------------------------------------
// Les méthodes d'affichage et d'animation : abstraites
//-------------------------------------------------------------------------
abstract void Afficher(Graphics g);
abstract void Animer();
//-------------------------------------------------------------------------
// Quelques méthodes d'accès
//-------------------------------------------------------------------------
public double getX(){
return x;
}
public double getY(){
return y;
}
public void setCouleur(Color c){
couleur = c;
}
}

60
src/Segment.java
View File

@@ -1,60 +0,0 @@
package linea;
import java.awt.BasicStroke;
import java.awt.Graphics;
public class Segment 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
//-------------------------------------------------------------------------
protected double xLong;
protected double yLong;
//-------------------------------------------------------------------------
// METHODES
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// Constructeurs de la classe
//-------------------------------------------------------------------------
public Segment(){
x = 0;
y = 0;
xLong = 50;
yLong = 50;
}
public Segment(double xx, double yy, double xxLong, double yyLong){
x = xx;
y = yy;
xLong = xxLong;
yLong = yyLong;
}
//-------------------------------------------------------------------------
// Redéfinition de la méthode Afficher, spécifiquement pour la classe
//-------------------------------------------------------------------------
@Override
void Afficher(Graphics g) {
// on définit la couleur
g.setColor(this.couleur);
// on dessine le segment (on pourrait faire mieux...)
g.drawLine((int)Math.round(x), (int)Math.round(y), (int)Math.round(x + xLong), (int)Math.round(y+yLong));
}
//-------------------------------------------------------------------------
// Redéfinition de la méthode Animer, spécifiquement pour la classe
//-------------------------------------------------------------------------
@Override
void Animer() {
// TODO Auto-generated method stub
}
}

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