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.

[droggo]

Hie,

Toute une discussion à propos des noms des variables de divers niveaux.

Une règle basique pour éviter toute ambiguïté est d'utiliser des noms différents, ne serait-ce que pour éclaircir la lecture (on oublie assez facilement qu'on a une variable locale nommée x, comme un paramètre de la fonction et ou une variable globale, d'où des confusions qui ne sont pas toujours aisées à résoudre.

Pour éviter ça, faire un effort sur les noms n'est pas difficile, non ?

[Roland Chastain]

Une discussion très instructive, comme d'habitude. Merci à Paul pour la leçon claire et précise.

Je suis assez d'accord avec droggo pour éviter les homonymies mais d'un autre côté s'il y a une règle claire et qu'on sait ce qu'on fait (et ce que fera le compilateur!), pourquoi pas ?

[Roland Chastain]

Une version améliorée du damier. Si vous le visionnez en plein écran, c'est vraiment joli. J'en parle à mon aise vu que la fonction dont je me suis servi n'est pas de moi. C'est la procédure Circle du Démineur. Pour maquiller l'emprunt, j'ai changé l'en-tête.

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
procedure TCell.Disque(r: integer);
var
  a:double;
  c1,s1:double;
  c2,s2:double;
  r2:double;
begin
  a:=3.14/4;
  c1:=cos(a);
  s1:=sin(a);
  a:=3.14/8;
  c2:=cos(a);
  s2:=sin(a);
  r2:=11*r/10;
  case State of
    0: lineStyle(0, $0000FF);
    1: lineStyle(0, $FF0000);
  end;
  moveTo(0,r);
  case State of
    0: beginFill($0000FF);
    1: beginFill($FF0000);
  end;
  curveTo( r2*s2, r2*c2, r*s1, r*c1);
  curveTo( r2*c2, r2*s2, r,0);
  curveTo( r2*c2,-r2*s2, r*s1,-r*c1);
  curveTo( r2*s2,-r2*c2, 0,-r);
  curveTo(-r2*s2,-r2*c2,-r*c1,-r*s1);
  curveTo(-r2*c2,-r2*s2, -r,0);
  curveTo(-r2*c2, r2*s2,-r*c1, r*s1);
  curveTo(-r2*s2, r2*c2, 0,r);
end;

[Paul TOTH]

ça serait sympa de pouvoir afficher directement les animations Flash dans le forum ...

[Archimède]

En effet, ça permettrait d'inciter davantage de développeurs à s'intégrer sur forum... Bonne idée

[droggo]

Hie,

Je suis assez d'accord avec droggo pour éviter les homonymies mais d'un autre côté s'il y a une règle claire et qu'on sait ce qu'on fait (et ce que fera le compilateur!), pourquoi pas ?

À ce petit jeu là, on finit généralement par se faire mordre, surtout quand le code commence à s'allonger (on dira de l'ordre de + de 10 à 20000 lignes ?).

[Roland Chastain]

Hie,

À ce petit jeu là, on finit généralement par se faire mordre, surtout quand le code commence à s'allonger (on dira de l'ordre de + de 10 à 20000 lignes ?).

Je le crois volontiers. Pour ma part au-delà de 1000 lignes j'ai déjà la tête qui tourne.

Autrement, au sujet de la possibilité d'insérer des animations Flash dans les messages, je trouve aussi que ça serait agréable. Pour le moment, il faut se connecter pour pouvoir télécharger les pièces jointes.

[Roland Chastain]

Bonjour !

Je reviens à mon damier. J'ai entrepris de le transformer en grille de Puissance-4. Il faut donc que j'arrive à faire tomber les pions. Et c'est là que j'aurais besoin d'un coup de main.

Comment faire pour que le clic sur une cellule modifie l'état d'une autre cellule ?

Bien sûr j'ai pensé au Sender de l'exemple Events, mais comment l'adapter à mon code actuel, je ne vois pas.

J'ai pensé aussi ajouter un argument à la procédure doRelease, mais quel argument ?

Autrement le programme fonctionne.

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
 
{$frame_width 125}
{$frame_height 110}
{$background $8b8b8b}
 
program essaiGrillePuissance4;
 
uses
  Flash8;
 
type
  tCellule = class(MovieClip)
    etat: integer;
    cx, cy: integer;
    constructor create(name: string; x, y: integer);
    procedure doRelease;
    procedure carreau;
    procedure reset;
    procedure isUp(nouvelEtat: integer);
  end;
 
const
  vide  =  0;
  bleu =   1;
  vert  = -1;
 
