Discussion :

[Invité]

Bonjour à tous !

Je travaille actuellement sur un projet java, qui consiste à dessiner un pont à l'écran (en utilisant des lignes), puis à faire passer un véhicule dessus.

Je m'interrogeais sur la façon de faire la plus simple pour dessiner ce pont. Je pensais à afficher une grille de points, puis l'utilisateur pourrait cliquer sur 2 de ces points, et cela afficherait une ligne entre ces 2 points. En répétant cette opération quelques fois, on pourrait ainsi créer une esquisse sommaire de pont. Le problème est que je bloque sur la manière d'afficher cette grille de points.. Je vois plus ou moins bien comment faire pour les lignes (on utiliserait un mouseListener, qui permettrait de récupérer les coordonnées des 2 points cliqués, puis on dessinerait la ligne avec drawLine en utilisant les 4 coordonnées récupérées), mais je ne vois pas du tout comment faire pour la grille. J'ai vu des exemples de grilles "classiques", avec les cases, mais selon moi, il serait plus utile d'utiliser l'objet Point de Java afin d'avoir directement les coordonnées x,y sur la grille.

Avez vous des idées sur la façon de faire ?

[wax78]

J'avoue ne pas comprendre ton histoire de grille. Par contre dessiner le pont a coup de drawline oui ca me semble bien. (en utilisant ce que tu as décrit pour detecter les click de souris et en sauvegardant toutes les coordonées des lignes en mémoire pour l'affichage et autres).

Jette un oeil la dessus : http://duj.developpez.com/tutoriels/java/dessin/intro/ ca te permettra peut être de faire une premier jet.

