Introduction aux jeu de Dames

**ptitlog** · 07/06/2009, 17h26

Bonjour je suis nouveau et j'ai vraiment d'aide le plus vite possible ...

Je suis entrain de faire un jeu de dames sous Delphi (du moins une introduction, étant donné que notre temps n'est pas assez conséquent).

Est-ce que quelqu'un est prêt à m'aider, car j'ai 2-3questions et j'en suis à un moment "crucial" ?

Sinon je ne posterais même pas plus pour ne pas vous gêner ...

Merci d'avance ...

**Cl@udius** · 07/06/2009, 17h33

Bonjour

Envoyé par ptitlog

Bonjour je suis nouveau

et bienvenue

Envoyé par ptitlog

Je suis entrain de faire un jeu de dames[...]
Est-ce que quelqu'un est prêt à m'aider?

C'est le but ce forum.

²

Il suffit que tu exposes ton problème technique le plus clairement possible, et tu devrais obtenir les réponses à tes questions.

@+ Claudius

**ptitlog** · 07/06/2009, 17h36

Ok merci de ta réponse et de ta rapidité ...

Alors voilà mon problème, en espérant être assez clair ...

Donc voilà, je suis étudiant en dernière année (j'ai 18ans), avant d'attaquer les études supérieurs. Et en cette fin d'année, je dois réaliser un jeu de dames. Mais étant donné que l'on s'y est pris un peu tard, mon Jeu de Dames ne sera pas complet et ne pourra pas tout faire mais pour le moment, je suis un petit peu calé sur 2 petits problèmes (pas assez réfléchi, ... ?), fin soit. Donc c'est pour cela que je demande votre aide.

Voici mon code :

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
implementation
var ColSelect, RowSelect : Integer;
premierClic, joueur1, joueur2 : Boolean;
tabDamier : array [0..9,0..9] of integer;
// Le damier en (colonne, ligne).
// Les indices vont de 0 à 9 pour correspondre au DrawGrid.
// Les valeurs possibles dans le tableau sont
// 0 : case vide
// 1 : case noire
// 2 : pion blanc
// 3 : pion noir
 
x1, y1, x2, y2:integer;
blanc : Boolean;
 
{$R *.dfm}
 
procedure TForm1.DrawGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
var pbitmap:timage;
begin
// Dessiner le damier.
// Les pions et les cases doivent être dessinés par une procédure spéciale (AFFICHE)
// qui se servira du tableau tabDamier.
if tabDamier [acol,arow] = 0 then
begin
pbitmap:=timage.create(self);
pbitmap.picture.loadfromfile('Casevide.bmp');
drawgrid1.canvas.StretchDraw(rect,pbitmap.picture.graphic);
end;
 
if tabDamier [acol,arow] = 1 then
begin
pbitmap:=timage.create(self);
pbitmap.picture.loadfromfile('noirvide.bmp');
drawgrid1.canvas.StretchDraw(rect,pbitmap.picture.graphic);
end;
 
if tabDamier [acol,arow] = 2 then
begin
pbitmap:=timage.create(self);
pbitmap.picture.loadfromfile('pionblanc.bmp');
drawgrid1.canvas.StretchDraw(rect,pbitmap.picture.graphic);
end;
 
if tabDamier [acol,arow] = 3 then
begin
pbitmap:=timage.create(self);
pbitmap.picture.loadfromfile('pionfonce.bmp');
drawgrid1.canvas.StretchDraw(rect,pbitmap.picture.graphic);
end;
end;
 
procedure TForm1.DrawGrid1MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
//Pourvoir déplacer les pions
//Après le premier clic, la case deviens toute noire et après le deuxième
//clic, la case devient un pion noir ou blanc.
if premierClic = true then //Premier clic
begin
x1:=(x div 41);
y1:=(y div 41);
if joueur1=false then
if (tabDamier[x1,y1] = 3) then
Abort;
 
if joueur2=false then
if (tabDamier[x1,y1] = 2) then //Ne fais rien comme c'est au premier joueur de jouer
Abort;
 
if (tabDamier[x1,y1] = 0) or (tabDamier[x1,y1] = 1) then //Ne fais rien si on clic sur une case (vide) blanche ou noir
Abort;
if tabDamier[x1,y1] = 2 then
blanc := True
else
blanc := False;
end;
 
if premierClic = false then //Deuxième clic
begin
x2:=(x div 41);
y2:=(y div 41);
 
if (tabDamier[x2,y2] <> 1) then // Ne fait rien si on essaye de déplacer un pion sur une case autre que noir
Abort;
 
(* if (tabDamier[x1+1,y1+1] = 2) or (tabDamier[x1-1,y1+1] = 2) then
begin
tabDamier[x1+1,y1+1]:=1; //Pour quand on passe au dessus d'un pion (image), que l'autre pion (image) se supprime
tabDamier[x2,y2]:=3; *)
 
// Jeu changement de couleur "physique".
if blanc then
begin
tabDamier[x1,y1] := 1;
tabDamier[x2,y2] := 2;
end
else
begin
tabDamier[x1,y1] := 1;
tabDamier[x2,y2] := 3;
end
end;
 
//end;
 
joueur2:= true; //Pour que le changement de joueur s'effectue
joueur1:= false;
premierClic := not premierClic; //Change la valeur du premier clic
end;
 
procedure TForm1.FormCreate(Sender: TObject);
begin
premierClic := True;
end;
 
procedure TForm1.Nouvellepartie1Click(Sender: TObject);
begin
premierClic:=true;
joueur1:=true;
joueur2:=false;
// Remplissage de la première ligne du damier avec 0 ou 3
tabDamier[0,0]:=0;
tabDamier[1,0]:=3;
tabDamier[2,0]:=0;
tabDamier[3,0]:=3;
tabDamier[4,0]:=0;
tabDamier[5,0]:=3;
tabDamier[6,0]:=0;
tabDamier[7,0]:=3;
tabDamier[8,0]:=0;
tabDamier[9,0]:=3;
//Ainsi de suite pour tout le damier
 
// Affiche le tableau dans la grille
DrawGrid1.Repaint;
end;
end.

Mes 2 problèmes sont : -Pouvoir faire un tour par tour (joueur1 puis joueur2).
-De pouvoir reconnaitre quand par exemple avec un pion blanc je passe au dessus d'un pion noir et donc le noir se supprime.

Tout se passe dans Drawgrid1MouseDown, j'ai déjà tenté quelques petites choses mais il me semble que je me dirige dans un mauvais sens. Avec des if et tout mais rien n'y fait ...

(j'ai essayé de mettre pas mal de commentaire pour que vous voyer où est réellement mon problème).

J'espère être assez clair et ne pas demandez de question "idiote"...

Je tenais aussi à préciser que c'est sur Delphi Pascal et que je ne suis pas du tout une "bête" en programmation.

Et n'hésitez pas à me demander si vous ne comprenez pas quelque chose ou si vous préférez avoir mon adresse pour que je vois envoi le programme ou quoi ...

Merci d'avance à ceux qui n'hésiterons pas à me donner un petit coup de pouce ...

Et j'oubliais, ceci qui devrait pouvoir fortement vous aider ... http://www2.noelshack.com/uploads/damiers011772.JPG

**Cl@udius** · 07/06/2009, 18h01

Envoyé par ptitlog

-Pouvoir faire un tour par tour (joueur1 puis joueur2).

Pour gérer le tour des joueurs (au lieu d'utiliser 2 booléens: Joueur1 et Joueur2) tu définis arbitrairement les valeurs 1 et -1 aux joueurs.
Pour cela tu peux définir 2 constantes:

Code :

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

1
2
3
const
  BLANC = 1;
  NOIR = -1

Ensuite pour inverser le tour il suffit de gérer une variable Joueur et de ceci:

Code :

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

1
2
3
4
procédure InverserTour;
begin
  Joueur := -Joueur
end;

Cela me parait être le plus simple.

Envoyé par ptitlog

-De pouvoir reconnaitre quand par exemple avec un pion blanc je passe au dessus d'un pion noir et donc le noir se supprime.

Je suppose que tu as prévu de cliquer sur la damier à chaque déplacement du pion. Donc entre la position de départ et celle d'arrivée, il suffit de vérifier si il existe un pion de couleur inverse au joueur et de le retirer du damier.
Ce sera également l'occasion de vérifier la validité de ce même déplacement.

Envoyé par ptitlog

Tout se passe dans Drawgrid1MouseDown, [...]

Ce n'est pas forcément la bonne méthode. Pour avoir regarder ton code (en diagonale

), je m'orienterais vers une conception plus objet avec une classe gérant l'échiquier, et s'assurant notamment de la validité des coups joués, et d'autres méthodes comme vérifier si la partie est finie ou non, etc...

[edit]
Dans ton code, apparemment tu ne libères jamais les TBitmaps créés.

ne pas oublier les Free.

@+ Claudius

**ptitlog** · 07/06/2009, 18h07

Ok un grand merci ...

Je vais regarder à ça tout de suite et je reviendrais tantôt pour parler de mon résultat obtenu ...

**anapurna** · 07/06/2009, 18h08

salut

un petit truc déjà pour changer le client a chaque rotation
on inverse la valeur de joueur 1
si il est vrai il devient faux
et si il est faux il devient vrai
ensuite le joueur2 est forcement l'inverse du joueur 1

Code :

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

1
2
3
 
     joueur1 := not(joueur1);
     joueur2 := not(joueur1);

ensuite pour savoir si tu as un pion dans ton deplacement
il suffit de connaitre ta case de départ et ta case d'arrivé
il suffit de parcourir ton tableau tabDamier
le truc étant de connaitre le sens a parcourir
pour connaitre le sens tu peut faire
par 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
 
 Type
  TSens = (BasDroite,BasGauche,HautDroit,HautGauche);
 
 Function DetermineSens(OldPos,NewPos : TPosPion) : TSens
   Deltalig := OldPos.lig -NewPos.lig ;
   DeltaCol := OldPos.Col -NewPos.Col ;
   if  Deltalig > 0 Then
   begin
     il DeltaCol > 0 Then
     begin
       Result := 
     end
     else
     begin
        Result := 
     end;
   end
   else
   begin
     il DeltaCol > 0 Then
     begin
        Result := 
     end
     else
     begin
        Result := 
     end;
   end ;

une fois le sens connue tu incrémente ton déplacement temporaire
et tu vérifie chaque case pour savoir si celle ci ne contient pas de pion différent des tiens

en fait regarde les code des defi tels que le serpent et le puissance 4
tu vas pouvoir t'en inspirer fortement

@+ Phil

**ptitlog** · 07/06/2009, 18h26

Je commence tout d'abord par essayer de faire au tour par tour, en commençant avec la solution d' "anapurna" car je l'avais déjà tenté.

J'ai encore réessayé, mais rien n'y fait.
Que le joueur1 := not (joueur1);
joueur2 := not (joueur1); ou not (joueur2);
ne fonctionne (seul les noir peuvent jouer et pas les blancs ...), probablement que l'erreur se situe autre part

Je vous donc essayer sans plus attendre avec une constante

**madlozoz** · 07/06/2009, 19h12

M'enfin le cas général pour l'alternance des joueur, c'est

Code :

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

1
2
NumeroDuTour := NumeroDuTour + 1;
Joueur := NumeroDuTour Mod NombreDeJoueur;

Pour rapel, "Mod" donne le reste d'une division entière. Si NombreDeJoeur = 2, on a donc les joueur n°0 et 1.

**mick605** · 07/06/2009, 19h20

Salut

J'ai regardé ton code, et je ne sais pas pourquoi tu différencie les cases vides des cases noires, c'est en fait la meme chose pour moi : l'absence de pions.
Le plus simple je pense, serait de faire une procedure AfficherPlateauVide, qui afficherai TOUT le plateau, en mettant noir ou blanc suivant la case.

Je te donnes un exemple de procedure :

Code :

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

1
2
3
4
5
6
7
8
Procedure AfficherPlateauVide;
var Ligne, Colonne :integer;
begin
  for Ligne:=0 to 7 do              //Un plateau de dames fait 8 par 8 !!!!
    for Colonne:=0 to 7 do
       if Odd(Ligne+Colonne) then AfficherCaseBlanche(Ligne, Colonne)
                             else AfficherCaseNoire (Ligne, Colonne);
end;

Il faudrait que tu crées tes 2 procedures AfficherCaseBlanche, AfficherCaseNoire (facile

). Tu peux meme l'optimiser en créant une procedure AfficherCase, qui prendrait en argument les coordonnées de la case et un booleen (suivant la couleur de la case), et qui afficherait la case correspondante dans le drawgrid.

Pour info, Odd renvoie true si l'argument est pair, false sinon (ou l'inverse, je ne me souviens plus !!)

Autre chose, dans un if, tu entres un booleen : si tu met "Booleen = true" c'est pareil que taper "Booleen" !

Enfin, pour ta variable tableau, il faut que tu la modifie, a mon avis.
Par exemple, ca pourrait etre un tableau (d'integer) qui contient 1 si c'est un pion blanc, 2 si c'est un noir, et 0 si c'est une case vide.

A chaque tour, tu pourrais afficher le tableau en entier, ce qui aurait pour effet d'effacer tout les pions, et tu réaffiches TOUT tes pions suivant comment ils ont bougé (ou pas !) !

Dernier conseil : décompose bien ton probleme en plusieurs procedures ! Ne laisse pas tout dans une seule procedure, ca devient vraiment illisible

!!

Bonne chance !!

**Droïde Système7** · 07/06/2009, 19h40

et bienvenue sur les forums Developpez.com,

[...] Dernier conseil : décompose bien ton probleme en plusieurs procedures ! Ne laisse pas tout dans une seule procedure, ca devient vraiment illisible

Je dirais même plus, l'indentation ça veut dire quoi ?

Pour obtenir le plus de réponses, faut pas repousser les éventuelles aides

Bonne chance

**ptitlog** · 07/06/2009, 20h06

Oui donc je vois ce que vous voulez dire mais entre voir et pouvoir faire, il un très grand pas pour moi ...

Premièrement pour ce qui est de l'affichage du damiers grâce à des boucles je comprend tout à fait que c'est beaucoup plus simple et logique mais est-ce vraiment obligatoire étant donné que vu mon niveau je risquerais de me retrouver avec un problème supplémentaire ...

Deuxièmement, je comprend tout à fait que ça devient illisible, mais comment pourrais-je utiliser d'autre procédure alors que dans DrawGrid1MouseDown tout se passe pour pouvoir différencier les clic et donc faire bouger les pions.

Et enfin je doit d'abord me concentrer sur le fait de jouer au tour par tour (ou d'abord la lisibilité, ou autre ?), mais malheureusement pour moi le temps presse et je n'ai plus trop à "chipoter" sur beaucoup de choses

. Donc au final, quelle serait la solution la plus adéquate étant donné que j'en vois 3, voire 4 ...

Et bien sûr que je ne repousse aucunes réponses, mais au risque de me répéter, je ne suis pas très doué comme vous avez pu le remarquer ...

**ptitlog** · 07/06/2009, 21h46

Ai-je mal décris quelque chose, mal suivi quelque chose ?

**mick605** · 07/06/2009, 22h19

Envoyé par ptitlog

Premièrement pour ce qui est de l'affichage du damiers grâce à des boucles je comprend tout à fait que c'est beaucoup plus simple et logique mais est-ce vraiment obligatoire étant donné que vu mon niveau je risquerais de me retrouver avec un problème supplémentaire ...

Au contraire, le fait de bien décomposer ton probleme t'aidera vraiment énormément pour le résoudre. Par exemple, pour une procedure Afficher, qui aurait pour but d'afficher le plateau, les pions, plusieurs décompositions sont possibles :

Premiere :
"Afficher case par case, si c'est une case blanche, afficher une case blanche, si c'est une case noire, afficher une case noire, si c'est un pion afficher un pion, si c'est un autre pion afficher un autre pion"

Deuxieme :
"Afficher une fois en debut de partie le plateau, puis, a chaque tour, afficher et effacer les pions qui ont bougé"

Troisieme :
"Afficher a chaque tour le plateau, puis tout les pions par dessus le plateau"

Je pense qu'entre toutes ces solutions, la plus simple reste la troisieme. Il faut visualiser chaque procedure et reflechir a celles les plus simples. Par exemple, on voit que dans la solution N°2, il nous faut une procedure qui "Efface un pion" ... Je ne vois pas du tout comment la faire ...

Autres raisons : Pour la solution N°3, si il y a un probleme, cela peut venir soit du plateau, soit des pions. On teste une fois et on vois lequel pose probleme. Tu peux ainsi affiner la recherche de ton erreur, en regardant la procedure.

Cette solution evite des problemes graphiques : par exemple, si nous avons opté pour la N°2, a un moment, un pion ne s'efface pas : il va rester pendant toute la partie ! Alors que la N°3 réaffiche toute la grille, donc va l'effacer.

Donc, plus décomposer ton probleme ne peux pas t'apporter d'erreurs supplémentaires ...

Envoyé par ptitlog

Deuxièmement, je comprend tout à fait que ça devient illisible, mais comment pourrais-je utiliser d'autre procédure alors que dans DrawGrid1MouseDown tout se passe pour pouvoir différencier les clic et donc faire bouger les pions.

Et bien, c'est la base de la programmation. Cette procedure DrawGrid1MouseDown est ta procedure principale, cela ne veux pas dire que c'est elle qui doit contenir tout le code, au contraire !! cela devrait etre une de tes procedures les plus courtes : un exemple de ce qu'elle pourrait etre :

Code :

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

1
2
3
4
5
6
7
8
procedure DrawGrid1MouseDown;
begin
  GestionTourJoueur;
  CalculerDeplacementPion;
  VerifierPionMange;
  AfficherPlateauVide;
  AfficherPions;
end;

(L'avantage de cette procedure est que, meme sans commentaires, on comprends tres facilement le déroulement des étapes, alors que dans ton code

...

)

Ensuite, toutes ces procedures appellent d'autres procedures !

Code :

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

1
2
3
4
5
6
7
8
Procedure AfficherPlateauVide;
var Ligne, Colonne :integer;
begin
  for Ligne:=0 to 7 do
    for Colonne:=0 to 7 do
       if Odd(Ligne+Colonne) then AfficherCaseBlanche(Ligne, Colonne)
                             else AfficherCaseNoire (Ligne, Colonne);
end;

Ainsi de suite !
Comme ca, en cas d'erreur dans ta procedure principale, supposons que tu sais qu'elle vient de la procedure AfficherPlateauVide, tu n'as plus qu'a tester dans AfficherPlateauVide, quelle est la ligne qui gene : si maintenant c'est AfficherCaseBlanche, tu n'as plus qu'a tester AfficherCaseBlanche !!

Dans ton cas actuel, une erreur dans ton code t'obliges a tout revoir !!

Envoyé par ptitlog

Et enfin je doit d'abord me concentrer sur le fait de jouer au tour par tour (ou d'abord la lisibilité, ou autre ?), mais malheureusement pour moi le temps presse et je n'ai plus trop à "chipoter" sur beaucoup de choses

. Donc au final, quelle serait la solution la plus adéquate étant donné que j'en vois 3, voire 4 ...

Et bien, pour jouer au tour par tour, la meilleure solution je pense, celle de madlozoz, est de creer une variable "Tour" qui compte le nombre de tours, et tu auras "Tour mod 2" qui te renverra 0 ou 1 suivant le joueur ! Cette ligne pourrait faire l'objet d'une procedure qui renverrait un boolean (plus facile a traiter) !

Envoyé par ptitlog

Et bien sûr que je ne repousse aucunes réponses, mais au risque de me répéter, je ne suis pas très doué comme vous avez pu le remarquer ...

Et bien, on est tous la pour apprendre ! C'est fait pour ca ! Ce qu'il ne faut pas, c'est croire que nous allons faire tout le boulot ! Mais ca, je sais que tu ne le fera pas !

Alors maintenant, je suis sur que tu peux t'en sortir ! Et si t'as encore besoin d'aide, n'hésite pas !

Edit : Euh, pour le multi-citage de ton post, c'est une erreur de ma part

!

**ptitlog** · 07/06/2009, 22h28

Ok et benh un grand merci à toi "mick605" ...

J'étais justement entrain d'essayer une solution avec un mod 2, qui renvoi soit 1 soit 0 (comme tu la dit) et ça ne marche toujours pas (je vais me focaliser sur ce problème un petit peu plus tard ^^), mais comme je vois maintenant la facilité que l'affichage et les procédures (enfin compris) peuvent m'apporter, je vais commencer par là pour éclaircir tout ça ...

**mick605** · 07/06/2009, 22h32

D'accord ! Tiens nous au courant sur l'avancement de ton projet !
Il faudra que tu postes ce code des que tu l'auras fini, je suis intérressé par ce programme ! Et si tu veux, tu pourra meme nous le faire tester, et on te donnera les eventuelles améliorations que tu peux y apporter ...

Sur ce, bonne chance pour ce projet !!

**ptitlog** · 07/06/2009, 22h36

Oui sans aucun soucis, mais comme nous avons eu quelques cours qui ont été supprimé (par divers congés), je devrais arriver à seulement joueur au tour par tour et peut-être à pouvoir passer au dessus d'un pion pour le "supprimer" ...

Mais bon pas de problèmes

**ptitlog** · 08/06/2009, 11h09

Donc j'ai enfin mis des procédure pour que ca soit plus clair ...

Voici ce que ca donne :

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
 
//-----------------------------------------------------------------------------
procedure TForm1.VerifierJoueur;
begin
//Ne fais rien comme c'est au deuxième joueur de jouer.
  if joueur1=false then
  begin
  if (tabDamier[x1,y1] = 3) then
    Abort;
  end;
 
//Ne fais rien comme c'est au premier joueur de jouer.
  if joueur2=false then
  begin
  if (tabDamier[x1,y1] = 2) then
     Abort;
  end;
end;
 
//-----------------------------------------------------------------------------
procedure TForm1.VerifierCasesPossibles;
begin
//Ne fais rien si on clic sur une case (vide) blanche ou noir.
  if (tabDamier[x1,y1] = 0) or (tabDamier[x1,y1] = 1)   then
     Abort;
  if tabDamier[x1,y1] = 2 then
     blanc := True
  else
     blanc := False;
  end;
 
//-----------------------------------------------------------------------------
procedure TForm1.VerifierSiCaseNoir;
begin
// Ne fait rien si on essaye de déplacer un pion sur une case autre que noir.
if (tabDamier[x2,y2] <> 1)   then
   Abort;
end;
 
//-----------------------------------------------------------------------------
procedure TForm1.ChangementsCouleur;
begin
// Jeu changement de couleur "physique".
    if blanc then
    begin
      tabDamier[x1,y1] := 1;
      tabDamier[x2,y2] := 2;
    end
    else
    begin
      tabDamier[x1,y1] := 1;
      tabDamier[x2,y2] := 3;
    end;
end;
 
//-----------------------------------------------------------------------------
procedure TForm1.DrawGrid1MouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
//Pouvoir déplacer les pions.
  //Après le premier clic, la case deviens toute noire et après le deuxième
  //clic, la case devient un pion noir ou blanc.
 
//Premier clic
if premierClic = true then
begin
  x1:=(x div 41);
  y1:=(y div 41);
 
VerifierJoueur;
VerifierCasesPossibles;
 
end;
 
//Deuxième clic.
  if premierClic = false then
  begin
     x2:=(x div 41);
     y2:=(y div 41);
 
VerifierSiCaseNoir;
ChangementsCouleur;
 
  end;
 
  joueur1:=not joueur1;           //Change valeur du joueur1.
  joueur2:=not joueur2;            //Change valeur du joueur2.
  premierClic := not premierClic; //Change la valeur du premier clic.
end;
 
//-----------------------------------------------------------------------------
procedure TForm1.FormCreate(Sender: TObject);
 
 
//-----------------------------------------------------------------------------
procedure TForm1.Nouvellepartie1Click(Sender: TObject);
 
 
//-----------------------------------------------------------------------------
procedure TForm1.Quitter1Click(Sender: TObject);
 
 
//-----------------------------------------------------------------------------
procedure TForm1.Rglesdujeu1Click(Sender: TObject);
 
 
end.

Je vais maintenant m'attaquer au fameux problème du changement de joueur ...

J-1semaine ...

**ptitlog** · 08/06/2009, 11h11

Oups, le début du code n'est pas passé ...

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
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, Grids, extctrls, Menus, StdCtrls;
 
type
  TForm1 = class(TForm)
    DrawGrid1: TDrawGrid;
    MainMenu1: TMainMenu;
    Menu1: TMenuItem;
    Nouvellepartie1: TMenuItem;
    N1: TMenuItem;
    Quitter1: TMenuItem;
    Rglesdujeu1: TMenuItem;
    procedure DrawGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
      Rect: TRect; State: TGridDrawState);
    procedure Quitter1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure Nouvellepartie1Click(Sender: TObject);
    procedure Rglesdujeu1Click(Sender: TObject);
    procedure DrawGrid1MouseDown(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
  private
    { Déclarations privées }
  public
    procedure VerifierJoueur;
    procedure VerifierCasesPossibles;
    procedure VerifierSiCaseNoir;
    procedure ChangementsCouleur;
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
implementation
var ColSelect, RowSelect : Integer;
    premierClic, joueur1, joueur2 : Boolean;
    tabDamier : array [0..9,0..9] of integer;
    x1, y1, x2, y2:integer;
    blanc : Boolean;
    // Le damier en (colonne, ligne).
    // Les indices vont de 0 à 9 pour correspondre au DrawGrid.
    // Les valeurs possibles dans le tableau sont
      // 0 : case vide
      // 1 : case noire
      // 2 : pion blanc
      // 3 : pion noir
 
{$R *.dfm}
 
 
procedure TForm1.DrawGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
  Rect: TRect; State: TGridDrawState);