var
  cellules: array [0 .. 6, 0 .. 5] of tCellule;
  x, y: integer;
  s: string;
  compteur: integer;
 
procedure nouvellePartie;
var x, y: integer;
begin
  compteur := 0;
  for x := 0 to 6 do for y := 0 to 5 do cellules[x, y].reset;
end;
 
constructor tCellule.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 tCellule.doRelease;
begin
  if (etat = vide) and (compteur < 7 * 6) then
    if compteur mod 2 = 0 then isUp(bleu) else isUp(vert);
  //
  inc(compteur);
end;
 
procedure tCellule.carreau;
begin
  lineStyle(0, $5b5b5b);
  moveTo(- 4, - 4);
  //
  case etat of
    vide: beginFill($8b8b8b);
    bleu: beginFill($00008b);
    vert: beginFill($008b00);
  end;
  //
  lineTo(- 4, + 4);
  lineTo(+ 4, + 4);
  lineTo(+ 4, - 4);
  lineTo(- 4, - 4);
end;
 
procedure tCellule.reset;
begin
  isUp(vide);
end;
 
procedure tCellule.isUp(nouvelEtat: integer);
begin
  etat := nouvelEtat;
  //
  clear;
  //
  moveTo(-7, +7);
  beginFill($6b6b6b);
  //
  lineStyle(1, $5b5b5b);
  lineTo(-7, -7);
  lineTo(+7, -7);
  //
  lineStyle(1, $7b7b7b);
  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);
      //
      cellules[x,y] := tCellule.create(s, x, y);
      //
    end;
    //
  nouvellePartie;
end.

[Paul TOTH]

habituellement je placerais toutes les cellules dans un objet qui gère la souris et le mouvement de la pièce qui tombe mais ces modifications rapides donnent un résultat intéressant

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
 
{$frame_width 125}
{$frame_height 110}
{$background $8b8b8b}
 
program essaiGrillePuissance4;
 
uses
  Flash8;
 
type
  tCellule = class(MovieClip)
    etat: integer;
    cx, cy: integer;
    constructor create(name: string; x, y: integer);
    procedure doRelease;
    procedure carreau;
    procedure reset;
    procedure isUp(nouvelEtat: integer);
    procedure onEnterFrame; override;
  end;
 
const
  vide  =  0;
  bleu =   1;
  vert  = -1;
 
var
  cellules: array [0 .. 6, 0 .. 5] of tCellule;
  x, y: integer;
  s: string;
  compteur: integer;
 
  couleur : Integer;
  caseX   : Integer;
  caseY   : Integer;
 
procedure nouvellePartie;
var x, y: integer;
begin
  compteur := 0;
  for x := 0 to 6 do for y := 0 to 5 do cellules[x, y].reset;
  couleur := bleu;
  caseX := -1;
end;
 
constructor tCellule.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 tCellule.onEnterFrame;
begin
  if (cx = caseX) and (cy = caseY) then
  begin
    if (cy = 5) or (cellules[cx, cy + 1].etat <> vide) then
      caseX := -1
    else begin
      Inc(caseY);
      cellules[caseX, caseY].isUp(etat);
      isUp(vide);
    end;
  end;
end;
 
procedure tCellule.doRelease;
begin
(*
  if (etat = vide) and (compteur < 7 * 6) then
    if compteur mod 2 = 0 then isUp(bleu) else isUp(vert);
  //
  inc(compteur);
*)
  if (caseX < 0) and (compteur < 7 * 6) and (cellules[cx, 0].etat = vide) then
  begin
    inc(compteur);
    caseX := cx;
    caseY := 0;
    cellules[caseX, caseY].isUp(couleur);
    if couleur = bleu then
      couleur := vert
    else
      couleur := bleu;
  end;
end;
 
procedure tCellule.carreau;
begin
  lineStyle(0, $5b5b5b);
  moveTo(- 4, - 4);
  //
  case etat of
    vide: beginFill($8b8b8b);
    bleu: beginFill($00008b);
    vert: beginFill($008b00);
  end;
  //
  lineTo(- 4, + 4);
  lineTo(+ 4, + 4);
  lineTo(+ 4, - 4);
  lineTo(- 4, - 4);
end;
 
procedure tCellule.reset;
begin
  isUp(vide);
end;
 
procedure tCellule.isUp(nouvelEtat: integer);
begin
  etat := nouvelEtat;
  //
  clear;
  //
  moveTo(-7, +7);
  beginFill($6b6b6b);
  //
  lineStyle(1, $5b5b5b);
  lineTo(-7, -7);
  lineTo(+7, -7);
  //
  lineStyle(1, $7b7b7b);
  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);
      //
      cellules[x,y] := tCellule.create(s, x, y);
      //
    end;
    //
  nouvellePartie;
