Créer un jeu vidéo : découverte de la boucle de jeu

Un jeu vidéo, comme tout jeu, s’articule autour d’une boucle. Il faut bien comprendre qu’un jeu vidéo n’est pas bien différent d’un jeu de société. Dans le cas du jeu de société, il y aura toujours les deux phases suivantes :

La mise en place du plateau de jeu (en anglais, ce serait setup)
Le jeu en lui-même découpé en tours de jeu (en anglais, ce serait loops)

Oui mais un jeu vidéo à la Zelda, Mario, Fortnite, il n’y a pas de tours de jeu. Non, en effet, il y a des images. Pour ces jeux, après leur chargement (setup), ils répètent (loop) le calcule de l'image suivante à afficher. C’est exactement ce que vous automatise une bibliothèque comme PyGame.

Je ne vais pas aborder PyGame dans cet article. Je vais vous proposer de découvrir comment un jeu s’articule autour d’une boucle.

Dans ce tuto, nous allons voir :

Les bases de la création de jeu vidéo
L'usage de la bibliothèque random pour tirer un nombre au hasard
L'usage de la boucle pour gérer des tours de jeu

Ces bases vous permettront de créer des petits jeux en mode texte ou avec des interfaces simples.

Un jeu de devinette

L’idée va être de proposer un jeu où le joueur devra deviner un nombre tiré entre 0 et 10. Le programme devra donc tirer au hasard ce nombre (c’est la mise en place du jeu, setup) puis poser la question au joueur, vérifier si la proposition correspond à cette valeur pour déterminer si il a gagné ou perdu (c’est un tour de jeu).

Nous allons commencer simple : n’accepter qu’une seule réponse, c’est du gagné ou perdu en une proposition. Ce programme sera des plus classiques.

Ensuite, nous allons voir comment répéter l’action jusqu’à ce que le joueur trouve la bonne réponse.

Mise en place du jeu

Nous allons avoir une seule action ici. Pour tirer une valeur au hasard, nous allons faire appel à une fonction proposée par Python. Cette fonction est dans un module qu’il faudra importer. Le code sera donc :

import random

value = random.randint(0, 10)

La fonction random.randint(min, max) retourne un entier tiré entre les valeurs min et max. On est donc certain que la valeur sera un entier.

Pour vraiment bien faire les choses, ces deux valeurs min et max devraient même être référencées par des constantes. Ceci sera utile pour valider la proposition. Le code plus consciencieux devrait donc être :

import random

MIN_VALUE = 0
MAX_VALUE = 10

value = random.randint(MIN_VALUE, MAX_VALUE)

Dans l’idéal, le programme devrait annoncer à l'utilisateur les règles du jeu et ce qu'il faudra faire. Je vous laisse compléter cette partie.

Vous n’avez qu’un seul essai

Maintenant, il faut attendre la proposition du joueur. Avec notre jeu en mode texte, nous allons simplement poser la question avec la fonction input(). Celle-ci retourne la saisie de l’utilisateur. Attention, cette valeur retournée est une chaine de caractères. Nous allons supposer qu’il n’y a pas d’erreur. Nous allons donc convertir la chaine en entier puis le comparer avec la valeur tirée. Si c’est la même, nous affichons un message de félicitation, sinon, on informe que ce n’était pas ça.

answer = int(input("Quelle est ta proposition ? : "))

if answer == value:
    print("Bravo, tu a trouvé !")
else:
    print("Dommage, ce n'était pas ça")

Nous avons ici un programme bien linéaire qui se termine après une seule proposition. C’est notre base.

Raté ? Continuons à jouer

Si nous souhaitons demander le résultat jusqu’à ce qu’il soit trouvé, il faut répéter la question, donc écrire une boucle. Dans le cas d’un jeu, il y aura deux possibilités :

Soit il n’y a pas de limite dans le nombre de propositions, alors la question sera posée autant de fois que nécessaire. On ne peut anticiper le nombre de répétitions, il faudra utiliser une boucle while.
Soit on va imposer un certain nombre d’essais, alors on sait combien de fois (maximum) on va poser la question. Il faudra dans ce cas utiliser une boucle for.

Précédemment, j’avais essayé de dédramatiser la boucle infinie. Vous allez voir que nous allons mettre en œuvre cette pratique.

Répétons jusqu’à trouver la réponse

Répéter la question tant qu’on n’a pas la bonne réponse est une boucle indéterminée mais pas infinie. Nous allons répéter la question jusqu’à ce que la bonne réponse soit trouvée. Ou encore, nous allons répéter la question tant que la bonne réponse n’est pas trouvée. Avant de commencer à poser la question, nous pouvons définir une variable qui indiquera si la réponse a été trouvée et qui servira d’état pour le tant que.

La structure de base de ce que nous allons écrire ressemble donc à ça :

found = False

while not found:
    pass

C’est dans cette boucle que nous allons placer la question et son évaluation, c’est à dire le code que nous avons écrit précédemment. Mais avec une différence : si la bonne réponse est trouvée, nous allons basculer le flag à vrai.

Flag, qui signifie drapeau en anglais, est utilisé en informatique pour parler d’une donnée qui nous indiquera quoi faire en fonction de son état. Si nous choisissons bien son nom, le code en Python peut être assez proche du langage naturel.

Nous allons donc basculer le flag à vrai quand la réponse sera trouvée. Notre code ressemblera alors à ceci :

found = False

while not found:
    answer = int(input("Quelle est ta proposition ? : "))

    if answer == value:
        print("Bravo, tu a trouvé !")
        found = True
    else:
        print("Dommage, ce n'était pas ça")

Dans ce cas, tout le code est dans la boucle. Le comportement en cas de victoire est dans la condition où la bonne réponse à été trouvée.

Limitons le nombre d’essais

Reprenons ce jeu mais maintenant, nous allons limiter à, disons, trois essais. Évidemment, nous allons déclarer une constante pour le nombre d’essais.

Ce cas va s’écrire avec la structure for et la fonction range().

MAX_ATTEMPTS = 3

for _ in range(MAX_ATTEMPTS):
    pass

Nous pouvons donc ajouter notre code dans le bloc du for ce qui nous amène à la structure suivante :

for _ in range(MAX_ATTEMPTS):
    answer = int(input("Quelle est ta proposition ? : "))

    if answer == value:
        print("Bravo, tu a trouvé !")
        break
    else:
        print("Dommage, ce n'était pas ça")

Cependant, si en cas de bonne proposition le jeu s’arrête correctement, ce n’est pas le cas si le bon résultat n’a pas été trouvé après tous les essais.

Pour résoudre ce défaut, nous allons utiliser la structure for else parfaitement adaptée à ce cas. Ce qui nous conduit à ce code :

for _ in range(MAX_ATTEMPTS):
    answer = int(input("Quelle est ta proposition ? : "))

    if answer == value:
        print("Bravo, tu a trouvé !")
        break
    else:
        print("Dommage, ce n'était pas ça")

else:
    print(f"La bonne réponse était {value}")

La base d’un jeu vidéo : la boucle de jeu

En introduction de cet article, j’avais fait le parallèle avec les jeux de société ou les jeux de plateau et le découpage en deux phases : mise en place et répétition des tours de jeu. Vous voyez que l’analogie est bien adaptée.

Pour synthétiser, une boucle de jeu consiste à :

traiter les interactions de l’utilisateur
mettre à jour le jeu (score, état…)
créer l’affichage suivant

Dans le cas de notre petit jeu de devinette, c’est ce que nous faisons à la main. Pour un jeu plus complexe, nous déléguerons à des outils qui se chargent de tout ça comme avec PyGame.