formateur informatique

Créer le jeu du Memory en VBA Excel

Accueil  >  Bureautique  >  Excel  >  Excel VBA  >  Créer le jeu du Memory en VBA Excel
Livres à télécharger


Pour partager cette vidéo sur les réseaux sociaux, voici son url absolue :

Pour l'intégrer sur votre site internet ou blog, vous pouvez l'embarquer :

Sujets et formations similaires :


Le jeu du Memory en VBA Excel

Dans cette formation VBA, nous proposons de monter le jeu du Memory pour Excel. Le principe est simple. Des images sont affichées sur un plateau de jeu durant quelques secondes. A l'issue, elles sont masquées. Le joueur doit solliciter sa mémoire. Par clics successifs, il doit réunir les paires semblables.

Partie de jeu du Memory en Visual Basic Excel



Ce développement est l'occasion d'affirmer certaines compétences acquises au cours des formations précédentes. Mais il offre aussi l'opportunité d'interagir avec les actions de l'utilisateur sur les cellules de la feuille.

Source et présentation de la problématique
Pour concentrer notre attention sur le développement de la solution, nous proposons tout d'abord de réceptionner un classeur source. Ce dernier offre la structure du jeu. Plateau de jeu vide du Memory sur feuille Excel pour développement VBA

Nous débouchons sur un classeur constitué de quatre feuilles. La feuille active par défaut se nomme Memory. Elle offre le plateau de jeu avec une barre verticale d'action sur sa droite. Bien entendu, à ce stade, ses boutons sont encore inopérants.

Le bouton Debuter doit donc permettre de commencer une nouvelle partie du jeu du Memory. Le code VBA doit disposer aléatoirement des paires d'images dans les cases prévues à cet effet. Après un certain délai, ces images doivent disparaître. L'utilisateur doit donc faire appel à sa mémoire pour les réunir toutes. Deux clics successifs dévoilant la même miniature conduisent à un succès. Les images sont conservées. Si les miniatures ne coïncident pas, elles sont de nouveau masquées. Le joueur a gagné la partie lorsque toutes les paires sont trouvées.
  • En bas de la fenêtre Excel, cliquer sur l'onglet Source pour activer sa feuille,
Miniatures images archivées en base de données Excel pour jeu du Memory VBA

C'est elle qui archive les miniatures d'images uniques à distribuer sur le plateau de jeu. Il s'agit en réalité de caractères spéciaux correspondant à des codes Ascii réalisés au clavier. Bref, les contenus de ces cellules sont considérés comme du texte par Excel. Cette remarque est loin d'être futile. Nous réaliserons des tests d'égalité en guise de comparaison.
  • En bas de la fenêtre Excel, cliquer sur l'onglet Patron pour activer sa feuille,
Feuille Excel mémorisant emplacements des images pour jeu du memory VBA

Cette feuille porte bien son nom. Il s'agit d'un reflet du plateau de jeu. C'est elle qui doit mémoriser les images générées aléatoirement. Ainsi, plutôt que de faire référence à un tableau de variables, le code VBA pourra comparer la cellule cliquée par l'utilisateur au contenu de ce modèle. Les plateaux de jeu ont effectivement les mêmes coordonnées sur les deux feuilles.
  • Revenir sur la feuille Memory,
Vous notez la présence de deux autres boutons : Scores et Stopper. En effet, le résultat doit être archivé à l'issue de la partie.
  • En bas de la fenêtre Excel, cliquer sur l'onglet Scores pour activer sa feuille,
Tableau Excel pour mémoriser les scores des joueurs au jeu du Memory VBA

La structure du tableau est proposée mais celui-ci est fort logiquement vide pour l'instant. A partir de la ligne 5, nous devrons être en mesure d'archiver le nom du joueur, sa date de participation et le temps écoulé pour résoudre le Memory. Grâce à cette dernière information, nous pourrons réaliser des tris. Ces tris nous permettront de mettre en valeur les meilleurs joueurs.

