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
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
|
// Fichier BasicRobotController.java
import java.awt.*;
import fsa.robots.*;
/**
* Un contrôleur de robot qui utilise le BasicRobotGeom
* et maintient un
* état (position, couleur de l'encre, ...)
* @author: Sébastien
* @version 24/10/2006
* @see BasicRobotGeom
* @see VisualFrame
*/
public class BasicRobotController {
// Variables d'instance: existent pour chaque objet
private double curX, curY; // coordonnées courantes du robot
private int curAngle; // orientation courante du robot
private boolean curPen; // true si la plume dessine
private Color curColor; // couleur de la plume
private BasicRobotGeom robot ; // Le robot contrôlé
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// Constructeur
/**
* Construit un contrôleur qui contrôle un robot en maintenant
* de l'état
* Le robot créé est à l'origine, plume (noire) levée,
* pointe vers les abscisses croissantes.
*/
public BasicRobotController(){
robot = new BasicRobotGeom();
robot.reset();
curX = 0.0;
curY = 0.0;
curAngle = 0;
curPen = true;
curColor = Color.black;
}
// *****************************************************************
// * Méthodes à supporter par le robot qui maintient de l'état
// * de manière à conserver l'état du robot après chaque opération *
// *****************************************************************
/*
* Cette méthode réinitialise le robot en le positionnant à l'origine,
* il pointe vers les x croissants, la pointe est levée et de couleur
* noire.
*/
public void reset() {
robot.reset(); // réinitialise le BasicRobotGeom
curX = 0.0;
curY = 0.0;
curAngle = 0;
curPen = true;
curColor = Color.black;
}
/*
* Après exécution de cette méthode, le robot a avancé de dist unités
*
*/
public void forward(int dist) {
robot.forward(dist);
curX = curX + (double)dist*(Math.cos(((Math.PI)/180)* curAngle));
curY = curY + (double)dist*(Math.sin(((Math.PI)/180)* curAngle));
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Après exécution de cette méthode, le robot a reculé de dist unités.
* Son orientation, la couleur et l'état de la plume ne sont pas modifiés.
*/
public void backward(int dist){
robot.backward(dist);
curX = curX - (double) dist*(Math.cos(((Math.PI)/180)* curAngle));
curY = curY - (double) dist*(Math.sin(((Math.PI)/180)* curAngle));
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Après exécution de cette méthode, le robot s'est déplacé de façon à
* atteindre, via un chemin approprié mais non spécifié et sans laisser
* de trace, la position (x,y)
* Son orientation, la couleur et l'état de la plume ne sont pas modifiés
* après l'exécution de cette méthode
*/
public void gotoLocation(double x, double y) {
//enregistrement de l'état initial de la plume
// boolean etat = curPen;
//enregistrement de l'orientation initiale du robot
int angle = curAngle;
robot.rotate(-curAngle);
int ang = (int) Math.atan( ( (y - curY) / (x - curX) ) );
robot.rotate(ang);
int distance = (int) Math.sqrt( Math.pow((x - curX),2) + Math.pow((y - curY),2) );
robot.forward(distance);
curX=x;
curY=y;
}//Fin de la méthode gotoLocation
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Après exécution de cette méthode, le robot s'est déplacé de façon à
* atteindre, via un chemin approprié mais non spécifié et sans laisser
* de trace, l'origine.
* Son orientation, la couleur et l'état de la plume ne sont pas modifiés
* après l'exécution de cette méthode.
*/
public void gotoOrign() {
robot.rotate(-curAngle);
robot.backward((int)curX);
robot.rotate(90);
robot.backward((int)curY);
curX = 0;
curY = 0;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Après exécution de cette méthode, la pointe du robot est relevée. Son
* orientation, sa position et la couleur de la plume ne sont pas modifiés.
*/
public void penUp() {
robot.penUp();
curPen = false;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Après exécution de cette méthode, la pointe du robot est descendue. Son
* orientation, sa position et la couleur de la plume ne sont pas modifiés.
*/
public void penDown() {
robot.penDown();
curPen = true;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Après exécution de cette méthode, la pointe du robot utilise la
* couleur col. Son orientation, sa position et l'état (relevé ou non)
* de la plume ne sont pas modifiés.
*/
public void setPenColor(java.awt.Color col) {
robot.setPenColor(col);
curColor=col;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Après exécution de cette méthode, le robot a tourné de angle degrés.
*/
public void rotate(int angle) {
if(angle == 0) return;
robot.rotate(angle);
curAngle = (curAngle + angle) % 360;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Après exécution de cette méthode, et si le radius est positif,
* le robot a parcouru un arc de cercle de angle degrés et de rayon
* radius unités. Si radius est négatif, le robot ne bouge pas.
*/
public void arc(int angle, int radius) {
if(radius>0)
{
// Déplacement du robot
robot.arc(angle, radius);
// Calcul de la nouvelle position du robot
double d_curAngle = ((double)curAngle / 180.0) * Math.PI;
double d_angle = ((double)angle / 180.0) * Math.PI;
double a_radius = Math.abs((double)radius);
curX = curX + a_radius
*(Math.sin(d_curAngle) - Math.sin(d_curAngle - d_angle));
curY = curY - a_radius
*(Math.cos(d_curAngle) - Math.cos(d_curAngle - d_angle));
curAngle = (curAngle - angle ) % 360;
}
}
// ******************************************************
// * Implémentation des opérations qui renvoient l'état *
// ******************************************************
/*
* Cette méthode retourne l'abscisse de la position actuelle
* du robot.
*/
public int getCoordX() {
return (int) curX;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Cette méthode retourne l'ordonnée de la position actuelle
* du robot.
*/
public int getCoordY() {
return (int) curY;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Cette méthode retourne l'orientation actuelle du robot en degrés.
*/
public int getOrientation() {
return curAngle;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Cette méthode retourne vrai si la plume du robot est relevée.
*/
public boolean isPenUp() {
return curPen;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/*
* Cette méthode retourne la couleur actuelle de la plume du robot (Color)
*/
public Color getPenColor() {
return curColor;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/**
* Cette méthode ajoute le robot à une zone de visualisation
*/
public void addToFrame(VisualFrame frame)
{
robot.addToFrame(frame);
}
} // Fin de la classe BasicRobotController |