end.

il faut jouer sur $FRAME_RATE pour changer la vitesse de chute.

[Roland Chastain]

habituellement je placerais toutes les cellules dans un objet qui gère la souris et le mouvement de la pièce qui tombe mais ces modifications rapides donnent un résultat intéressant

Je trouve aussi. C'est exactement ce que je voulais faire... en mieux.

Je joins le fichier compilé pour qu'on puisse voir ce que ça donne. (Il y a deux versions.)

Pour la vitesse de l'animation, je trouve qu'avec la valeur par défaut (?) ça va très bien.

[Roland Chastain]

Voici la suite de mon projet. Il me paraît préférable de continuer la même discussion, même si on s'éloigne un peu du sujet initial.

J'étais donc bien décidé à faire un Puissance-4 en Flash Pascal. J'ai repris le code précédent pour mieux le comprendre et voici ce que j'en ai fait :

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
 
(* Projet Puissance 4 *)
 
program grille;  
 
{$FRAME_WIDTH 459}
{$FRAME_HEIGHT 408}
{$BACKGROUND $310062}
 
uses
  Flash8, Couleurs;
 
type
  tCellule = class(MovieClip)
    etat: integer;
    cx, cy: integer;
    constructor create(name: string; x, y: integer);
    procedure doRelease;
    procedure colorie;
    procedure attribue(nEtat: integer);
    procedure onEnterFrame; override;
  end;
 
const
  vide  =  0;
  blanc =  1;
  noir  = -1;
  r     = 16;
 
var
  cellules: array [0 .. 6, 0 .. 5] of tCellule;
  x, y: integer;
  s: string;
  compteur: integer;
  trait: integer;
  caseX: integer;
  caseY: integer;
 
procedure nouvellePartie;
var
  x, y: integer;
begin
  compteur := 0;
  for x := 0 to 6 do for y := 0 to 5 do cellules[x, y].attribue(vide);
  trait := blanc;
  //
  caseX := -1;
  //
end;
 
constructor tCellule.create(name: string; x, y: integer);
begin
  inherited create(_root, name, x + 7 * y);
  cx := x;
  cy := y;
  _x := x * 51 + 25 + 51;
  _y := y * 51 + 25 + 51;
  onRelease := doRelease;
end;
 
procedure tCellule.doRelease;
begin
  if (caseX < 0) and (compteur < 7 * 6) and (cellules[cx, 0].etat = vide) then
  begin
    inc(compteur);
    caseX := cx;
    caseY := 0;
    cellules[caseX, caseY].attribue(trait);
    trait := - trait;
  end;
end;
 
procedure tCellule.colorie;
var
  c: integer;
begin
  lineStyle(0, DarkIndigo);
  moveTo(-r, 0);
  case etat of
    vide : c := Indigo;
    blanc: c := Amethyst;
    noir : c := PersianBlue;//MediumBlue;//DarkOrchid;//BlueViolet;
  end;
  beginFill(c);
  curveTo(-r, -r,  0, -r);
  curveTo( r, -r,  r,  0);
  curveTo( r,  r,  0,  r);
  curveTo(-r,  r, -r,  0);
end;
 
procedure tCellule.attribue(nEtat: integer);
begin
  etat := nEtat;
  colorie;
end;
 
procedure tCellule.onEnterFrame;
begin
  if (cx = caseX) and (cy = caseY) then
  begin
    if (cy = 5) or (cellules[cx, cy + 1].etat <> vide) then
      //
      caseX := -1
      //
    else
    begin
      Inc(caseY);
      cellules[caseX, caseY].attribue(etat);
      attribue(vide);
    end;
  end;
end;
 
begin
  for x := 0 to 6 do for y := 0 to 5 do
    begin
      s := 'cell_' + IntToStr(x) + '_' + IntToStr(y);
      cellules[x,y] := tCellule.create(s, x, y);
    end;
  nouvellePartie;
  stage.scaleMode := 'noScale';
end.

Bref, je n'ai pas vraiment avancé. J'ai cherché comment intégrer un opposant artificiel, mais je n'ai rien trouvé de convaincant. Je me demande si c'est une bonne idée de partir de ce code et s'il ne vaudrait pas mieux commencer par la représentation interne du jeu.

Pourrait-on aborder la question de l'architecture d'un jeu de ce type (où l'on joue contre l'ordinateur) ? A quoi pourrait ressembler le squelette d'un tel programme ?

