Discussion :

[Transgarp]

NB. Ce fil de discussion fait suite au sujet :
http://www.developpez.net/forums/sho...d.php?t=504428

Souvent je place des documents texte après le End. comme aide mémoire du fonctionnement du programme.

[krachik]

Bonjour

Souvent je place des documents texte après le End. comme aide mémoire du fonctionnement du programme.

De bons commentaires dans le programme et non à la fin suffiraient amplement pour comprendre le fonctionnement de celui-ci.
Et même en plus des commentaires , le "document texte" dont tu parles je crois doit etre pour resumer de façon globale ce que va faire le programme ,il faudrait plutot le mettre au debut du programme comme ça d'entrée on sait ce à quoi on a faire .
@+

[Transgarp]

Bah, souvent le nom que je donne à la procédure ou la fonction explique l'opération à effectuer.

Petit exemple de ma facon de programmer.

J'arrive à me retrouver dans des cas de code que j'ai programmé il y a 20 ans.

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
 
Program GPG;
 
{$F+}
 
Uses
{$IFDEF DPMI}
  Crt,Dos,Printer,CHR_UNIT,
  GPG_BASE,GPG_BOOK,GPG_DATA,GPG_FICH,GPG_GED,GPG_RECH,GPG_ROOT,GPG_SORT,
  GPG_TYPE,GPG_TREE,GRP_CONS,GRP_FONC,GRP_GRAP,GRP_PROC,GRP_TYPE;
{$ELSE}
  Crt,Dos,Overlay,Printer,CHR_UNIT,
  GPG_BASE,GPG_BOOK,GPG_DATA,GPG_FICH,GPG_GED,GPG_RECH,GPG_ROOT,GPG_SORT,
  GPG_TYPE,GPG_TREE,GRP_CONS,GRP_FONC,GRP_GRAP,GRP_PROC,GRP_TYPE;
{$ENDIF}
 
{$O CHR_UNIT}
{$O GPG_8514}
{$O GPG_BASE}
{$O GPG_BOOK}
{$O GPG_DATA}
{$O GPG_FICH}
{$O GPG_PROC}
{$O GPG_RECH}
{$O GPG_ROOT}
{$O GPG_SORT}
{$O GPG_TREE}
 
Var
  FE,GG,I,IK,J,JK,PT,WD,WE  : Byte;
  IO                        : Word;
  WPP                     : PtrL1592at;
  ZZZ                      : PtrS04780at;
 
Begin
  WD:=FileExist('D:\GRP\DAT\GPG\DAT.GPG');
  WE:=FileExist('D:\GRP\DAT\GPG\ERR.GPG');
  FE:=FileExist('D:\GRP\DAT\GPG\WINBAT');
 