Enfin le bouton Stopper, comme son nom l'indique, doit permettre d'interrompre la partie et de réinitialiser le plateau de jeu. La gestion aléatoire de nombres est importante dans ce développement. Mais il s'agit de techniques que nous maîtrisons désormais. La réception du clic utilisateur sur une cellule de la feuille est de même une notion incontournable. Nous avions démontré et abouti ces techniques au travers de la conception du Jeu du casse brique en VBA Excel.



Déclaration des variables publiques
De nombreuses informations doivent être stockées en mémoire pour être portées tout au long de la partie. Nous devons donc commencer par déclarer les variables publiques nécessaires.
  • Réaliser le raccourci clavier ALT + F11 pour basculer dans l'éditeur de code VBA Excel,
  • Dans l'explorateur de projet sur la gauche de l'écran, double cliquer sur Feuil1 (Memory),
Ainsi, au centre de l'éditeur, nous affichons la feuille de code associée au plateau de jeu du Memory.
  • Dans cette feuille, ajouter les déclaratives suivantes :
Option Explicit

Dim debut As Variant: Dim fin As Variant
Dim clic As Byte: Dim en_cours As Boolean
Dim mem_avt As String: Dim mem_aps As String
Dim ligne_avt As Byte: Dim col_avt As Byte
Dim ligne_aps As Byte: Dim col_aps As Byte
Dim paire As Byte
...


Tout d'abord et comme vous le savez, la déclarative Option Explicit en en tête de code VBA, impose la déclaration de toutes les variables utilisées. De fait, nous initialisons ensuite les variables publiques nécessaires. C'est pourquoi nous les situons en dehors des bornes de toute procédure.

Les variables debut et fin serviront à prélever les informations de temps entre le commencement et l'achèvement d'une partie. Elles sont typées comme des Variant pour pouvoir réceptionner l'information retournée par la fonction Timer.

La variable clic doit enregistrer le nombre de coups tentés. S'agit-il de la première miniature cliquée ou de son homologue. Lorsque sa valeur vaut 2, nous saurons que les deux images doivent être comparées. La variable en_cours est déclarée comme un booléen. Et pour cause, selon son affectation, c'est elle qui déterminera si le code doit se déclencher pour scruter les actions de l'utilisateur.

Les variables qui suivent serviront à mémoriser les informations de cellules cliquées au premier et deuxième coup, pour pouvoir les comparer. La dernière variable se nomme paire. Nous la typons comme un entier court. En effet, l'objectif est de l'incrémenter à chaque fois qu'une association est retrouvée. Lorsque les 8 paires sont débusquées, la partie est finie.

Déclarations des variables publiques pour le jeu du Memory en VBA Excel

Initialiser la partie
Désormais, nous devons créer la procédure destinée à accueillir le code VBA pour initialiser la partie. Ensuite et naturellement, cette procédure sera attachée au bouton Debuter de la feuille Memory.
  • A la suite du code, créer les procédures arreter et debuter comme suit :
...
Sub arreter()


End Sub

Sub debuter()


End Sub
...


Par la même occasion, nous construisons donc les bornes de la routine qui permettra de mettre fin à la partie. Nous l'implémenterons plus tard.
  • Entre les bornes de la procédure debuter, ajouter les déclarations et affectations suivantes :
...
Dim j As Byte: Dim lig As Byte: Dim col As Byte
Dim combi_couleur As String
Dim couleur As Byte
Dim ligne As Byte: Dim colonne As Byte
Dim mem_couleur As String
Dim combi_plateau As String: Dim mem_plateau As String

clic = 0: en_cours = True
paire = 0: debut = Timer
Randomize
...


j est une variable que nous utiliserons pour fabriquer les paires. Les autres variables sont destinées à mémoriser les indices de cellules passées en revue, issues de différentes feuilles. Les variables déclarées comme des texte (String) seront utilisées pour mémoriser les combinaisons aléatoires déjà servies. C'est donc grâce à elles et l'appui d'une boucle while, que nous serons en mesure de proposer de nouvelles combinaisons. Nous le verrons bientôt.

Ensuite, nous initialisons trois variables publiques : clic, en_cours et paire. Au commencement d'une partie, aucun clic n'a encore été effectué et aucune paire n'a été trouvée. Nous indiquons de même que le jeu a commencé (en_cours = True). Nous prélevons l'information de temps dans la variable debut, grâce à la fonction VBA Timer. Puis, nous synchronisons la génération aléatoire de nombres sur l'horloge système, grâce à la fonction Randomize.