[Archimède]

je me souviens que ce défi avait été abordé en delphi il y a quelques temps...
Tu as tout ici :

http://delphi.developpez.com/defi/puissance4/

amicalement

[Paul TOTH]

oui le défi est une bonne source, ensuite pour ce qui est spécifique à Flash, il y a deux choses : soit l'évaluation du coup de l'IA est rapide et ça ne pose pas de problème de le faire, soit c'est long et il faudra trouver un moyen de le segmenter. Je ne pense pas qu'il soit possible d'avoir un Thread en Flash, il faudra donc périodiquement relancer le calcul dans on onEnterFrame (ou avec un Timer c'est possible aussi je pense) jusqu'à ce qu'il soit terminé. Il faudrait faire quelques tests là dessus, je ne sais pas réellement comment ça fonctionne.

petite recherche rapide sur le sujet: http://blog.generalrelativity.org/ac...green-threads/

[Roland Chastain]

Le problème est intéressant. Dans le cas présent, l'évaluation devrait être instantanée donc je n'aurai pas besoin de recourir à ce genre de technique.

J'ai commencé un nouveau code, en m'inspirant de l'exemple Calc avec ses variables globales. Je pense avoir trouvé la formule qui me convient. Pour simplifier les choses, j'ai dessiné la grille directement dans l'objet _root. Du coup j'ai perdu la jolie animation qu'on pouvait voir dans le code précédent. Je verrai plus tard comment la rétablir.

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
 
program PUISS_4;
 
{$FRAME_WIDTH 300}
{$FRAME_HEIGHT 300}
 
uses
  Flash8,
  Couleurs;
 
const
  neant = 0;
  blanc = 1;
  noir = -1;
 
type
  tGrille = array[0..6, 0..5] of integer;
 
  tBouton = class(MovieClip)
              numero: integer;
              constructor create(z: integer);
              procedure onRelease; override;
            end;
 
var
  grille: tGrille;
{ procedure initialise; }
{ function ajoute(var g: tGrille; const aX: integer): boolean; }
{ procedure dessine; }
{ function meilleurCoup: integer; }
  compteur: integer;
  fin_de_partie: boolean;
  boutons: array[0..6] of tBouton;
 
procedure initialise;
var
  x, y: integer;
begin
  for x := 0 to 6 do for y := 0 to 5 do grille[x, y] := neant;
  compteur := 0;
end;
 
function ajoute(var g: tGrille; const aX: integer): boolean;
var
  y: integer;
begin
  if g[aX, 5] = neant then
  begin
    result := true;
    y := 5;
    while (y > 0) and (g[aX, y - 1] = neant) do dec(y);
    if compteur mod 2 = 0 then g[aX, y] := blanc else g[aX, y] := noir;
    inc(compteur);
    if compteur = 6 * 7 then fin_de_partie := true;
  end else
    result := false;
end;
 
procedure dessine;
var
  x, y: integer;
begin
  with _root do
  begin
    lineStyle(1, Red);
    for y := 0 to 5 do for x := 0 to 6 do
    begin
      moveTo(10+40*x + 00, 10+40*(5-y) + 00);
      case grille[x, y] of
        noir: beginFill(OrangeRed);
        neant: beginFill(Cream);
        blanc: beginFill(Yellow);
      end;
      lineTo(10+40*x + 40, 10+40*(5-y) + 00);
      lineTo(10+40*x + 40, 10+40*(5-y) + 40);
      lineTo(10+40*x + 00, 10+40*(5-y) + 40);
      lineTo(10+40*x + 00, 10+40*(5-y) + 00);
    end;
  end;
end;
 
function meilleurCoup: integer;
var
  x: integer;
begin
  x := 0;
  while not ajoute(grille, x) do inc(x);
end;
 
constructor tBouton.create(z: integer);
begin
  inherited create(_root, '', z + 1);
  numero := z;
  linestyle(0, Red);
  moveTo(0, 0);
  beginFill(BrightGreen);
  lineTo(40, 00);
  lineTo(40, 40);
  lineTo(00, 40);
  lineTo(00, 00);
  endFill;
  _x := 10 + 40 * z;
  _y :=250;
end;
 
procedure tBouton.onRelease;
begin
  if not ajoute(grille, numero) then exit;
  dessine;
  if fin_de_partie then
  begin
    initialise;
    dessine;
  end else
  begin
    ajoute(grille, meilleurCoup);
    dessine;
  end;
end;
 
var
  i: integer;
 
begin
  initialise;
  dessine;
  for i := 0 to 6 do boutons[i] := tBouton.create(i);
end.