var pbitmap:timage;
begin
   // Dessiner le damier.
   // Les pions et les cases doivent être dessinés par une procédure spéciale (AFFICHE)
   // qui se servira du tableau tabDamier.
  if tabDamier [acol,arow] = 0 then
  begin
   pbitmap:=timage.create(self);
   pbitmap.picture.loadfromfile('Casevide.bmp');
   drawgrid1.canvas.StretchDraw(rect,pbitmap.picture.graphic);
  end;
 
  if tabDamier [acol,arow] = 1 then
  begin
   pbitmap:=timage.create(self);
   pbitmap.picture.loadfromfile('noirvide.bmp');
   drawgrid1.canvas.StretchDraw(rect,pbitmap.picture.graphic);
  end;
 
  if tabDamier [acol,arow] = 2 then
  begin
    pbitmap:=timage.create(self);
    pbitmap.picture.loadfromfile('pionblanc.bmp');
    drawgrid1.canvas.StretchDraw(rect,pbitmap.picture.graphic);
  end;
 
  if tabDamier [acol,arow] = 3 then
  begin
    pbitmap:=timage.create(self);
    pbitmap.picture.loadfromfile('pionfonce.bmp');
    drawgrid1.canvas.StretchDraw(rect,pbitmap.picture.graphic);
  end;