Dans la feuille Source, 8 miniatures d'images sont disponibles pour générer les 16 paires. Nous devons donc entamer un traitement récursif sur huit passages, capable de les piocher aléatoirement. La solution consiste à engager une double boucle sur les indices de ligne et de colonne.
  • A la suite du code, créer la double boucle suivante :
...
For ligne = 3 To 4
For colonne = 3 To 6

Next colonne
Next ligne
...


L'idée est de parcourir les cellules de la feuille Source de la ligne 3 à la ligne 4 en passant en revue les colonnes de C à F (3 à 6). Il s'agit précisément des emplacements des images. Pour chaque image à placer deux fois, nous devons définir une couleur associée. Cette couleur ne peut être répétée. Il s'agit d'une aide visuelle pour faciliter l'identification des paires.
  • A l'intérieur de la double boucle, ajouter les instructions VBA suivantes :
...
couleur = Int(Rnd() * 8) + 3
combi_couleur = couleur & '-'

While InStr(1, mem_couleur, combi_couleur) <> 0
couleur = Int(Rnd() * 8) + 3
combi_couleur = couleur & '-'
Wend

mem_couleur = mem_couleur & combi_couleur
MsgBox mem_couleur
...


Nous souhaitons générer des indices de couleur numériques et les affecter à la propriété ColorIndex des cellules. Nous choisissons de générer ces valeurs entre le chiffre 3 inclus et le nombre 11 exclu. La fonction VBA Rnd génère en effet un nombre réel entre 0 et 1. Nous le multiplions par 8 pour obtenir un nombre entre 0 et 8. Grâce à la fonction Int, nous ne conservons que la valeur entière à laquelle nous ajoutons 3 unités. Par concaténation, nous stockons cette valeur dans la variable combi_couleur. Nous la faisons suivre d'un tiret pour les démarquer toutes les unes des autres.

Nous engageons alors une boucle while destinée à tester la présence de cette couleur, due à une précédente génération. Nous sommes en effet dans une double boucle. Donc pour chaque image, la génération aléatoire est commandée. C'est la fonction VBA InStr qui est utilisée dans le critère de boucle. En partant du premier caractère (1), elle recherche dans la variable mem_couleur, la présence de la combinaison fraîchement générée (combi_couleur). Tant qu'elle ne retourne pas la position Zéro (0), elle indique que la combinaison existe déjà, puisqu'elle est trouvée. C'est pourquoi, entre les bornes de la boucle, nous produisons exactement la même génération aléatoire, jusqu'à ce que la combinaison ne soit plus trouvée (0).

De fait, en dehors de la boucle, nous ajoutons cette valeur générée et approuvée à la suite des autres, dans la variable mem_couleur qui sert de test à chaque passage, donc pour chaque nouvelle image.
  • Enregistrer les modifications (CTRL + S) et basculer sur la feuille Memory du classeur,
  • Cliquer droit sur le bouton Debuter,
  • Dans le menu contextuel, choisir Affecter une macro,
  • Dans la boîte de dialogue, sélectionner la macro debuter,
  • Puis, cliquer sur le bouton Ok pour valider l'association,
Déclencher un code VBA au clic sur un bouton de feuille Excel pour débuter la partie de jeu du Memory

Désormais, un clic sur ce bouton doit déclencher le code en cours de conception.
  • Cliquer sur une cellule vide de la feuille pour désactiver la sélection du bouton,
  • Puis, cliquer sur le bouton Debuter pour simuler le lancement d'une partie,
Grâce à la fonction MsgBox, une première alerte se déclenche et restitue le premier code couleur généré aléatoirement.

Afficher dans une boîte de dialogue les codes couleurs générés aléatoirement par le code VBA Excel

