Discussion :

[SeniorEric]

OK, pas mal le clicbulles.this, j'avais fait autrement, mais je vais corriger.
Donc j'ai cet exo avec les bulles qui évoluent chacune dans un thread. Je l'ai modifié pour que les bulles ne sortent pas du champ et rebondissent sur les cotés. Maintenant, je voudrais gérer les collisions de disques pour en faire quelque chose. Donc même si je trouve la méthode qui va repérer les collisions, je ne vois pas comment scanner : dois je faire :
pour chaque disque voir si il y une collision avec tous les autres disques. Je trouve que c'est lourd mais il n'y a peut etre pas d'autres moyen : voici le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
package applibulles;
 
import java.awt.Color;
import java.awt.Graphics;
import java.util.ArrayList;
import java.util.Random;
 
import javax.swing.JPanel;
 
public class Bulle extends Thread {
	//la fenetre dans laquelle le disque se deplace
	private ClicBulles panneauBulles;
 
	//abscisse et ordonnee du centre du disque
	private int abs, ord;
 
	//largeur et hauteur de la fenetre dans laquelle la ebulle se d�place
	private int largeur, hauteur;
 
	//le rayon du disque
	private int rayon;
 
	//la couleur du disque
	private Color couleur;
 
	//param�tre qui regle la distance parcourue par le disque � chaque deplacement
	private int pas;
 
	//(alpha, beta) donne la direction du deplacement
	private float alpha, beta;
 
	//le temps (minimum) entre deux deplacements
	private int pause ;
 
	Random alea = new Random();
 
	public Bulle(int x, int y, int l, int h, ClicBulles panneauBulles) {
		abs = x;
		ord = y;
		largeur = l;
		hauteur = h;
		this.panneauBulles = panneauBulles;
		rayon = (Math.abs(alea.nextInt())) % 15 + 3;
	    pas = (Math.abs(alea.nextInt())) % 5 + 1;
	    pause = (Math.abs(alea.nextInt())) % 100 + 1;
		alpha = 2 * alea.nextFloat() - 1;
		beta = 2 * alea.nextFloat() - 1;
		couleur = new Color((Math.abs(alea.nextInt())));
		System.out.println("bulle "+alpha+" "+beta+" "+pas) ;
	}
 
	//indique si le disque est totalement sorti de la fenetre
	public boolean sortie() {
		/*if ((abs + rayon < 0) || (abs + rayon > largeur) 
				||(ord + rayon < 0) || (ord - rayon > hauteur))
			return true;*/
		if ((abs< 0) || (abs> largeur) 
				||(ord< 0) || (ord> hauteur))
			return true;
		else return false;
	}
 
	//dessine le disque dans la couleur indiqu�e
	public void dessiner(Graphics g) {
		g.setColor(couleur);
		g.fillOval(abs - rayon, ord - rayon, 
				2 * rayon, 2 * rayon);
	}
 