end;

**chaplin** · 08/06/2009, 12h36

Bonjour,

// Le damier en (colonne, ligne).
// Les indices vont de 0 à 9 pour correspondre au DrawGrid.
// Les valeurs possibles dans le tableau sont
// 0 : case vide
// 1 : case noire
// 2 : pion blanc
// 3 : pion noir

Comme tu as 4 états pour les cases du damier, utilises la structure "Case ... of" à la place des if. C'est plus lisible, en plus tu t'appercevras que certains blocs de codes se répéterons au paramètre près, donc il faut utiliser une fonction à la place.

**mick605** · 08/06/2009, 13h57

Salut !

Je vois que tu as avancé ! Maintenant je vais te donner plus de conseils :
Premierement, tes procedures ne sont pas obligées de commencer par Form1. !!

Deuxiemement, sert toi de fonctions :
Une fonction, c'est comme une procedure, sauf que ca renvoie une valeur, et c'est TRES utile ! Par exemple, tu pourrais faire une fonction Joueur, qui renvoie le joueur dont c'est le tour :

Code :

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

1
2
3
4
5
6
7
function Joueur :boolean
var Resultat :Boolean;
begin
  if (NbTours mod 2)=0 then Resultat:=True
                       else Resultat:=False;
  Joueur:=Resultat;