A chaque clic, un nouveau numéro est consolidé. Et comme vous le remarquez, jamais un chiffre n'est répété. Nous pourrons donc associer un code couleur différent par paire d'images.
  • Cliquer sur le bouton Ok jusqu'à atteindre le dernier et la fin du traitement,
  • Revenir dans l'éditeur de code VBA Excel (ALT + F11),
  • Passer la ligne du MsgBox en commentaire en la préfixant d'une apostrophe,
  • A la suite du code, ajouter les instructions VBA suivantes :
...
For j = 1 To 2
lig = Int(Rnd() * 4) + 3
col = Int(Rnd() * 4) + 3

combi_plateau = lig & col & '-'

While InStr(1, mem_plateau, combi_plateau) <> 0
lig = Int(Rnd() * 4) + 3
col = Int(Rnd() * 4) + 3

combi_plateau = lig & col & '-'
Wend

mem_plateau = mem_plateau & combi_plateau

Next j
....


Pour chaque image passée en revue, nous devons créer une paire. C'est pourquoi nous initions une boucle sur deux passages. Nous générons aléatoirement l'indice de ligne et de colonne entre les bornes définies par le plateau de jeu (3 et 6 pour les deux dimensions). Nous stockons cette combinaison dans la variable combi_plateau. Grâce à la fonction VBA InStr, nous testons la présence de cette nouvelle combinaison dans celles consolidées à chaque passage, grâce à la variable mem_plateau. Comme précédemment, tant que cette combinaison existe (<>0), nous la regénérons. Au sortir de la boucle While, nous concaténons la combinaison de coordonnées validées, à la suite dans la variable mem_plateau.

Nous devons exploiter ces indices de ligne et de colonne autorisés pour placer les paires sur le plateau de jeu.
  • A la suite du code et avant la fermeture de la boucle For (Next j), ajouter les lignes suivantes :
...
Sheets('Patron').Cells(lig, col).Value = Sheets('Source').Cells(ligne, colonne).Value
Sheets('Patron').Cells(lig, col).Interior.ColorIndex = couleur
Sheets('Memory').Cells(lig, col).Value = Sheets('Source').Cells(ligne, colonne).Value
Sheets('Memory').Cells(lig, col).Interior.ColorIndex = couleur
...


Nous exploitons tout simplement ces indices de ligne et de colonne, pour placer par paires, les images prélevées sur le plateau de jeu modèle de la feuille Patron et sur celui de la feuille Memory. De fait, ils sont tous deux identiques. Ainsi, ils permettront la comparaison à chaque clic du joueur durant une partie.
  • Enregistrer les modifications et basculer sur la feuille Memory,
  • Puis, cliquer sur le bouton Debuter,
Placement aléatoire des paires de photos par le code VBA Excel au début de la partie du jeu du Memory

Comme vous pouvez le voir, à chaque clic pour commencer une partie, les paires sont placées aléatoirement. De même, une couleur unique leur est associée.
  • Revenir dans l'éditeur de code Visual Basic Excel,
Ces paires d'images doivent persister quelques secondes et disparaître. C'est alors que le joueur devra essayer de les reconstituer de mémoire. Nous proposons de créer une procédure indépendante. Elle doit consister à nettoyer le plateau de jeu, après un délai d'attente.
  • Sous la procédure debuter, créer la procédure nettoyer, comme suit :
...
Private Sub nettoyer()
Dim tampo As Variant
Dim i As Byte: Dim j As Byte

tampo = Timer

While Timer < tampo + 5
DoEvents
Wend

For i = 3 To 6
For j = 3 To 6
Cells(i, j).Value = ''
Cells(i, j).Interior.ColorIndex = -4105
Next j
Next i

End Sub
...


Il s'agit de techniques que nous avons démontrées à maintes reprises au cours des formations VBA Excel. Nous prélevons l'information de temps grâce à la fonction VBA Timer. Nous temporisons durant cinq secondes (Timer < tampo +5), grâce à une boucle While. L'instruction DoEvents permet de rendre la main à l'utilisateur pendant le traitement récursif. Mais est-ce bien judicieux ? Durant ce laps de temps, le joueur voit encore les paires. Il ne doit pas pouvoir les cliquer tant que le plateau n'est pas purgé. A vous de décider donc. Ces applications sont proposées en Open Source pour être améliorées. Nous pourrions aussi déplacer l'initialisation de la variable en_cours, après le traitement de cette boucle. C'est elle qui détermine que la partie est lancée, et nous allons bientôt comprendre son impact.

