Comment jouer à « 1, 2, 3, Soleil » de Squid Game sur Excel ?
Dans ce tutoriel, nous allons découvrir comment créer un jeu sur Excel, en nous inspirant du phénomène actuel Squid Game. Nous allons en effet créer un petit jeu reposant sur le principe de « 1, 2, 3, Soleil ».
Téléchargement
Vous pouvez télécharger le fichier d'exemple de cet article en cliquant sur le lien suivant :
Tutoriel Vidéo
1. Préparation de l’aire de jeu
Pour commencer ce tutoriel, nous créer l’aire de jeu dans une nouvelle feuille.
La première chose à faire va alors être de modifier la taille des cellules.
Nous sélectionnons toutes les cellules, puis nous redimensionnons les cellules pour que celles-ci mesurent 14x8 pixels :
Ensuite, nous sélectionnons un rectangle de 50 cellules de large et de 80 cellules de hauteur, soit la plage A1:A80 :
Pour manipuler facilement cette plage de cellule, nous lui donnons un nom en le saisissant simplement dans la zone de nom, en haut à gauche de la feuille de calculs :
Pour démarquer ce terrain, nous lui affectons une couleur, par exemple en jaune :
Puis, nous plaçons la ligne grise au niveau de la septième ligne :
Maintenant, nous pouvons repasser la zone au-dessus de cette ligne en blanc :
Pour le dernier détail, nous allons insérer la poupée au centre de cette zone, en effectuant simplement un copier-coller de l’image ci-dessous :
Pour retirer le contour de cette image, nous la sélectionnons, puis nous nous rendons dans le menu Format de l’image > Image > Couleur transparente, puis avec la pipette, nous venons sélectionner un pixel blanc situé autour de la poupée :
Le terrain est terminé pour le moment, nous reviendrons plus tard mettre en place une mise en forme conditionnelle pour afficher les joueurs :
Avant de passer au développement de l’application, nous allons réserver deux cellules pour l’enregistrement des informations.
Pour cela, nous sélectionnons une cellule située en dehors du terrain, que nous nommons « _compter » :
Et une seconde que nous nommons « _position ».
2. Faisons parler la poupée
Maintenant, nous allons nous atteler à la création du jeu à proprement parler, et pour cela, nous allons bien entendu devoir passer par le développement d’une petite macro-commande en VBA.
Pour que ce tutoriel soit accessible à tout le monde, nous allons revenir dans le détail sur aspect de cette dernière.
Pour commencer, nous allons souhaiter faire parler la poupée, afin que celle-ci puisse énoncer le fameux « Un … Deux … Trois … Soleil ».
Pour cela, nous allons insérer une bulle dans la feuille de calcul, que nous allons faire pointer sur celle-ci.
Nous nous rendons donc dans le menu Insertion > Formes et nous choisissons la bulle qui nous intéresse, qu’il ne nous reste plus qu’à faire pointer sur la poupée :
Si nous le souhaitons, nous pouvons mettre en forme cette bulle avant d’aller plus loin.
Puis, nous allons donner un nom à cette forme afin de pouvoir l’appeler plus facilement par la suite.
Pour cela, nous la sélectionnons, puis dans le menu « format de la forme », nous cliquons sur le bouton « Volet Sélection ».
Ensuite, nous pouvons renommer la forme en « parole » depuis la fenêtre qui s’affiche sur la partie droite :
Maintenant, pour développer notre application, nous allons lancer l’éditeur de code VBE (pour Visual Basic Editor), qui est l’éditeur de code intégré dans les différentes applications de la suite Office et qui permet de développer des macro-commandes en VBA.
Pour cela, nous appuyons simplement sur les touches [Alt]+[F11].
VBE s’ouvre alors et nous allons commencer par créer un nouveau module.
Un module est une feuille de saisie de code dans laquelle nous allons pouvoir saisir nos macros et fonctions.
Pour insérer un nouveau module, nous nous rendons dans le menu Insertion > Module :
Une fois le module inséré, nous allons pouvoir créer notre première petite macro-commande, laquelle va nous permettre de modifier le texte affiché dans la bulle !
Pour créer une macro-commande (ici une procédure), nous saisissons le mot-clé Sub, suivi du nom que nous souhaitons lui donner, à savoir « setParole ».
Le préfixe « set » signifie que nous allons affecter une valeur à un objet, ici la bulle de parole.
Nous verrons plus tard comment récupérer cette valeur avec une fonction que nous appellerons « getParole ».
Lorsque nous validons, Excel ajoute la fin de la procédure avec la ligne, et tout ce que nous allons saisir entre ces deux lignes va s’exécuter lorsque nous allons appeler la macro setParole.
Ensuite, pour modifier le texte affiché dans la bulle, nous allons saisir la ligne :
Sub setParole()
ActiveSheet.Shapes("parole").TextFrame2.TextRange.Characters.Text = "UN..."
End Sub
Nous appelons ici la forme que nous avons insérée sur la feuille de calcul active.
À partir de cet objet, nous allons appeler le sous-objet TextFrame2.TextRange qui contient le texte (vide pour le moment), et nous allons modifier tout le contenu avec la propriété Characters.Text.
Pour tester la macro, nous appuyons sur la touche [F5] et nous revenons sur la feuille de calculs :
Maintenant, nous allons insérer le texte à insérer dans la bulle en tant qu’argument de la fonction setParole, en le saisissant entre les parenthèses :
Sub setParole(parole As String)
ActiveSheet.Shapes("parole").TextFrame2.TextRange.Characters.Text = parole
End Sub
Comme nous l’avons vu juste avant, nous allons maintenant créer la fonction getParole qui va effectuer l’opération inverse, en nous retournant la valeur du texte inséré sur la bulle.
Pour créer une fonction, nous utilisons le mot-clé Function :
Function getParole()
getParole = ActiveSheet.Shapes("parole").TextFrame2.TextRange.Characters.Text
End Function
Ensuite, nous affectons la valeur du texte de la bulle à cette fonction getParole.
Maintenant que nous sommes en mesure de modifier, puis de récupérer le contenu de la bulle nous allons pouvoir affecter dynamiquement.
Nous créons donc une nouvelle macro changerParole, dans la laquelle nous affectons la valeur de la parole en fonction de ce que la poupée dit actuellement :
Sub changerParole()
If getParole = "UN..." Then
setParole "DEUX..."
ElseIf getParole = "DEUX..." Then
setParole "TROIS..."
ElseIf getParole = "TROIS..." Then
setParole "SOLEIL !!"
ElseIf getParole = "SOLEIL !!" Then
setParole "UN..."
End If
End Sub
De cette manière, à chaque fois que nous lancer cette macro, le texte inséré dans la bulle va être modifié :
3. C’est parti !
Maintenant, nous allons pouvoir faire avancer les joueurs !
Dans un premier temps, nous allons nous contenter de les faire avancer automatiquement, nous insèrerons le gameplay juste après.
Pour rendre le développement le plus simple possible, nous allons insérer dans la première ligne de chaque colonne une valeur que nous allons ensuite décrémenter.
En début de partie, cette valeur sera égale à 80 correspondants aux 80 lignes de l’aire de jeu.
Pour être sauvé, il faudra que celle-ci arrive en dessous de 7.
Nous créons donc une nouvelle procédure que nous appelons nouvellePartie, dans laquelle nous définissons la valeur de tous les joueurs à 80 :
Sub nouvellePartie()
[_terrain].Rows(1) = 80
End Sub
Nous allons également redéfinir la valeur de la bulle à « SOLEIL !! » :
setParole "SOLEIL !!"
Et appeler une procédure « unDeuxTroisSoleil » que nous créer juste après
unDeuxTroisSoleil
Cette procédure va nous permettre de faire défiler les termes, pour un temps aléatoire :
Sub unDeuxTroisSoleil()
If [_compter] <= 0 Then
changerParole
[_compter] = CInt(Rnd * 10)
End If
[_compter] = [_compter] - 1
End Sub
Nous regardons ici la valeur de la cellule _compter que nous avions nommée dans la première partie de ce tutoriel.
Lorsque cette valeur est inférieure ou égale à 0, alors nous modifions la parole en suivant l’ordre défini dans la procédure changerParole, puis réaffectons une nouvelle valeur aléatoire, comprise entre 0 et 10 à la cellule _compter.
Ensuite, nous décrémentons la valeur de cette cellule.
De cette manière, il suffira d’appeler à nouveau cette procédure unDeuxTroisSoleil pour faire avancer le jeu.
À partir de maintenant nous allons pouvoir créer la procédure dans laquelle nous allons insérer le déroulement de la partie :
Sub partie()
End Sub
Dans cette procédure, nous allons passer en revue les 50 colonnes du terrain de jeu pour faire avancer les joueurs :
Dim i As Integer
For i = 1 To 50
Next
Nous utilisons ici une boucle For… Next qui permet de répéter une série d’instructions dans que la valeur d’une variable (ici la variable i) est comprise dans un intervalle donné (ici de 0 à 50).
À l’intérieur de cette boucle, chaque joueur est identifié par la variable i.
Nous pouvons donc récupérer et modifier la position de chacun des joueurs avec Cells(1, i), c’est-à-dire la cellule située sur la première ligne de la feuille de calcul, et sur la colonne correspondant à la variable i.
Pour les modifier, nous allons simplement décrémenter la valeur de cette cellule, uniquement tant que cette valeur est supérieure à 7 :
Sub partie()
Dim i As Integer
For i = 1 To 50
If Cells(1, i) > 7 Then
Cells(1, i) = Cells(1, i) - 1
End If
Next
End Sub
Ensuite, le but va être de répéter cette opération jusqu’à qu’il reste encore des participants au jeu.
Nous allons donc créer une fonction qui va se charger de compter le nombre de cellules de la première ligne qui ont une valeur supérieure à 7 :
Function joueursEnJeu() As Integer
Dim nombre As Integer, i As Integer
For i = 1 To 50
If Cells(1, i) > 7 Then
nombre = nombre + 1
End If
Next
joueursEnJeu = nombre
End Function
Il suffit maintenant d’appeler cette petite fonction pour connaître le nombre de joueurs n’ayant pas encore passé la ligne d’arrivée.
Nous pourrons ainsi relancer la procédure partie jusqu’à ce que ce nombre soit nul :
Sub partie()
Dim i As Integer
For i = 1 To 50
If Cells(1, i) > 7 Then
Cells(1, i) = Cells(1, i) - 1
End If
Next
If joueursEnJeu > 0 Then
partie
End If
End Sub
Nous en profitons également pour lancer la procédure changerParole :
If joueursEnJeu > 0 Then
unDeuxTroisSoleil
partie
End If
Nous pouvons lancer la procédure nouvellePartie à ce moment-là du développement, mais nous ne pourrons pas voire grand-chose, le jeu défilera bien trop rapidement.
Nous allons donc introduire une pause entre chaque lancement de la procédure partie.
Pour cela, nous allons utiliser la procédure que nous avions découverte dans le tutoriel dédié à la création d’une pause en VBA :
Sub pause(dureePause As Single)
Dim finPause As Single
finPause = Timer() + dureePause
Do While Timer < finPause
DoEvents
Loop
End Sub
Il ne reste plus qu’à insérer cette pause avec les appels des procédures unDeuxTroisSoleil et partie :
If joueursEnJeu > 0 Then
pause 0.1
unDeuxTroisSoleil
partie
End If
Pour pouvoir simplifier le lancement de chaque nouvelle partie, nous pouvons insérer un bouton sur la feuille de calcul.
Pour cela, nous allons ajouter une zone de texte (menu Insertion > Zone de texte), que nous pourrons mettre en forme depuis le menu « Mise en forme de l’objet » :
Puis, nous effectuons un clic-droit sur celui-ci afin de choisir Affecter une macro.
Dans la fenêtre qui s’affiche, nous choisissons la macro nouvellePartie et nous validons en appuyant sur le bouton [OK].
Et voilà, nous avons bien avancé dans le développement de notre jeu, même si cela ne se voit absolument pas pour le moment !
Mais pas de panique, nous allons revenir sur notre feuille de calcul, afin de faire apparaitre les joueurs comme par magie…
6. Ajouter les participants
Pour faire apparaitre les participants à la partie de « 1, 2, 3, Soleil » sur le terrain de jeu, nous allons utiliser la mise en forme conditionnelle.
Nous sélectionnons donc toutes les cellules de l’aire de jeu, en sélectionnant la plage nommée _terrain :
Puis, nous nous rendons dans le menu Accueil > Mise en forme conditionnelle > Nouvelle règle.
Dans la fenêtre qui s’affiche, nous choisissons la dernière option « Utiliser une formule pour déterminer pour quelles cellules le format sera appliqué » :
Et nous saisissons la formule suivante :
=A$1=LIGNE()
En d’autres termes, nous regardons si la valeur saisie dans la première ligne correspond au numéro de la ligne en cours.
Cela étant fait, nous cliquons sur le bouton Format… afin de sélectionner une couleur de fond correspondante à la couleur des joueurs (en vert) :
Maintenant, si nous lançons la procédure nouvelle partie, nous allons pouvoir constater la présence des joueurs en vert sur le plateau.
En revanche, nous constatons également deux éléments à corriger.
Le premier de ces éléments, c’est qu’Excel fait avancer un joueur à la fois, et non pas l’ensemble des joueurs.
Pour corriger ce problème, nous allons simplement stopper l’actualisation des éléments de la feuille de calcul le temps de calculer les nouvelles positions de tous les participants, que nous ne manquerons pas réactiver juste après.
Pour cela, nous utilisons la propriété Application.ScreenUpdating, à laquelle nous donnons tout d’abord la valeur de False pour désactiver le rafraîchissement de la feuille de calcul, puis que nous passerons à True pour le réactiver :
Application.ScreenUpdating = False
For i = 1 To 50
If Cells(1, i) > 7 Then
Cells(1, i) = Cells(1, i) - 1
End If
Next
Application.ScreenUpdating = True
Le second problème à corriger, c’est que les joueurs avancent tous en rang, au même rythme.
Nous allons donc introduire une notion d’aléatoire, en en retirant non pas la valeur « 1 » lors de chaque lancement de la procédure Sub, mais une valeur aléatoire comprise en 0 et 1 grâce à l’instruction Rnd :
For i = 1 To 50
If Cells(1, i) > 7 Then
Cells(1, i) = Cells(1, i) - 1 * Rnd
End If
Next
Par contre maintenant avant de tester, nous allons devoir modifier la formule insérée dans la mise en forme conditionnelle, afin de convertir le résultat des cellules situées sur la première ligne du terrain en une valeur entière.
Nous répétons donc l’opération en sélectionnant la plage nommée _terrain, puis nous nous rendons dans le menu Accueil > Mise en forme conditionnelle, et cette fois-ci, nous sélectionnons Gérer les règles.
Nous retrouvons alors notre règle, sur laquelle nous effectuons un double clic afin de modifier la formule comme ceci :
=ENT(A$1)=LIGNE()
Puis, nous validons.
Les joueurs avancement maintenant chacun à leur rythme :
5. Un, deux, trois, Soleil !
Il est maintenant temps d’implémenter la gestion du « 1, 2, 3, Soleil » dans notre jeu.
La règle est très simple : les joueurs peuvent avancer à leur rythme pendant les phases « 1 », « 2 » et « 3 ».
Par contre, le moindre mouvement effectué pendant la phase « Soleil » est synonyme d’élimination !
Pour que les participants ne puissent avancer qu’au moment adéquat, nous revenons dans la procédure partie et nous effectuons un test qui va analyser la valeur de la bulle parole avant d’autoriser les joueurs à avancer :
For i = 1 To 50
If Cells(1, i) > 7 Then
If getParole = "UN..." Or getParole = "DEUX..." Or getParole = "TROIS..." Then
Cells(1, i) = Cells(1, i) - 1 * Rnd
End If
End If
Next
Puis pour simuler les éliminations, nous allons lancer un tirage aléatoire, et nous décrèterons que la personne a bougé lorsque cette valeur sera inférieure à 0,01.
Dans ce cas, nous multiplierons la valeur de la cellule par -1 pour le passer en négatif et l’éliminer :
If Cells(1, i) > 7 Then
If getParole = "UN..." Or getParole = "DEUX..." Or getParole = "TROIS..." Then
Cells(1, i) = Cells(1, i) - 1 * Rnd
ElseIf getParole = "SOLEIL !!" Then
If Rnd < 0.01 Then
Cells(1, i) = Cells(1, i) * -1
End If
End If
End If
Maintenant, les joueurs éliminés disparaissent du plateau :
Mais nous pouvons également les faire apparaitre dans une autre couleur, et définissant une nouvelle mise en forme conditionnelle :
Ce qui permet de les faire apparaitre sur le terrain :
6. Et maintenant le jeu !
Le programme est maintenant fonctionnel, nous pouvons lancer une partie et voir les différents concurrents à « 1, 2, 3, Soleil ».
À présent, il est temps de rendre le jeu interactif en ajoutant une part de Gameplay.
Pour cela, nous allons réserver une place pour le joueur, que nous verrons avancer en cliquant le plus rapidement possible sur un bouton dédié.
Pour définir où va se placer le joueur, nous allons commencer par effectuer un tirage aléatoire compris entre 1 et 50, que nous viendrons enregistrer dans la cellule _position, au moment où nous lançons la partie, c’est-à-dire dans la procédure nouvellePartie :
Sub nouvellePartie()
[_terrain].Rows(1) = 80
setParole "UN..."
[_position] = CInt (Rnd * 50) + 1
unDeuxTroisSoleil
End Sub
Pour différencier notre joueur, nous allons venir modifier la mise en forme conditionnelle utilisée pour nous assurer que celle-ci soit appliquée sur tous les joueurs, à l’exception de celui qui se trouve dans la colonne dont le numéro est stocké dans la cellule _position :
La fonction ET() permet de cumuler les tests et donc de contrôler non seulement si la valeur de la cellule A1 correspond au numéro de la ligne, mais également que le numéro de la colonne est différent de celui inscrit en cellule _position.
Il ne reste plus qu’à dupliquer cette mise en forme pour regarder si cette fois-ci il s’agit bien de la position du joueur et d’appliquer une couleur différente :
Nous allons également devoir modifier la procédure qui fait avancer les joueurs pour exclure celui correspondant au joueur :
Puis nous allons ajouter une nouvelle procédure pour faire avancer notre joueur :
Sub avancer()
End Sub
Cette macro sera activée en cliquant sur un bouton :
Pour commencer, nous allons nous contenter de décrémenter la valeur de la cellule dans la laquelle se trouve la position du joueur :
Sub avancer()
Cells(1, [_position]) = Cells(1, [_position]) - 1
End Sub
Bien entendu, pour éviter que le joueur n’avance trop vite face à ses adversaires, nous allons pondérer cette décrémentation :
Sub avancer()
Cells(1, [_position]) = Cells(1, [_position]) - 0.4 * Rnd
End Sub
Ensuite, si le joueur avance pendant la période « Soleil », nous devons éliminer le joueur :
Sub avancer()
If getParole = "UN..." Or getParole = "DEUX..." Or getParole = "TROIS..." Then
Cells(1, [_position]) = Cells(1, [_position]) - 0.4 * Rnd
ElseIf getParole = "SOLEIL !!" Then
setParole "Vous êtes éliminé !"
Cells(1, [_position]) = -Cells(1, [_position])
End If
End Sub
Maintenant, nous pouvons interrompre le jeu, inutile d’aller plus loin si le joueur a perdu la partie.
Nous revenons dans procédure partie pour effectuer le contrôle :
Sub partie()
…
If joueursEnJeu > 0 And (getParole = "UN..." Or getParole = "DEUX..." Or getParole = "TROIS..." Or getParole = "SOLEIL !!") Then
pause 0.1
unDeuxTroisSoleil
partie
End If
End Sub
Puis, à l’inverse, nous allons regarder si le joueur a gagné :
Sub avancer()
If Cells(1, [_position]) > 0 And Cells(1, [_position]) < 7 Then
setParole "Bravo ! Vous êtes arrivé en " & (50 - joueursEnJeu) & "e position !"
ElseIf getParole = "UN..." Or getParole = "DEUX..." Or getParole = "TROIS..." Then
Cells(1, [_position]) = Cells(1, [_position]) - 0.4 * Rnd
ElseIf getParole = "SOLEIL !!" Then
setParole "Vous êtes éliminé !"
Cells(1, [_position]) = -Cells(1, [_position])
End If
End Sub
Et voilà, notre jeu est maintenant terminé !
Bien entendu, celui-ci est encore grandement perfectible…
Alors si vous avez des idées d’amélioration, n’hésitez pas à m’en faire part, si elles sont suffisamment nombreuses, je pourrai peut-être préparer une seconde partie !
Vous pouvez bien entendu le télécharger en suivant le lien de téléchargement.