end;

Ensuite, tu peux tester par exemple :

Code :

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

if Joueur=True then ....

Enfin, tu te sert de la fonction Abort, qui je crois fais quitter la procedure : Cette fonction est tres "bourrin" a mon gout (je pense que c'est l'avis d'autres aussi).

Par exemple, pour ta procedure VerifierSiCaseNoire, tu pourrais la remplacer par une fonction qui renvoie True si c'est bon et False sinon :

Code :

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

1
2
3
4
5
6
7
Function VerifierSiCaseNoire (X, Y :Integer) :boolean;  //le X et le Y sont des arguments, voir l'aide de delphi !
var Resultat :boolean;
begin
  if (tabDamier[X,Y] <> 1) then Resultat:=False
                           else Resultat:=True;
  VerifierSiCaseNoire:=Resultat;
end;

Ensuite dans ta procedure principale, tu auras :

Code :

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

1
2
3
4
5
6
7
8
9
Begin
  if VerifierSiCaseNoire(X1, Y1)=True then
    begin
      //Ta partie de programme ICI
 
 
 
    end;
end;

Voila ! Et normalement tu peux te passer de cette fonction (nulle) Abort !
Je vois que tu as bien décomposé ton probleme, et c'est bien !
Mais n'hésite pas a faire des fonctions a la place de ces procedures, et a mettre des arguments (késako ??). Tu verra plus tard, la (TRES TRES) grande majorité des procedures sont des fonctions et/ou ont des arguments !!

Bonne chance !

PS : Je te conseille de lire quelques tutos au niveau des procedures/fonctions, ton niveau me semble un peu faible a ce niveau !

Edit : Et pour faire propre, tu pourrait définir un type énuméré pour les cases de ton tableau ! Fait aussi cette procedure afficher !

Introduction aux jeu de Dames

Langage Delphi

Discussions similaires

Partager

Partager