Bref, ensuite c'est une double boucle qui parcourt toutes les cellules du plateau de jeu. Grâce à la propriété dérivée ColorIndex de la propriété Interior de l'objet Cells, nous remplissons chaque cellule de blanc, après les avoir vidées. La valeur numérique -4105 est enseignée par l'aide en ligne pour cette réinitialisation de couleur.
  • Entre les bornes de la procédure arreter, ajouter le code VBA suivant :
...
en_cours = False
clic = 0
paire = 0
nettoyer
...


L'objectif de cette routine est de terminer le jeu et de réinitialiser la partie. Nous basculons fort logiquement la variable booléenne à False. Avec ce statut, elle interdira au code VBA d'interpréter les clics sur les cellules du plateau de jeu. Les variables clic et paire sont elles mêmes remises à zéro. Puis, la procédure nettoyer est appelée pour purger le plateau de jeu.

Cette même procédure doit être appelée à la fin du traitement de la routine debuter. En effet, une fois les paires constituées, elles doivent disparaître pour débuter la partie. Souvenez-vous, c'est la feuille Patron qui conserve un exemplaire des combinaisons à reformer.
  • Avant le End Sub de la procédure debuter, ajouter l'appel suivant :
...
nettoyer
...
  • Enregistrer les modifications et basculer sur la feuille Memory,
  • Cliquer droit sur le bouton Stopper,
  • Dans le menu contextuel, choisir Affecter une macro,
  • Dans la boîte de dialogue, sélectionner la macro arreter,
  • Puis, cliquer sur le bouton Ok pour valider l'association,
  • Ensuite, cliquer sur une cellule de la feuille pour désactiver la sélection du bouton,
  • Cliquer alors sur le bouton debuter pour commencer une nouvelle partie,
Masquer les images au bout de 5 secondes pour débuter la partie du jeu de mémoire en VBA Excel



Comme vous le constatez, le plateau de jeu est effectivement purgé à l'issue des 5 secondes. Dès lors, ce sont les clics de l'utilisateur que nous devons intercepter pour dévoiler les images cachées et reconstituer les paires.

Le code VBA complet des procédures que nous avons bâties jusqu'alors est le suivant :

Sub arreter()

en_cours = False
clic = 0
paire = 0
nettoyer

End Sub

Sub debuter()
Dim j As Byte: Dim lig As Byte: Dim col As Byte
Dim combi_couleur As String
Dim couleur As Byte
Dim ligne As Byte: Dim colonne As Byte
Dim mem_couleur As String
Dim combi_plateau As String: Dim mem_plateau As String

clic = 0
paire = 0: debut = Timer
Randomize

For ligne = 3 To 4
For colonne = 3 To 6

couleur = Int(Rnd() * 8) + 3
combi_couleur = couleur & '-'

While InStr(1, mem_couleur, combi_couleur) <> 0
couleur = Int(Rnd() * 8) + 3
combi_couleur = couleur & '-'
Wend

mem_couleur = mem_couleur & combi_couleur

'MsgBox mem_couleur

For j = 1 To 2
lig = Int(Rnd() * 4) + 3
col = Int(Rnd() * 4) + 3

combi_plateau = lig & col & '-'

While InStr(1, mem_plateau, combi_plateau) <> 0
lig = Int(Rnd() * 4) + 3
col = Int(Rnd() * 4) + 3

combi_plateau = lig & col & '-'
Wend

mem_plateau = mem_plateau & combi_plateau

Sheets('Patron').Cells(lig, col).Value = Sheets('Source').Cells(ligne, colonne).Value
Sheets('Patron').Cells(lig, col).Interior.ColorIndex = couleur
Sheets('Memory').Cells(lig, col).Value = Sheets('Source').Cells(ligne, colonne).Value
Sheets('Memory').Cells(lig, col).Interior.ColorIndex = couleur

Next j
Next colonne
Next ligne

nettoyer


End Sub

Private Sub nettoyer()
Dim tampo As Variant
Dim i As Byte: Dim j As Byte