(Edit : La grille ce sont des points fixé qui permettent de pouvoir dessiner une ligne de manière non arbitraire dans l'espace en fait ?)

[Invité]

Oui c'est exactement ça pour la grille. Ca permet à l'utilisateur d'avoir des repères spatiaux assez simples à utiliser, et pour nous assez simple à utiliser derrière. Si j'ai parlé d'utiliser l'objet Point, c'est pour avoir accès rapidement à ses coordonnées dans la grille. Mais peut être qu'il y a une manière plus simple ?

[joel.drigo]

Salut,

La classe java.awt.Point (ou la classe java.awt.geom.Point2D) n'est pas un objet "graphique", comme le serait un JLabel, ou autre JComponent. De plus, il n'existe pas de méthode de dessin de points, du même type que celles qui permettent de dessiner des lignes ou des rectangles, par exemple. Il faut que tu utilises une autre méthode pour rendre le point, par exemple dessiner un disque. On pourrait maintenir une structure qui contient les points de ta grille (un tableau par exemple), mais ceci aura le défaut d'être fixée, donc limitée : le mieux est d'avoir une grille virtuelle, calculée et dessinée dynamiquement.

Exemple :

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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
public class GridMagDrawDemo extends JPanel {
 
	private final List<Line2D> lines; // pour stocker les lignes dessinées
	private final Rectangle size; // la taille de la zone à dessiner (qui englobe toutes les lignes)
	private final int hGridStep; // le pas horizontal de la grille
	private final int vGridStep; // le pas vertical de la grille
 
	private Point point; // le point correspondant à la souris
	private Line2D line; // le ligne en cours de dessin
 
	private Rectangle tmpsize;
 
	public GridMagDrawDemo(int hGridStep, int vGridStep) {
		super(true);
		lines=new ArrayList<Line2D>();
		size=new Rectangle();
		this.hGridStep=hGridStep;
		this.vGridStep=vGridStep;
		setBackground(Color.BLACK);
 
		// pour gérer l'interactivité
		MouseAdapter mouseListener = new MouseAdapter() {
 
			@Override
			public void mouseMoved(MouseEvent e) {
				point = magnetize(e.getPoint());
				repaint();
			}
 
			@Override
			public void mouseExited(MouseEvent e) {
				point = null;
				repaint();
			}
 
			@Override
			public void mousePressed(MouseEvent e) {
				line = new Line2D.Double(point, point);
				repaint();
			}
 
			@Override
			public void mouseDragged(MouseEvent e) {
				line.setLine(line.getP1(), magnetize(e.getPoint()));
				tmpsize = new Rectangle(size);
				updateSize(line, tmpsize);
				revalidate();
				repaint();
			}
 
			@Override
			public void mouseReleased(MouseEvent e) {
				if ( line!=null ) {
					if ( !line.getP1().equals(line.getP2()) ) {
						lines.add(line);
						updateSize(line, size);
					}
					line=null;
					tmpsize=null;
					repaint();
				}
			}
 
		};
 
		addMouseListener(mouseListener);
		addMouseMotionListener(mouseListener);
 
	}
 
	private void updateSize(Line2D line, Rectangle size) {
		Rectangle bounds = line.getBounds();
		bounds.setFrame(bounds.x-hGridStep, bounds.y-vGridStep, bounds.width+hGridStep*2, bounds.height+vGridStep*2);
		size.setFrame(size.union(bounds));
		size.setFrame(0, 0, size.width+size.x, size.height+size.y);
		revalidate();
	}
 
	// simule une grille
	private Point magnetize(Point point) {
		int x = (point.x/hGridStep) * hGridStep;
		int y = (point.y/vGridStep) * vGridStep;
		point.x = nearest(point.x, x, x+hGridStep);
		point.y = nearest(point.y, y, y+vGridStep);
		return point;
	}
 
	// détermine la coordonnée la plus proche
	private int nearest(int current, int pos1, int pos2 ) {
		if ( current-pos1< pos2-current ) {
			return pos1;
		}
		else {
			return pos2;
		}
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		drawGrid(g); // on dessine la grille
		drawLines((Graphics2D)g); // on dessine les lignes
		drawMouse((Graphics2D)g); // on dessine le résultat du dessin courant
	}
 
	private void drawGrid(Graphics g) {
 
		g.setColor(Color.GRAY); // on dessine la grille en gris
 
		int width = Math.max(getWidth(), size.width) + hGridStep;
		int height = Math.max(getHeight(), size.height) + vGridStep;
 
		int xs = size.x - hGridStep;
 
		int y=size.y-hGridStep;
		while( y<=height ) {
			int x=xs;
			while( x<=width ) {
				drawPoint(g, x, y); 
				x+=hGridStep;
			}
			y+=vGridStep;
		}
 
	}
 
	private void drawLines(Graphics2D g) {
		g.setColor(Color.WHITE); // on dessine les lignes en blanc
		for(Line2D line : lines) {
			drawLine(g, line);
		}
	}
 
	private void drawMouse(Graphics2D g) {
		if ( point!=null ) {
			g.setColor(Color.YELLOW);
			fillPoint(g, point.x, point.y);
		}
		if ( line!=null && !line.getP1().equals(line.getP2()) ) {
			g.setColor(Color.CYAN);
			drawLine(g, line);
		}
	}
 
	private void drawLine(Graphics2D g, Line2D line) {
		fillPoint(g, (int)line.getX1(), (int)line.getY1());
		fillPoint(g, (int)line.getX2(), (int)line.getY2());
		g.draw(line);
	}
 
	private void drawPoint(Graphics g, int x, int y) {
		g.drawOval(x-2,y-2,4,4); // on représente un point par un cercle
	}
 
	private void fillPoint(Graphics g, int x, int y) {
		g.fillOval(x-2,y-2,4,4); // on représente un point par un cercle
	}
 
	// pour dimension le panel( nécessaire pour l'adaptation du scrollpane
	@Override
	public Dimension getPreferredSize() {
		if( tmpsize!=null ) return tmpsize.getSize();
		return size.getSize();
	}
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		frame.getContentPane().add(new JScrollPane(new GridMagDrawDemo(25,25)));
 
		frame.setSize(300, 200);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
}

[Invité]

Merci beaucoup de ta réponse ! Cela m'aide beaucoup
Effectivement, je dois dire que je bloquais sur la façon d'afficher les points, et je confondais l'objet Point et le cercle plein pour le graphique.
Autre chose, je me posais la question de comment représenter l'effet de la gravité sur ce pont. J'ai pensé à faire courber les lignes en fonction du poids qu'on appliquerai (par exemple un véhicule plus ou moins lourd passant sur le pont dessiné à l'écran). Cela serait donc un affichage dynamique.
Cela serait compatible avec les lignes que l'on dessine à l'écran en utilisant la grille dynamique ?
Encore une fois, merci beaucoup de votre aide !

[joel.drigo]

Les jeux de type bridge building gèrent, à ma connaissance, ça en deux phases : la construction du pont d'une part sans gravité, ni autres forces, et une phase dynamique avec application des forces. Ils gèrent par contre plutôt une liste de points d'ancrage fixe plutôt qu'une grille.

Mais on peut faire les deux à la fois. Cela revient à gérer à la fois une grille virtuelle (ou une liste de points d'ancrage fixe) et une liste de de points d'ancrage qui correspondent aux extrémités des lignes déjà placées. En donnant la priorité à ces dernières : on cherche, en parcourant les lignes existantes, les extrémités qui seraient plus proches que le point de la grille sur lequel on devrait normalement s'aimanter. Et on prend celui la plus proche (de la position de la souris) d'entre elles. Les extrémités des lignes peuvent se décaler de la grille virtuelle, pour une raison ou une autre, en temps réel.