Les Défis DELPHI - Jouez à Puissance 4 !

La classe TJoueur garde les informations relatives à chaque joueur.

• Plateau : le plateau d'appartenance ;
• Snom : son nom ;
• Icamp : son camp (actuellement 1 = rouge, 2 = jaune) ;
• IjetonsRestants : son nombre de jetons restants au cours d'une partie.

Deux méthodes également, TJoueur.Init et TJoueur.Jouer, permettent de faire interagir le joueur au cours de la partie.

La classe TPlateau garde les informations du plateau, principalement :

• Joueur[x] : les joueurs de classe TJoueur, indicés de 1 à 2 ;
• Grille[col,lig] : grille virtuelle aux dimensions du puissance 4 (7 colonnes par 6 lignes).
  Les valeurs des cellules sont : 0 si la cellule est vide, 1 ou 2 pour spécifier le camp du jeton ;
• DernierJeton : les coordonnées du dernier jeton joué ;
• Icurseur : curseur en cours du lâcher de jeton ;
• Ijoueur : joueur actuellement en cours (1 ou 2). Vaut 0 si aucune partie n'est en cours ;

Ainsi que des informations pour l'affichage :

• BmpFond, BmpJeu sont les images de fond et de grille de Puissance 4 ;
• BmpDoubleFond est l'image de fond, pour gérer un affichage correct pendant les animations des jetons ;
• BmpPion[x] sont les images des jetons.

TPlateau intègre également ses propres méthodes pour le faire vivre, principalement les méthodes :

• NouveauJeu : initialise une partie et ses joueurs ;
• Jouer : lâche un jeton selon l'état courant du jeu (à la position ICurseur) et gère l'analyse des jetons alignés ;
• Fin : partie terminée, affiche le message de match nul ou de victoire.

Les autres méthodes sont des outils ; elles seront expliquées par la suite.

1. Le plateau est initialisé avec IJoueur = x (x = 1, par exemple, si le joueur N°1 commence) ;
2. La propriété ICurseur est mise à jour en temps réel, lorsque la souris se déplace sur le plateau ;
3. Le clic souris sur le plateau déclenche le lâcher de jeton par Plateau.Jouer :
   1. le joueur courant IJoueur lâche un jeton dans la colonne courante Icurseur,
   2. TPlateau.CaseVide indique quelle est la cellule libre à remplir ; l'algorithme est suffisamment simple à comprendre en lisant le code.
4. L'analyse de gain / nul est lancée avec la méthode Plateau.ResultatDernierJeton, expliquée ci-dessous ;
5. Si la partie continue, le programme boucle en 2.

TPlateau.CaseVide permet de savoir, en fonction de la colonne du lâcher de jeton, quelle est la case finale du jeton.

La recherche d'une case vide est faite par un parcours séquentiel dans la colonne désignée, de haut en bas, à la recherche d'une cellule déjà remplie par un jeton.

Le programme analyse uniquement à la périphérie du dernier jeton joué ; l'analyse ne porte pas sur l'ensemble de la grille.

J'ai choisi cette méthode car un minimum de jetons seront soumis à des tests ; le code est également assez compact.

De plus, il est permis d'imaginer de faire évoluer le plateau en nombre de cellules et/ou en nombre de dimensions sans changer l'algorithme.

Le vocabulaire utilisé est : SENS = axe non orienté, DIRECTION = axe orienté.

L'analyse repose sur le « comptage » des jetons dans les huit directions de cellules identiques au dernier jeton joué.

Puis ensuite au comptage des jetons pour les quatre sens.

Pour effectuer ce comptage dans les quatre sens, la somme des compteurs de directions deux à deux opposées et effectuées + 1 (le jeton central).

Si, pour un des quatre sens, le compteur vaut au moins 4, le joueur correspondant au dernier jeton a gagné.

Voici une présentation un peu plus parlante du fonctionnement de comptage.
Les captures sont prises du programme graphique, mais cela revient strictement au même pour la version non graphique :

Captures d'écran	Commentaires
	La constante DIR_INCR spécifie les directions par incrémentation sur les deux axes.   Sélectionnez DIR_INCR : array[ 0..7] of TPoint = ( ( x:1;y:0),( x:-1;y:0), // horizontale ( x:0;y:1),( x:0;y:-1), // vertical ( x:1;y:1),( x:-1;y:-1), // oblique slash ( x:-1;y:1),( x:1;y:-1) ); // oblique anti-slash Le sens horizontal est spécifié par les directions 0 et 1 ; Le sens vertical est spécifié par les directions 2 et 3 ; Le sens oblique \ est spécifié par les directions 4 et 5 ; Le sens oblique / est spécifié par les directions 6 et 7.
Les marques rouges marquent l'arrêt du comptage dans la direction ; la cellule n'est plus identique à la cellule centrale.	Comptage dans chaque direction. Et ensuite, comptage dans les quatre sens : le sens oblique / ajouté de 1 vaut au moins 4, les jaunes gagnent. Dir 0 = 0 ; Dir 1 = 0 ; Dir 2 = 0 ; Dir 3 = 0 (en pratique, on pourrait se passer de compter dans cette direction…) ; Dir 4 = 1 ; Dir 5 = 0 ; Dir 6 = 2 ; Dir 7 = 1 ; Sens horizontal = Dir 0 + Dir 1 = 0 ; Sens vertical = Dir 2 + Dir 3 = 0 ; Sens oblique \ = Dir 4 + Dir 5 = 1 ; Sens oblique / = Dir 6 + Dir 7 = 3.

II-C-1-a. Support▲

II-C-1-b. Affichage d'un jeton▲

procedure TPlateau.PionAfficher( ICamp: Integer; PPos: TPoint );
var
   CCar: string;
begin
     case ICamp of
       1 : CCar := ' X';
       2 : CCar := ' O';
       else CCar := '';
     end;
     // le tableau logique commence en indice -1 pour le laché de jeton
     StringGrid.Cells[ PPos.X, PPos.Y + 1 ] := CCar;
end;

II-C-1-c. Animation▲

II-C-2-a. Support▲

II-C-2-b. Affichage d'un jeton▲

procedure TPlateau.PionAfficher( ICamp: Integer; PPos: TPoint; IDelta: Integer = 0 );
var
   RRect: TRect;
   BmpSource: TBitmap;
begin
     // zone de dessin
     RRect.Left := OFFSET.X + SEGMENT.X * PPos.X;
     RRect.Top := OFFSET.Y + SEGMENT.Y * PPos.Y + IDelta;
     RRect.Right := RRect.Left + JETON.X;
     RRect.Bottom := RRect.Top + JETON.Y;
     // Type de dessin
     if ICamp > 0
       then BmpSource := BmpPion[ ICamp ]
       else BmpSource := Nil;
     // Affichage du dessin
     if Assigned( BmpSource )
       then BmpFond.Canvas.Draw( RRect.Left, RRect.Top, BmpSource ) // affichage Jeton
       else BmpFond.Canvas.CopyRect( RRect, BmpDoubleFond.Canvas, RRect ); // restitution du fond
end;

II-C-2-c. Animation▲

Pour éviter ce que l'on appelle le « Flickering » ou le scintillement du jeton pendant son animation, je laisse soin aux composants VCL, le TPanel contenant le TStringGrid ou les TImage, de gérer le double-buffering.

Pour cela, la propriété Conteneur.DoubleBuffered est activée à True.

L'image générale n'est réaffichée en visuel qu'une fois complètement constituée dans un buffer.

II-C-3-a. Autres▲