tampo = Timer

While Timer < tampo + 5
DoEvents
Wend

For i = 3 To 6
For j = 3 To 6
Cells(i, j).Value = ''
Cells(i, j).Interior.ColorIndex = -4105
Next j
Next i

en_cours = True

End Sub


Interpréter les clics du joueur
Visual Basic Excel offre un évènement dédié et attaché à la feuille pour transmettre les coordonnées d'une cellule cliquée. Nous allons l'exploiter. Ces coordonnées devront être comparées à celles de la feuille Patron pour démasquer l'image qui s'y cache.
  • Revenir dans l'éditeur de code VBA Excel,
  • En haut de l'éditeur, déployer la première liste déroulante, sur la gauche,
  • Y choisir l'objet Worksheet,
Cette action a pour effet de créer instantanément la procédure évènementielle Worksheet_SelectionChange. Nous n'avons pas eu besoin de définir l'évènement à l'aide de la seconde liste déroulante. Il lui est attaché par défaut. C'est lui qui gère les clics de l'utilisateur sur les cellules de la feuille active. Et à ce titre, vous notez qu'elle transmet un paramètre nommé Target. Ce dernier définit la cible, soit la cellule cliquée et interceptée. Il s'agit d'ailleurs d'un objet de type Range, soit de plages de cellules ou d'une cellule. Nous allons donc pouvoir récupérer et exploiter les coordonnées du clic effectué par le joueur.

Créer la procédure évènementielle VBA Excel pour intercepter les clics utilisateur sur les cellules de la feuille

Private Sub Worksheet_SelectionChange(ByVal Target As Range)

End Sub
  • Dans les bornes de la procédure, ajouter les déclarations de variables suivantes :
...
Dim la_ligne As Byte: Dim la_colonne As Byte
Dim tampo As Variant: Dim nom As String
...


Nous déclarons les variables nécessaires pour récupérer les coordonnées de la cellule, prélever l'information de temps et réceptionner le nom du joueur à l'issue de la partie.
  • A la suite, ajouter les tests suivants :
...
If (en_cours = True) Then
la_ligne = Target.Row: la_colonne = Target.Column
If (la_ligne >= 3 And la_ligne <= 6 And la_colonne >= 3 And la_colonne <= 6) Then
clic = clic + 1
Cells(la_ligne, la_colonne).Value = Sheets('Patron').Cells(la_ligne,la_colonne).Value
Cells(la_ligne, la_colonne).Interior.ColorIndex = Sheets('Patron').Cells(la_ligne, la_colonne).Interior.ColorIndex

End If
End If
...


Avant de chercher à interpréter les clics du joueur, nous vérifions que la partie est bien démarrée, grâce à la variable booléenne dédiée. Si le test est concluant, nous prélevons les coordonnées de la cellule désignée, grâce aux propriétés Row et Column de l'objet Range, transmis en paramètre. Ensuite, nous nous assurons que le clic est bien émis sur le plateau de jeu. C'est un quadruple test qui vérifie que les indices de ligne et de colonne sont bien compris dans les bornes imposées par le plateau (3 et 6). Si ce second test est concluant, le clic doit être géré. Nous incrémentons donc la variable publique clic. C'est elle qui permet de savoir s'il s'agit de la première image dévoilée ou de la paire associée. Ensuite, nous restituons le contenu et la couleur, issus du modèle soit de la feuille Patron. De fait, nous affichons l'image telle qu'elle a été proposée sur le plateau de jeu au début de la partie.

Désormais, nous devons traiter le contexte. Soit il s'agit du premier clic (clic=1) et nous devons mémoriser les coordonnées en vue de la comparaison future, soit il s'agit du second (clic=2) et nous devons comparer les deux vignettes. C'est ainsi que nous déciderons de la suite de la partie.
  • A la suite du code, dans la double instruction conditionnelle, ajouter le test suivant :
...
If (clic = 1) Then
mem_avt = Cells(la_ligne, la_colonne).Value
ligne_avt = la_ligne: col_avt = la_colonne
Else
mem_aps = Cells(la_ligne, la_colonne).Value
clic = 0
End If
...


