Discussion :

[Roland Chastain]

Bonjour !

J'ai pensé intituler cette discussion Détournement de démineur mais réflexion faite je me suis abstenu.

J'ai donc étudié le code du Démineur de Paul TOTH. J'en ai extrait pour mon propre usage plusieurs exemples indépendants, dont cette ébauche d'un damier. En cliquant sur les petits carrés, vous les faites changer de couleur. On remarquera la simplicité du code relatif à la souris !

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
(*----------------------------------------------------------------------------*)
 
{$FRAME_WIDTH 125}
{$FRAME_HEIGHT 110}
{$BACKGROUND $CCCCCC}
 
(*----------------------------------------------------------------------------*)
 
 program Exercice;
 
(*----------------------------------------------------------------------------*)
 
 uses Flash8;
 
(*----------------------------------------------------------------------------*)  
 
type
  TCell = class(MovieClip)
    State: integer;
    cx,cy: integer;
    constructor Create(Name: string; x, y: integer);
    procedure doRelease;
    procedure Carreau;
    procedure Reset;
    procedure IsUp(NewState: integer);
  end;
 
(*----------------------------------------------------------------------------*)
 
var
  Cells: array[0..6, 0..5] of TCell;
  x, y: integer;
  s: string;
 
(*----------------------------------------------------------------------------*)
 
procedure NewGame;
var
  x, y: integer;
begin
  for x := 0 to 6 do for y := 0 to 5 do Cells[x, y].Reset;
end;
 
(*----------------------------------------------------------------------------*)
 
constructor TCell.Create(Name: string; x, y: integer);
begin
  inherited Create ( nil, Name, x + 7 * y );
  cx := x;
  cy := y;
  _x := x * 15 + 7 + 10;
  _y := y * 15 + 7 + 10;
  onRelease := doRelease;
end;
 
(*----------------------------------------------------------------------------*)
 
procedure TCell.doRelease;
begin
  case State of
    0: IsUp(1);
    1: IsUp(0);
  end;
end;
 
(*----------------------------------------------------------------------------*)
 
procedure TCell.Carreau;
begin
  lineStyle(0, $999999);
 
  moveTo(- 4, - 4);
 
  case State of
    0: beginFill($000000);
    1: beginFill($FFFFFF);
  end;
 
  lineTo(- 4, + 4);
  lineTo(+ 4, + 4);
  lineTo(+ 4, - 4);
  lineTo(- 4, - 4);
end;
 
(*----------------------------------------------------------------------------*)
 
procedure TCell.Reset;
begin
  IsUp(1);
end;
 
(*----------------------------------------------------------------------------*)
 
procedure TCell.IsUp(NewState: integer);
begin
  State := NewState;
 
  clear;
  moveTo(-7, +7);
 
  beginFill($FFFFFF);
 
  lineStyle(1, $888888);
  lineTo(-7, -7);
  lineTo(+7, -7);
 
  lineStyle(1, $AAAAAA);
  lineTo(+7, +7);
  lineTo(-7, +7);
 
  endFill;
 
  Carreau;
end;
 
(*----------------------------------------------------------------------------*)
 
begin
  for x := 0 to 6 do
  for y := 0 to 5 do
      begin
        s := 'cell_' + IntToStr(x) + '_' + IntToStr(y);
        Cells[x,y] := TCell.Create(s, x, y);
      end;
  NewGame;
end.
 
(*----------------------------------------------------------------------------*)

Il y a deux ou trois choses cependant à propos desquelles j'aimerais avoir les lumières d'un expert.

1° Les noms de variable x et y sont utilisés à la fois pour des variables globales, pour des variables locales et pour des paramètres. Quelle est la règle dans ce cas ?

2° Dans cette ligne : onRelease := doRelease;, la procédure doRelease est traitée comme une fonction. Comment est-ce possible ?

[Archimède]

je me permets d'essayer de répondre puisque Paul n'est pas là...

Variables globales et variables locales en même temps, ce n'est pas possible.
Paramètres aucun soucis quels que soient les cas.

Utilise avantageusement directement procedure onRelease plutôt que onRelease:=doRelease;
Il me le fait remarquer à chaque fois..

Attention le on en minuscule et R de release en majuscule, sinon ça ne marche pas.

[Roland Chastain]

Merci pour ta réponse.

J'aurais dû préciser que je parlais du code original :

Code :

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

1
2
3
4
5
var
 Cells  :array[0..15,0..15] of TCell;
 Mines  :integer;
 Flags  :integer;
 x,y,i  :integer;

Code :

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

1
2
3
4
5
procedure NewGame;
var
 x,y,i:integer;
begin
 for x:=0 to 15 do

Code :

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

1
2
constructor TCell.Create(Name:string; x,y:integer);
begin

Autrement, aucun souci, c'est-à-dire ? Dans le cas d'une variable globale et d'un paramètre qui ont le même nom, lequel est pris en compte ?

[Archimède]

Pour la boucle for to do, ce doit être une variable locale sinon ça ne marche pas. Donc la variable globale dans ce cas est ignorée...

Il peut en effet y avoir un souci si on initialise une variable locale et qu'on la mette en paramètre...laquelle de la variable locale ou globale sera retenue ...?
Ce n'est pas conseillé...

[Archimède]

Pour ta réponse, c'est le paramètre qui est pris en compte et pas la variable globale.

[Paul TOTH]

Bonjour,

voici quelques explications

il n'y a jamais de confusion entre x local, global ou paramètre...en fait une règle simple en Pascal c'est de remonter dans le code pour savoir de quoi on parle.

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
 
var
  x: Integer;
 
procedure test1;
begin
  x := 1; // on remonte et on tombe sur la variable globale
end;
 
procedure test2(x: Integer);
begin
  x := 2; // on remonte et on tombe sur le paramètre
end;
 
procedure test3;
var
  x: Integer;
begin
  x := 3; // on remonte et on tombe sur la variable locale
end;

NB: je viens de constater qu'il est possible de déclarer une variable local x alors qu'un paramètre portant le même nom existe...C'est un bug, mais en tout état de cause c'est la variable locale qui sera utilisée car elle est plus "proche" du code que le paramètre.

autre précision au cas zou

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
var
  x: Integer;
 
procedure test1;
var
  x: Integer;
begin
end;
 
procedure test2;
begin
  x := 1; // on tombe bien sur la variable globale, car la variable locale à test1 n'est pas visible en dehors de test1 (idem pour un paramètre)
end;

Concernant le on/doRelease : dans mes premiers codes j'ai intuitivement déclaré un doRelease que j'affecte à onRelease de la même façon qu'on peut le faire sous Delphi. Mais en fait, tel que FlashPascal est conçu, le simple fait de déclarer une méthode onRelease suffit....le code généré va de toute façon affecter le code de la fonction à un membre onRelease de la classe.