	/* deplace le disque depuis son point de d�part en 
	 * suivant la direction (alpha, beta) jusqu'� ce 
	 * qu'il sorte de la fenetre */
	public void run() {
		ArrayList<Bulle>  mesBulles ; 
		float absF = abs, ordF = ord;
 
		while (!sortie()){
			absF += pas*alpha ; ordF += pas*beta ;
			this.abs = (int) absF ; this.ord = (int) ordF ;
			if ((this.abs < 2)||(this.abs > largeur -2)) { alpha = -alpha ;}
 
			if ((this.ord < 2) || (this.ord > hauteur -2) ) { beta = -beta ;}
			//System.out.println("Bulle : "+newx+" "+newy) ;
			try {
				this.sleep(pause) ;
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			panneauBulles.repaint();
			//A COMPLETER
		}
		mesBulles = panneauBulles.getLesBulles() ;
		synchronized(mesBulles) { mesBulles.remove(this); }
		//panneauBulles.getLesBulles().remove(this);
		//mesBulles.remove(this);
		System.out.println("sorti"+mesBulles.size()) ;
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package applibulles;
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
 
import javax.swing.JPanel;
 
public class ClicBulles extends JPanel {
	private static final long serialVersionUID = 1L;
	private ArrayList<Bulle>  lesBulles = new ArrayList<Bulle>();
	public ClicBulles panneau = this ;
	public ClicBulles()
	{
		setBackground(Color.WHITE);
		//setPreferredSize(new Dimension(300, 300));
		addMouseListener(new MouseAdapter()
		{
			public void mouseClicked(MouseEvent evt) {
				Bulle mabulle = new Bulle(evt.getX(),evt.getY(),getWidth(),getHeight(),panneau) ;
				synchronized(lesBulles) { lesBulles.add(mabulle) ; }
				//lesBulles.add(mabulle) ; 
				mabulle.start() ;
				System.out.println("cliqué ...") ;
				repaint() ;
				/* A COMPLETER pour creer une bulle, l'ajouter aux bulles et  faire
				 * demarrer cette bulle dans un nouveau thread */
			}  
		});
	}
 
	public ArrayList<Bulle> getLesBulles() {
		return lesBulles;
	}
 
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		for (Bulle b : lesBulles) b.dessiner(g);
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package applibulles;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class AppliBulles {
	public static void main(String[] args) {
		JFrame frame = new JFrame("Appli Bulles") ;
		frame.setSize(600,400);
		ClicBulles  panel = new ClicBulles() ;
		frame.add(panel) ;
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setLocation(200, 200);
 
		frame.setResizable(true) ;
		frame.setVisible(true);
	}
}

j'ai vu la méthode intersects , c'est adapté ?

[joel.drigo]

si je trouve la méthode qui va repérer les collisions, je ne vois pas comment scanner : dois je faire :
pour chaque disque voir si il y une collision avec tous les autres disques. Je trouve que c'est lourd mais il n'y a peut etre pas d'autres moyen
[...]
j'ai vu la méthode intersects , c'est adapté ?

Oui, de base, le plus simple est de procéder comme ça : par parcours, et test d'intersection (en effet, par la méthode Rectangle.intersects()).
Ensuite, ce calcul d'intersection permet d'éliminer les cas où les bulles ne sont vraiment pas au même endroit, mais pour être plus juste, il faudra plutôt calculer si la distance entre les 2 centres est inférieure à une distance égale à la somme des rayon des deux bulles, sinon tu vas détecter une collision fausse surtout dans les coins.


Enfin, il y a des techniques d'optimisation :

• technique "Java"
• technique plus générale,
• mathématique
• algorithmique, et là, ça ne concerne plus directement Java (la rubrique "jeux" regorge d'informations à ce sujet)

Par exemple, en ce qui concerne Java, le problème de intersects, c'est que c'est une méthode d'une classe, et que tes bulles sont modélisées par des coordonnées. Il est donc nécessaire d'instancier un Rectangle pour pouvoir l'appeler, ce qui est coûteux (en temps direct d'instanciation, en mémoire, en temps de garbage collecting, surtout que tu vas créer beaucoup de rectangles). La première technique serait de réécrire la méthode pour qu'elle s'appliquent à des coordonnées directement. La seconde serait d'utiliser une instance de rectangle qu'on recycle, ou plutôt deux, puisqu'il s'agit de faire l'intersection entre deux rectangles.
En ce qui concerne la technique générale :

1. Tout calcul prend du temps.
   Il faut donc chercher à appliquer des techniques qui permettent de ne pas perdre de temps sur un calcul : par exemple, une multiplication par 2 d'un int peut être remplacé
   
   • par une addition
   • mieux, par un décalage à gauche de 1 bit ( a<<1 au lieu de a*2) (éventuellement, le compilateur pourrait faire cette optimisation de lui-même, mais pour être sûr, autant être explicite)
2. Tout calcul répété prend du temps inutilement. Par exemple, au lieu de faire graphics.drawOval(x-rayon, y-rayon, rayon*2, rayon*2), on pourait précalculer une fois pour toute et faire graphics.drawOval(x,y,diametre,diametre)En général, tout ce qui peut être précalculé doit l'être, et lorsqu'on modifie les entrées du précalcul, on recalcule : on évite ainsi de recalculer à chaque fois qu'on teste, qu'on utilise pour dessiner, etc.

C'est là que les mathématiques entre en jeux.
Par exemple : une translation d'un point ne change en rien les calculs de déplacement qu'on peut faire sur tout autre point lié à celui-ci de manière à ce que la distance entre les deux points ne change pas. Concrêtement, si tu gères une bulle avec un x, y du centre, et un rayon, que tu déplaces en ajoutant dx à x et dy à y, et que tu dessines avec un graphics.drawOval(x-rayon, y-rayon, rayon*2, rayron*2);, tu peux tout à fait appliquer les mêmes dx et dy à x si tu fais graphics.drawOval(x,y,diametre,diametre). Rien ne t'empêche de faire le calcul dans le constructeur pour que les paramètres soit xcentre, ycentre et rayon si ça te simplifie le paramétrage de tes bulles.
Autre exemple, le théorème de Thalès, te permet de remplacer de nombreux calculs qui nécessitent de connaitre un angle (long à calculer parce que sinus et consinus) par le travaile sur les coordonnées directement. Il permet également d'éviter d'avoir à calculer la distance (long à calculer parce que racine carrée, et dans une moindre mesure carré). Ainsi, au lieu de faire si (distance(A,B)<d) on peut faire si ( (xB-xA)<dx && (yB-yA)<dy).


Au niveau de la technique, il faut noter également qu'il est très long (relativement) de dessiner un disque avec un drawOval, surtout si on veut de l'anticrénelage. Dessiner une image est bien plus rapide, même avec transparence). On peut tout à fait créer une image dynamiquement (avec un graphics.drawOval()), puis ensuite se servir de cet image pour faire le dessin dans l'animation. Ainsi, on appelle qu'une seule fois drawOval(), pour l'ensemble des bulles d'une même couleur et d'une même taille. Evidemment, tout dépend du nombre de couleurs et de tailles différentes, puisque toutes ces images vont prendre de la mémoire. Après, il y a des techniques qui permettent de diminuer le nombre d'image : par exemple, pour la couleur, on peut partir d'une image blanche par exemple, un masque, et dessiner la bulle dans n'importe quelle couleur.
C'est là qu'on peut introduire plein de techniques qu'offrent la classe Graphics et d'autres classes du java.awt. Comme les "Composite" par exemple. Ou les transformées affines aussi : lorsque tu as besoin d'imprimer une translation à un ensemble d'objet, au lieu de les parcourir et de changer leur x,y, appliquer une translation au contexte graphique, sera souvent plus rapide et surtout plus simple.

Pour la partie algorithmique, on peut citer par exemple des techniques qui permettent d'éviter d'avoir à parcourir l'ensemble des autres bulles pour calculer une intersection, comme par exemple les quadtrees. On divise l'écran en secteur, chaque secteur en sous-secteur, etc. On perd un peu de temps quand on créé ou déplace une bulle pour déterminer le secteur dans laquelle elle se trouve, et ensuite, lors de la détermination du calcul d'intersection, avec de faire le calcul d'intersection, on fait une simple égalité sur le secteur : si 2 bulles ne sont pas dans le même secteur inutile de faire le calcul d'intersection, ou de distance.

[SeniorEric]

Hello !

donc je me suis bien amusé à faire des collisions en utilisant les distances, et ça n'était pas saccadé même avec beaucoup de disques. J'ai même fait une raquette déplaçable par les flèches pour réinventer le premier jeu informatique sur MO5 ou TO7 8 bits mais ma raquette ne se déplace pas assez vite je trouve. Bref je suis passé à JEE, c'est moins rigolo, et je tiens à te remercier Joel pour toutes tes réponses.
A bientôt certainement.

Ah si une question encore : eclipse c'est écrit en java je pense. Quelle est la library graphique qui a été utilisée pour les menus et la gestion des fenètres...??? Je pense que tu le sais !

[joel.drigo]

Ah si une question encore : eclipse c'est écrit en java je pense. Quelle est la library graphique qui a été utilisée pour les menus et la gestion des fenètres...???

Eclipse est écrit principalement en Java, mais il y a une partie native, en particulier pour la bibliothèque graphique justement qui s'appelle SWT, avec pour extension JFace (il y a également Draw2D pour certains plug-ins). SWT/JFace c'est un l'équivalent de AWT/Swing, mais la séparation est moins nette entre SWT et JFace qu'entre AWT et Swing. En revanche, ne pas oublier qu'il y a une alternative à AWT/Swing en pur Java : JavaFX.