S'il s'agit du premier clic, nous mémorisons les coordonnées de la cellule pour pouvoir la comparer, en prévision du second clic. Sinon donc, s'il s'agit du second clic, nous mémorisons de même les coordonnées. Et puis, nous réinitialisons la variable clic à zéro puisqu'il n'y a pas de seconde chance. Le prochain clic sera considéré comme le premier.

Ce sont donc les variables mem_avt et mem_aps qui portent désormais la solution. Si elles correspondent, nous en concluons que les images coïncident. Dans le cas contraire, cette paire discordante doit être masquée après un bref délai.
  • A la suite du code, dans la branche else, ajouter le test suivant :
...
If (mem_avt <> mem_aps) Then

Else

End If
...
  • Dans la branche du If, ajouter les instructions VBA suivantes :
...
en_cours = False
ligne_aps = la_ligne: col_aps = la_colonne
tampo = Timer
While Timer < tampo + 1
DoEvents
Wend
Cells(ligne_avt, col_avt).Value = ''
Cells(ligne_aps, col_aps).Value = ''
Cells(ligne_avt, col_avt).Interior.ColorIndex = -4105
Cells(ligne_aps, col_aps).Interior.ColorIndex = -4105
en_cours = True
...


Nous basculons tout d'abord l'état de la variable booléenne à false. Ainsi, grâce au test réalisé en début de procédure, en cas de paire non conforme, nous interdisons temporairement le code VBA d'interpréter tout nouveau clic. Les vignettes non concordantes doivent d'abord être masquées, après temporisation.

Nous enregistrons donc les coordonnées de la cellule cliquée. Nous temporisons ensuite une seconde, toujours grâce à une boucle While. Puis, nous vidons les cellules de la mauvaise paire et réinitialisons les couleurs de fond, pour les masquer. A l'issue, nous rebasculons l'état de la variable booléenne afin d'autoriser de nouveau les clics. En effet, les vignettes discordantes ont été masquées dans le laps de temps.

Dans le cas contraire, nous devons conserver les paires visibles, puisqu'elles concordent. Dans le même temps, nous devons nous assurer qu'elles n'ont pas toutes été dévoilées. En effet, si la variable paire vaut 8, le joueur a correctement reconstruit le plateau de jeu.
  • Dans la branche du else, ajouter les lignes VBA suivante :
...
paire = paire + 1
If (paire = 8) Then
en_cours = False
nom = InputBox('Fécilitations, quel est votre prénom ?')
If (nom <> '') Then
'MsgBox nom
fin = Timer
archiver nom, (fin - debut)
End If
nettoyer
End If
...


Nous commençons par incrémenter la variable comptabilisant les paires trouvées. Puis, nous engageons une vérification, grâce à une nouvelle instruction conditionnelle. En effet, si les huit paires sont dévoilées, la partie est finie. Nous la stoppons tout d'abord en basculant l'état de la variable booléenne. Puis, grâce à la fonction VBA InputBox, nous prélevons le prénom du joueur, par le biais d'une boîte de dialogue déclenchée.

Si le prénom est bien transmis, nous prélevons l'information de temps. C'est ainsi que nous pourrons comptabiliser la durée de jeu. De fait et par anticipation, nous appelons une procédure nommée archiver, en lui transmettant le nom du joueur avec cette différence de temps, entre le début et la fin de partie. Enfin, la procédure nettoyer est de nouveau appelée, puisqu'il s'agit de purger le plateau de jeu.

Cette procédure archiver n'existe pas encore. Elle doit simplement ajouter les résultats du joueur, dans le tableau de la feuille Scores, à la suite des précédentes archives.
  • En dessous de la procédure évènementielle, créer la procédure archiver :
Private Sub archiver(nom As String, temps As Double)
Dim ligne As Integer

ligne = 4

While Sheets('Scores').Cells(ligne, 2).Value <> ''
ligne = ligne + 1
Wend

Sheets('Scores').Cells(ligne, 2).Value = nom
Sheets('Scores').Cells(ligne, 3).Value = Now
Sheets('Scores').Cells(ligne, 4).Value = temps

End Sub