{$IFDEF DPMI}
{$ELSE}
  OvrInit('D:\TMP\GPG.OVR');
  If OvrResult<>OvrOk then OvrInit('D:\GRP\OVR\GPG.OVR');
  If OvrResult<>OvrOk then WriteErrorOVR;
{$ENDIF}
 
  Test_Print(FE, PT,IO); GetMem(WPP,MemTPX(5580)); GetMem(ZZZ,MemTPX(2835));
  For J:=0 to 4 Do For I:=1 to 7 Do ZZZ^[J,I]:=Strings(80,' ');
  For J:=1 to 15 Do For I:=0 to 91 Do WPP^[J,I]:=0;
  Repeat
    SetTextMode(3); Color(0,7); ClrScr; WriteOwner(13,4); Color(10,0); GotoXY(9,2);
    If FE=0
    then Write('      Mode DOS         ')
    else Write('      Mode Windows     ');
    WriteXY(9,06,C1s); WriteXY(9,07,'³      GENEALOGIE     ³');
    WriteXY(9,08,C2s); WriteXY(9,09,'³    Version  2.00    ³');
    WriteXY(9,10,C3s); Color(14,0); WriteXY(9,12,'Pèse ESC pour System   ');
    If WD=1 then Color(12,0);
    WriteXY(9,WhereY+1,'Pèse  A  pour Arbre    ');
    If WD=0 then WriteXY(9,WhereY+1,'Pèse  B  pour Base     ');
    Color(14,0); WriteXY(9,WhereY+1,'Pèse  C  pour Caractère');
    If WE=0 then WriteXY(9,WhereY+1,'Pèse  D  pour Data     ');
    WriteXY(9,WhereY+1,'Pèse  F  pour Fichier  ');
    If WD=0 then WriteXY(9,WhereY+1,'Pèse  G  pour Gedcom   ');
    If WD=0 then
    Begin
      If IO>0 then Color(12,0);
      WriteXY(9,WhereY+1,'Pèse  L  pour Livre    ');
    End;
    If WD=1 then Color(12,0) else Color(14,0);
    WriteXY(9,WhereY+1,'Pèse  O  pour Origine  ');
    WriteXY(9,WhereY+1,'Pèse  R  pour Recherche'); Color(14,0);
    IF FE=0
    then WriteXY(9,WhereY+1,'Pèse  M  pour Mode WIN ')
    else WriteXY(9,WhereY+1,'Pèse  M  pour Mode DOS ');
    If WD=1 then WriteXY(9,WhereY+1,'Pèse  S  pour Sort     ');
    WriteXY(9,25,'MEM='); Write(MemAvail:9,' DF=',DiskFree(0) Div 150:6);
    Cursor(0,7);
    Repeat
      InkeyJ(IK,JK); GG:=0;
      Case IK of
         27,46 : GG:=1;
         65    : GG:=2;
         66    : If WD=0 then GG:=3;
         67    : GG:=4;
         68    : If WE=0 then GG:=5;
         70    : GG:=6;
         71    : If WD=0 then GG:=7;
         76    : If WD=0 then GG:=8;
         77    : GG:=12;
         79    : GG:=9;
         82    : GG:=10;
         83    : GG:=11;
        255    : GG:=255;
      End;
    Until GG>0;
 
 
    Case GG of
       2 : P_Arbre(IO,PT,WD);
                   {          03             11 12 13 14    44 79 90 91    }
       3 : P_Base(WD);
                   {          03             11 12 13 14    44 79 90 91    }
       4 : P_Chr(1);
       5 : P_Data(IO, WD,WPP,ZZZ);
                   { 00 01 02 03 04 05    10 11 12 13 14 33 44 79 90 91    }
       6 : P_Fichier(IO,PT);
                   { 00 01 02 03 04 05 06 10 11 12 13 14 33 44 79 90 91 95 }
       7 : P_Gedcom;
       8 : P_Book(IO,PT);
                   { 00 01    03 04 05 06    11 12 13 14       79 90 91    }
       9 : P_Origine(IO,PT);
                   {          03             11 12 13 14    44 79 90 91    }
      10 : P_Rech(IO,PT);
                   {          03             11 12 13 14    44 79 90 91 95 }
      11 : Fichier_Sort(WD);
      12 : Begin
             FE:=1-FE; Ecrire_Fichier_Signal(FE,'D:\GRP\DAT\GPG\WINBAT');
             Test_Print(FE, PT,IO);
           End;
    End;
  Until GG=1;
  FreeMem(ZZZ,MemTPX(2835)); FreeMem(WPP,MemTPX(5580)); Color(15,0); SetTextMode(3);
  If PT in [1,2] then Prt(5,48,0,160,48);
End.
 
 GPG_RECH.DOC   (Font Num = 1004; Line = 80; Orient = P)
 GPG_ROOT.DOC   (Font Num = 1004; Line = 80; Orient = P)
 GPG_TREE.DOC   (Font Num = 1001; Line = 65; Orient = L)

[diden138]

alors disons que tu est un pro du désordre .
tu t y trouve ok mais il faut penser aussi aux gens qui pourrait utiliser notre code
cordialement @+

[droggo]

Cei,

J'ose espérer que ce n'est pas un prof qui t'a appris à écrire du code comme ça.

Si tu reviens à la programmation après une période d'arrêt, fais un effort sur la présentation du code. Tu verras que ça te sera utile, même si "J'arrive à me retrouver dans des cas de code que j'ai programmé il y a 20 ans.", ne serait-ce que pour le faire lire par d'autres, comme rappelé par diden138.

Une présentation "propre" implique plus ou moins :

- des noms (procédures, fonctions, types, constantes, variables...) ayant un rapport avec leur rôle (par exemple, ne pas appeler "soupiere" une variable contenant les données concernant un couteau ))).

- du code indenté régulièrement et de manière cohérente

