init 2: Start project

PROJET/linea/Cercle.java

@@ -0,0 +1,131 @@
+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;
+	}
+	
+	
+
+	
+}

PROJET/linea/Jeu.java

@@ -0,0 +1,145 @@
+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) {
+		
+	}
+		
+}

PROJET/linea/Ligne.java

@@ -0,0 +1,78 @@
+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
+		
+	}
+}

PROJET/linea/LineaAppli.java

@@ -0,0 +1,15 @@
+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();
+
+	}
+	
+}

PROJET/linea/ObjetGraphique.java

@@ -0,0 +1,56 @@
+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;
+	}
+}

PROJET/linea/Segment.java

@@ -0,0 +1,60 @@
+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
+		
+	}
+	
+	
+}

PROJET/linea/ZoneDessin.java

@@ -0,0 +1,105 @@
+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
+	}
+	
+}
+	
+