En partant de la cellule de titre de la feuille Scores, grâce à une boucle While, nous déplaçons l'indice de ligne vers le bas, tant que la première cellule vide n'est pas trouvée. A l'issue, dans les colonnes respectives, nous inscrivons les informations du joueur. Notez l'emploi de la fonction VBA Now qui retourne l'information de temps, sous forme de date, à la seconde près.
  • Enregistrer les modifications et basculer sur la feuille Memory,
  • Cliquer sur le bouton Debuter,
  • Une fois le plateau nettoyé, cliquer sur les cellules pour tenter de retrouver les paires,
Partie en cours du jeu du Memory Excel contrôlé par le code VBA



A chaque fois qu'une paire est reconstituée dans l'enchaînement des deux clics, les images persistent. Lorsqu'elles ne coïncident pas, elles disparaissent au bout d'une seconde.

Boîte de dialogue pour récolter le nom du joueur à la fin de la partie du jeu du Memory VBA Excel

Une fois toutes les paires résolues, la partie se stoppe et une invite se déclenche pour récolter le prénom du joueur.

Score du joueur au Memory archivé dans un tableau Excel par le code VBA

Le code complet de cette seconde partie du développement, est le suivant :

Private Sub archiver(nom As String,temps As Double)
Dim ligne As Integer

ligne = 4

While Sheets('Scores').Cells(ligne, 2).Value <> ''
ligne = ligne + 1
Wend

Sheets('Scores').Cells(ligne, 2).Value = nom
Sheets('Scores').Cells(ligne, 3).Value = Now
Sheets('Scores').Cells(ligne, 4).Value = temps


End Sub

Private Sub Worksheet_SelectionChange(ByVal Target As Range)
Dim la_ligne As Byte: Dim la_colonne As Byte
Dim tampo As Variant: Dim nom As String

If (en_cours = True) Then
la_ligne = Target.Row: la_colonne = Target.Column
If (la_ligne >= 3 And la_ligne <= 6 And la_colonne >= 3 And la_colonne <= 6) Then
clic = clic + 1
Cells(la_ligne, la_colonne).Value = Sheets('Patron').Cells(la_ligne,la_colonne).Value
Cells(la_ligne, la_colonne).Interior.ColorIndex = Sheets('Patron').Cells(la_ligne, la_colonne).Interior.ColorIndex

If (clic = 1) Then
mem_avt = Cells(la_ligne, la_colonne).Value
ligne_avt = la_ligne: col_avt = la_colonne
Else
mem_aps = Cells(la_ligne, la_colonne).Value
clic = 0
If (mem_avt <> mem_aps) Then
en_cours = False
ligne_aps = la_ligne: col_aps = la_colonne
tampo = Timer
While Timer < tampo + 1
DoEvents
Wend
Cells(ligne_avt, col_avt).Value = ''
Cells(ligne_aps, col_aps).Value = ''
Cells(ligne_avt, col_avt).Interior.ColorIndex = -4105
Cells(ligne_aps, col_aps).Interior.ColorIndex = -4105
en_cours = True
Else
paire = paire + 1
If (paire = 8) Then
en_cours = False
nom = InputBox('Fécilitations, quel est votre prénom ?')
If (nom <> '') Then
fin = Timer
archiver nom, (fin - debut)
End If
nettoyer
End If
End If
End If

End If
End If

End Sub


A validation du nom et après avoir affiché la feuilles Scores, vous constatez que les données sont parfaitement consolidées à la suite, dans le tableau prévu à cet effet.

Le développement du bouton restant est trivial. Il consiste à afficher la feuille des scores. Sa procédure doit préalablement être créée.

Sub afficher_scores()

Sheets('Scores').Activate

End Sub


C'est la méthode Activate de l'objet Sheets qui donne le focus à cette dernière, en fonction du nom de la feuille passé en paramètre. Enfin, il convient d'affecter le bouton Scores à cette macro.

Nous sommes donc parvenus à développer le jeu du Memory en VBA pour Excel avec succès.

 
Sur Facebook
Sur G+
Sur Youtube
Les livres
Contact
Mentions légales



Partager la formation
Partager sur Facebook
Partager sur Google+
Partager sur Twitter
Partager sur LinkedIn