- du code aéré, c'est à dire des lignes vides pour séparer les différents blocs fonctionnels d'une fonction, et, bien entendu, pour séparer les différentes procédures/fonctions (à ce niveau là, je préconise même d'ajouter une ligne commentée, genre

Code :

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

1
2
3
4
5
6
7
8
9
procedure blabla
...
end;
 
{ ---------------------------------------------------------- }
 
function allo : boolean;
...
end;

- et enfin, des commentaires clairs et précis, suffisamment, mais pas trop (pas la peine de mettre

Code :

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

1
2
    {lecture du prix }
    readln(prix);

on voit ici un des intérêts des noms bien utilisés : le code devient auto-commenté).
Généralement, on met, au minimum

* au début du programme, ce qu'il est chargé de faire (pour une unité, le but global des procedures/fonctions... définies, par exemple "Implémentation de calcul multi-précision").

* à quoi correspondent les types, constantes définis, si nécessaire
( pas la peine de mettre

Code :

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

1
2
3
4
5
const
  lim = 1000;
 
type
  ma_Table = array [1..lim] of Integer; { tableau de 1000 éléments entiers }

surtout que là on mélange une valeur en dur avec la définition d'une constante, bonjour la maintenance)

* un petit commentaire pour expliquer ce que fait une procédure/fonction, idem pour les différents blocs fonctionnels, si ce n'est pas immédiatement apparent

* ne pas hésiter à développer l'algorithme utilisé s'il sort des grands classiques que tous devraient connaître (même dans ce cas, il n'est pas inutile de rappeler "blabla ..... par algorithme trucmuche), au moins les étapes délicates, s'il y en a.

Bref, tout doit être fait pour que le code soit clair et facilement lisible/compréhensible, c'est nécessaire pour la maintenance, point primordial trop souvent oublié.

[Transgarp]

J'ai fait un BAC en informatique de génie à l'Université Laval entre 1990-1994

Un programme que j'avais à remettre dans le cours d'Infographie IFT10558 à l'automne 1992

J'ai eu 95% comme résultat de ce programme

Excusez, pour les caractères spéciaux du style éèêâà, ils vont vous paraître tout bizarre car je n'ai pas le temps de réécrire le programme en mode texte. Il vient directement du code BP7 et j'ai fait attention pour ce travail de bien aérer les lignes de code, ce que je fais moins en pratique pour mes applications personnelles et question d'un visuel plus rapide.

Vous verrez que je suis aussi capable de documenter pleinement un programme, mais que dans des big programmes avec plusieurs overlay, 50000 lignes de codes, le moindre caractère de documentation diminue l'espace mémoire pour compiler ce dit programme.

Pour plus de facilité de lecture j'écris plusieurs commandes sur la même ligne pour avoir un visuel plus rapide.

Sur une demie douzaine de mes programmes que j'utilise à tous les jours, la moindre ligne de code inutile, de terme trop long ou trop documentée, diminue le nombre de variable à utiliser.

Autre chose, l'informatique n'est pas mon travail, je programme par plaisir à la maison et mon boulot est la mécanique moto

Alors le fait que les gens puissent comprendre ou non mes programmes m'importe peu, l'important est qu'après 10 ans, je peu relire mes programmes comme si je les avait écris la veille et c'est ce qui se passe.

A part l'Université, je n'ai jamais fait de programmes pour les autres ou dans quelques cas rare ou des gens en Maitrise Informatique en arrachait avec du code vu qu'ils étaient plus spécialisé organigramme sur tableau que faire du code.

Ma facon de nommer les fonctions et procédures est pareille pour tout mes programmes et en plus j'utilise en commun des groupes de fonctions et de procédures pour une trentaine de programmes.

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
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
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
 
Program TP6;                           { Tours de Hanoi                       }
 
{ Ce programme a ‚t‚ r‚alis‚ dans le mode texte et montre une application     }
{ du principe de la r‚cursivit‚ utilis‚ en informatique.                      }
{                                                                             }
{ Au d‚part 4 questions sont demand‚es … l'utilisateur:                       }
{                  - Le nombre d'anneaux.                                     }
{                  - La tour source.                                          }
{                  - La tour cible.                                           }
{                  - La vitesse de d‚placement de l'anneau.                   }
{                                                                             }
{ Au d‚but, la vitesse, le temps de d‚part et les anneaux sont affich‚s       }
{                                                                             }
{ A la fin, le temps d'arriv‚e, le nombre de mouvement ex‚cut‚ et             }
{ la nouvelle position des anneaux sont affich‚s, et un menu demande          }
{ la prochaine op‚ration … ex‚cuter:                                          }
{                  - PŠse ESC pour Sortir                                     }
{                  - PŠse TAB pour Continuer                                  }
 
Uses
  Crt, Dos;
Const
  BASE          =    20;               { Plancher des 3 Tours                 }
  LIGNE_BASSE   =    24;               { Ligne du bas de l'‚cran              }
  NB_ANNEAU_MAX =    12;               { Nombre maximum d'anneau              }
  TOUR_POSI                            { Position en X des 3 Tours            }
  : Array[1..3] of Integer = (2, 28, 54);
 
Type
  Matrice_A     = Array[0..NB_ANNEAU_MAX + 1] of Integer;
  Matrice_B     = Array[1..NB_ANNEAU_MAX, 0..1] of Integer;
  Matrice_C     = Array[1..3] of Integer;
  Matrice_S     = Array[1..NB_ANNEAU_MAX + 1] of String[NB_ANNEAU_MAX * 2 + 1];
 
Var
  IK               : Char;             { Cl‚ lu du clavier                    }
  A, B,                                { Compteurs divers                     }
  HAUT,                                { Plafond des tours                    }
  NB_MOUVEMENT,                        { Indicateur du nombre de mouvement    }
  NIVEAU_RECURSION,                    { Niveau de r‚cursivit‚ de proc‚dure   }
  TEMPS_X,                             { Temps de d‚placement en X            }
  TEMPS_Y,                             { Temps de d‚placement en Y            }
  VITESSE          : Integer;          { Vitesse de d‚placement des anneaux   }
  ANNEAU           : Matrice_S;        { Dessin des anneaux                   }
  ANNEAU_NUM,                          { Num‚ro des anneaux                   }
  TOUR_SOURCE,                         { Tour Source                          }
  TOUR_CIBLE       : Matrice_A;        { Tour Cible                           }
  ANNEAU_POSI      : Matrice_B;        { Position des anneaux                 }
  TOUR_HAUTEUR     : Matrice_C;        { Hauteur des Tours                    }
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                                Fonction TP2                               ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
{-----------------------------------------------------------------------------}
Function StrNombre(NOMBRE : Integer) : String;
{ Transformation d'un nombre entier en une chaine de 2 caractŠres.            }
{ Analogie de la proc‚dure Str interdite                                      }
Var
  A, B   : Byte;
  CHAINE : String;
Begin
  B      := 10;
  CHAINE := '';
  For A := 1 to 2 Do
  Begin
    CHAINE := CHAINE + Chr(NOMBRE Div B + 48);
    NOMBRE := NOMBRE Mod B;
    B      := B Div 10;
  End;
  StrNombre := CHAINE;
End;
 
{-----------------------------------------------------------------------------}
Function ValChaine(CHAINE_1 : String) : Integer;
{ Transformation d'une chaine de 4 caractŠres en nombre entier.               }
{ Analogie de la proc‚dure Val interdite                                      }
Var
  A                       : Byte;      { Compteur                             }
  MULTIPLICATEUR, NOMBRE  : Integer;
Begin
  NOMBRE         := 0;
  MULTIPLICATEUR := 1000;
  For A := 1 to 4 Do
  Begin
    NOMBRE         := NOMBRE + (Ord(CHAINE_1[A]) - 48) * MULTIPLICATEUR;
    MULTIPLICATEUR := MULTIPLICATEUR Div 10;
  End;
  ValChaine := NOMBRE;
End;
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                               Proc‚dure TP2                               ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
{-----------------------------------------------------------------------------}
Procedure Valider_Entier(Var NOMBRE  : Integer;  { Coordonn‚e format entier   }
                             MINIMUM,            { Nombre limite min permis   }
                             MAXIMUM : Integer); { Nombre limite max permis   }
Const
  CHIFFRE : Set of '0'..'9' = ['0','1','2','3','4','5','6','7','8','9'];
Var
  EFFACE, A, LONGEUR : Byte;           { Efface, Compteur, longueur CHAINE_1  }
  INKEY              : Char;           { CaractŠre lu du clavier              }
  CHAINE_1, CHAINE_2 : String;         { Sert pour r‚ajustement de CHAINE_1   }
Begin
  EFFACE := 1;
  While (EFFACE = 1) or (LONGEUR > 4) Do
  Begin
    INKEY    := #1;
    LONGEUR  := 0;
    CHAINE_1 := '';
    While (INKEY <> #13) and (LONGEUR < 5) Do
    Begin                    { Lecture du clavier                             }
      Write(' ',#8);
      INKEY := ReadKey;      { ReadKey indispensable pour l'invisibilit‚      }
      If (INKEY = #8) and (LONGEUR > 0)
      then Begin             { Effacement du dernier caractŠre de la CHAINE_1 }
             LONGEUR := LONGEUR - 1;
             Write(#8,' ',#8);
             CHAINE_2 := '';
             For A := 1 to LONGEUR Do CHAINE_2 := CHAINE_2 + CHAINE_1[A];
             CHAINE_1 := CHAINE_2;
           End
      else If CHIFFRE * [INKEY] <> [] then
           Begin             { Ajout d'un nouveau caractŠre … la CHAINE_1     }
             LONGEUR := LONGEUR + 1;
             CHAINE_1 := CHAINE_1 + INKEY;
             Write(INKEY);
           End;
    End;
    If CHAINE_1 = '' then Write('0');
                             { Si Enter sans caractŠre, NOMBRE sera 0         }
    If LONGEUR > 4
    then EFFACE := 1         { Message pour effacer CHAINE_1                  }
    else Begin               { Ajustement … 4 caractŠres de CHAINE_1          }
           For A := 1 to 4 - LONGEUR Do CHAINE_1 := '0' + CHAINE_1;
           If (ValChaine(CHAINE_1) > MAXIMUM)
           or (ValChaine(CHAINE_1) < MINIMUM)
           then EFFACE := 1            { Message pour effacer CHAINE_1        }
           else EFFACE := 0;           { Message pour valider CHAINE_1        }
         End;
    If EFFACE = 1 then                 { Efface CHAINE_1                      }
    For A := 1 to LONGEUR Do Write(#8,' ',#8);
  End;
  NOMBRE := ValChaine(CHAINE_1);       { Conversion num‚rique de CHAINE_1     }
End;
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                               Proc‚dure TP6                               ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
{-----------------------------------------------------------------------------}
Procedure Afficher_Temps(LY : Byte; CHAINE : String);
{ GetTime mˆme si interdit est la seule facon de mesurer le temps sur PC      }
Var
  HEURE, MINUTE, SECONDE, SEC100 : Word;
Begin
  GetTime(HEURE, MINUTE, SECONDE, SEC100);
  GotoXY(1, LY);
  Write(CHAINE);
  If HEURE < 10 then Write('0', HEURE) else Write(HEURE:2);
  If MINUTE < 10 then Write(':0', MINUTE) else Write(':', MINUTE:2);
  If SECONDE < 10 then Write(':0', SECONDE) else Write(':', SECONDE:2);
End;
 
{-----------------------------------------------------------------------------}
Procedure Color(A, B : Byte);          { Analogie de Color(a,b) de BASIC      }
Begin
  Textcolor(A);
  TextBackground(B);
End;
 
{-----------------------------------------------------------------------------}
Procedure Cursor(A, B : Byte);         { Efface le curseur aprŠs affichage    }
Begin
  Color(B, B);
  Write(' ', #8);
  Color(A, B);
End;
 
{-----------------------------------------------------------------------------}
Procedure Initialiser; { Initialise l'‚cran et obtient le nombre d'anneau     }
Begin
  Color(15, 1);                         { Initialise la couleur de l'‚cran     }
  ClrScr;
  Color(12, 1);
  GotoXY(30, 1);
  Write('TOURS de HANOI');             { Affiche le nom du programme          }
  Cursor(14, 1);
  GotoXY(1, 24);
  Write('Nombre d', #39, 'Anneau (1 … ', StrNombre(NB_ANNEAU_MAX), ') ');
  Cursor(14, 1);
  GotoXY(26, 24);
  Valider_Entier(ANNEAU_NUM[1], 0, NB_ANNEAU_MAX);
  GotoXY(1, 24);
  Write(' ':79);                       { Nettoie la ligne de commande         }
  GotoXY(1, 24);
  Write('Entrer le num‚ro de la tour source (1 … 3) ');
  Valider_Entier(TOUR_SOURCE[0], 1, 3);
  GotoXY(1, 24);
  Write(' ':79);
  GotoXY(1, 24);
  Write('Entrer le num‚ro de la tour cible (1 … 3) ');
  Valider_Entier(TOUR_CIBLE[0], 1, 3);
  GotoXY(1, 24);
  Write(' ':79);
  GotoXY(1, 24);
  Write('Entrer la vitesse de d‚placement ( 1=>10000æsec  …  4=>1 æsec) ');
  Valider_Entier(VITESSE, 1, 4);
  GotoXY(1, 24);
  Write(' ':79);
  Color(15, 1);
  For A := 1 to VITESSE Do
  Begin TEMPS_X:=TEMPS_X Div 10; TEMPS_Y:=TEMPS_Y Div 10; End;
 
  For A := 1 to ANNEAU_NUM[1] Do
  Begin                                { Cr‚ation des anneaux                 }
    ANNEAU[A] :='';
    For B := 1 to NB_ANNEAU_MAX * 2 + 1 Do ANNEAU[A] := ANNEAU[A] + ' ';
    For B := NB_ANNEAU_MAX + 1 - A to NB_ANNEAU_MAX + A + 1 Do
      ANNEAU[A, B] := #219;
  End;
 
  HAUT := BASE - ANNEAU_NUM[1];
  For A := HAUT to HAUT + ANNEAU_NUM[1] Do for B := 0 to 2 Do
  Begin                                { Cr‚ation des tours                   }
    GotoXY(B * 26 + 14, A);
    Write('Û');
  End;
 
  GotoXY(2, HAUT + ANNEAU_NUM[1] + 1);
  For A := 2 to 78 Do Write('Û');      { Cr‚ation plancher                    }
 
  For A := 1 to ANNEAU_NUM[1] Do       { Affiche les anneaux de d‚part        }
  Begin
    ANNEAU_POSI[A, 0] := HAUT + A;                    { Assigne la rang‚e     }
    ANNEAU_POSI[A, 1] := TOUR_POSI[TOUR_SOURCE[0]];   { Assigne la colonne    }
    GotoXY(TOUR_POSI[TOUR_SOURCE[0]], HAUT + A);
    Color(A Mod 14 + 1, 1);
    Write(ANNEAU[A]);                  { Affiche l'anneau courant             }
  End;
End;
 
{-----------------------------------------------------------------------------}
Procedure Afficher_Message_Ecran;
Begin
  GotoXY(30, 1);
  Color(14, 1);
  Write('TOURS de HANOI pour ', ANNEAU_NUM[1], ' Anneau');
  If ANNEAU_NUM[1]>1 then Write('x');
  Cursor(15, 1);
End;
 
{-----------------------------------------------------------------------------}
Procedure Afficher_Mouvement;
Var
  OLD_X, OLD_Y,                        { Ancienne position X et Y             }
  NEW_X, NEW_Y : Integer;              { Nouvelle position X et Y             }
Begin
  NEW_X := TOUR_POSI[TOUR_CIBLE[NIVEAU_RECURSION]];
                             { Va … la position du prochain … d‚placer        }
  Color(15, 1);
  TOUR_HAUTEUR[TOUR_SOURCE[NIVEAU_RECURSION]] :=
    TOUR_HAUTEUR[TOUR_SOURCE[NIVEAU_RECURSION]] + 1;
  NEW_Y := TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]];
  OLD_Y := ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 0];
  OLD_X := ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 1] + 1;
  For A := OLD_Y downto HAUT Do
  Begin
    GotoXY(OLD_X - 1, A);
    Write('            Û            ');
    Cursor(15, 1);
    GotoXY(OLD_X - 1, A - 1);
    Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
    Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]);      { Affiche l'anneau      }
    Cursor(15, 1);
    Delay(TEMPS_Y);
  End;
  If NEW_X > OLD_X
  then For A := OLD_X Div 2 to (NEW_X + 1) Div 2 Do
       Begin
         GotoXY(A * 2, HAUT - 1);
         Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
         Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]); { Affiche l'anneau      }
         Cursor(15, 1);
         Delay(TEMPS_X);
         GotoXY(A * 2, HAUT - 1);
         Color(15, 1);
         Write('                         ');          { Efface l'anneau       }
         Cursor(15, 1);
       End
  else For A := (OLD_X - 1) Div 2 downto NEW_X Div 2 Do
       Begin
         GotoXY(A * 2, HAUT - 1);
         Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
         Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]); { Affiche l'anneau      }
         Cursor(15, 1);
         Delay(TEMPS_X);
         GotoXY(A * 2, HAUT - 1);
         Color(15, 1);
         Write('                         ');          { Efface l'anneau       }
         Cursor(15, 1);
       End;
  For A := HAUT to NEW_Y Do
  Begin
    GotoXY(NEW_X, A);
    Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
    Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]);      { Affiche l'anneau      }
    Cursor(15, 1);
    Delay(TEMPS_Y);
    If A <> NEW_Y then
    Begin
      Color(15, 1);
      GotoXY(NEW_X, A);
      Write('            Û            ');
      Cursor(15, 1);
    End;
  End;
 
                             { Mise … jour de la position courante de l'anneau}
  ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 0] :=
                                   TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]];
  ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 1] := NEW_X;
 
                             { D‚cr‚mente la hauteur de la tour source        }
  TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]] :=
                               TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]] - 1;
End;
 
{-----------------------------------------------------------------------------}
Procedure Executer_Mouvement(Var NB_MOUVEMENT : Integer);
Begin
  NIVEAU_RECURSION := NIVEAU_RECURSION + 1;
  If ANNEAU_NUM[NIVEAU_RECURSION] = 0
  then NIVEAU_RECURSION := NIVEAU_RECURSION - 1
  else Begin
         ANNEAU_NUM[NIVEAU_RECURSION + 1] := ANNEAU_NUM[NIVEAU_RECURSION] - 1;
         TOUR_SOURCE[NIVEAU_RECURSION + 1] := TOUR_SOURCE[NIVEAU_RECURSION];
         TOUR_CIBLE[NIVEAU_RECURSION + 1] := 6 -
           TOUR_SOURCE[NIVEAU_RECURSION] - TOUR_CIBLE[NIVEAU_RECURSION];
         Executer_Mouvement(NB_MOUVEMENT);
         NB_MOUVEMENT := NB_MOUVEMENT + 1;
         Afficher_Mouvement;
         ANNEAU_NUM[NIVEAU_RECURSION + 1] := ANNEAU_NUM[NIVEAU_RECURSION] - 1;
         TOUR_SOURCE[NIVEAU_RECURSION + 1] := 6 -
           TOUR_SOURCE[NIVEAU_RECURSION] - TOUR_CIBLE[NIVEAU_RECURSION];
         TOUR_CIBLE[NIVEAU_RECURSION + 1] := TOUR_CIBLE[NIVEAU_RECURSION];
         Executer_Mouvement(NB_MOUVEMENT);
         NIVEAU_RECURSION := NIVEAU_RECURSION - 1;
       End;
End;
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                            Programme principal                            ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
 
Begin
  IK := #1; 
  While IK <> #27 Do
  Begin
    NB_MOUVEMENT := 0;
    TEMPS_X:=10000; TEMPS_Y:=20000;
    Initialiser;                       { Initialise variables                 }
    Afficher_Message_Ecran;
    GotoXY(1, 3);
    Write('Vitesse de d‚placement = ',VITESSE);
    Afficher_Temps(5, 'Temps de d‚part = ');
    If TOUR_SOURCE[0] <> TOUR_CIBLE[0] then
    Begin
      For B := 1 to 3 Do TOUR_HAUTEUR[B] := 0;
      TOUR_HAUTEUR[TOUR_SOURCE[0]] := HAUT;
      TOUR_HAUTEUR[TOUR_CIBLE[0]]  := BASE;
      For B := 1 to 3 Do If TOUR_HAUTEUR[B] = 0 then
      Begin
        TOUR_HAUTEUR[B] := BASE;
        B := 3;
      End;
      TOUR_SOURCE[1]   := TOUR_SOURCE[0];
      TOUR_CIBLE[1]    := TOUR_CIBLE[0];
      NIVEAU_RECURSION := 0;
      Executer_Mouvement(NB_MOUVEMENT);
    End;
    Color(15, 1);
    Afficher_Temps(6, 'Temps d'+#39+'arriv‚e = ');
    GotoXY(1, 24);
    Write('PŠse TAB pour Continuer');
    GotoXY(1, 25);
    Write('PŠse ESC pour Sortir');
    Color(14, 1);
    GotoXY(40, 24);
    Write('Termin‚ en ', NB_MOUVEMENT, ' Mouvement');
    If NB_MOUVEMENT>1 then Write('s');
    Cursor(14, 1);
    IK := ReadKey;
  End;
End.