QB64 : Installation et introduction au Quick Basic

Alexandre Laurent

Vous souhaitez vous lancer dans la conception d'un jeu vidéo et cela, avec la volonté de programmer et de mettre les mains dans le cambouis. Alors QB64 est fait pour vous et ce tutoriel sera votre guide pour découvrir ce merveilleux moteur et langage de programmation.

Commentez

- Titre : QB64 : Installation et introduction au Quick Basic

- Auteur : Alexandre Laurent

- Parution : 15 avril 2014

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2014 Alexandre Laurent. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- I-A. QB64

- I-A-1. Spécificités

- I-A-2. Exemples de jeux

- I-A-2-a. Papi Commando

- I-A-2-b. Black Annex

- I-A-2-c. Barbarian Remake

- II. Installation

- II-A. Windows

- II-B. Linux

- II-C. Mac OS X

- II-D. Compilation d'un programme en ligne de commande

- III. Langage

- III-A. Hello World

- III-A-1. Les commandes

- III-A-2. Les arguments

- III-A-3. Les variables

- III-A-4. Les chaînes de caractères

- III-A-5. Les entrées utilisateurs

- III-A-6. Les commentaires

- III-B. Déroulement du programme

- III-B-1. Les conditions

- III-B-2. Les boucles

- III-B-2-a. La boucle FOR

- III-B-2-b. La boucle DO

- III-B-3. Les procédures

- III-B-3-a. SUB

- III-B-3-b. FUNCTION

- III-B-3-c. Les arguments

- IV. Exercice : jeu des allumettes

- IV-A. Règles

- IV-B. Réflexion

- IV-C. Code final

- IV-D. Améliorations

- V. Remerciements

I - Introduction

Vous souhaitez faire un jeu vidéo et vous souhaitez programmer ? Vous voulez faire un jeu vidéo rapidement et simplement, sans pour autant passer par un logiciel de création de jeu vidéo ? Vous êtes alors au bon endroit !

I-A - QB64

QB64 est un compilateur (logiciel transformant le code source en exécutable) pour le langage de programmation BASIC pour Windows, Linux et Mac OS X. De plus, QB64 propose un éditeur apportant de nombreuses fonctionnalités vous aidant lors de l'écriture de votre code.

Si vous préférez utiliser un autre éditeur de code, cela est aussi possible.

De plus, QB64 permet la programmation 64 bits grâce à l'ajout des types en 64 bits ainsi qu'un meilleur support du son et des graphismes et offre ainsi une solution moderne tout en utilisant le langage simple BASIC.

I-A-1 - Spécificités

QB64 est un choix intéressant pour un débutant en programmation souhaitant développer un jeu vidéo pour les raisons suivantes :

- un langage de programmation simple : le BASIC (Beginners All-purpose Symbolic Instruction Code) ;

- une compilation du programme en C++, permettant d'atteindre des hautes performances ;

- des améliorations pour les graphismes (reposant sur la SDL) et pour le support audio. Ainsi, vous pouvez créer des fenêtres d'une résolution supérieure à 640 x 480 et ouvrir des fichiers sonores comme les fichiers MP3 et OGG ou les fichiers image comme les fichiers PNG et JPEG. Pour ces raisons, QB64 est un logiciel convenable pour créer un jeu vidéo.

I-A-2 - Exemples de jeux

Pour vous convaincre, voici quelques jeux réalisés avec QB64 :

I-A-2-a - Papi Commando

Papi Commando est un jeu de tir vu de dessus d'un membre de Developpez.com.

Animation en format "youtube" non supportée.
Contenu uniquement consultable en ligne à cette adresse :
https://www.youtube.com/watch?v=ipJUBIhLVM4

I-A-2-b - Black Annex

Un jeu 2D d'infiltration, espionnage et sabotage dans des bureaux d'entreprises.

Animation en format "youtube" non supportée.
Contenu uniquement consultable en ligne à cette adresse :
https://www.youtube.com/watch?v=ZqlveWIhCFI

I-A-2-c - Barbarian Remake

Barbarian est un jeu oldschool de combat sorti sur les vieux micro-ordinateurs.

Animation en format "youtube" non supportée.
Contenu uniquement consultable en ligne à cette adresse :
https://www.youtube.com/watch?v=DOUSL6Za3SU

II - Installation

L'installation de QB64 est très rapide.

II-A - Windows

Sous Windows, il suffit de télécharger le fichier .7z à partir du site qb64.net (prenez la dernière version) et de décompresser le fichier dans le répertoire que vous souhaitez.

II-B - Linux

Sous Linux, vous devez télécharger le fichier .tar.gz à partir du site qb64.net (prenez la dernière version) et de décompresser le fichier dans un répertoire. Ensuite, vous devez exécuter (dans un terminal) le script setup_lnx.sh. Celui-ci vous guidera dans le processus d'installation en vérifiant et vous indiquant quelles sont les dépendances manquantes.

Une fois prêt (et que tout s'est bien passé), QB64 se lance, validant l'installation.

Sous Linux, l'éditeur BASIC de QB64 (version 0980) souffre d'un problème de performance. En effet, même le simple fait de taper du code provoquera des latences insupportables. Le problème est connu mais ne dispose pas de solution au moment de l'écriture de ce tutoriel. Le mieux est de choisir un autre éditeur (de le configurer pour colorer le code source en suivant la syntaxe BASIC) et de compiler en ligne de commande.

II-C - Mac OS X

Sous Mac OS X, vous devez télécharger le fichier macosx.tar.gz à partir du site qb64.net (prenez la dernière version). Ensuite, vous devez installer Xcode à partir du magasin d'applications (QB64 utilise le compilateur installé par Xcode, vous n'aurez pas besoin directement de Xcode). Sur Mac OS X Lion ou supérieur, vous devez installer les outils en ligne de commande (command line tools). Vous pouvez le faire à partir de Xcode, par le menu « Préférences » (« Preferences ») → « Téléchargements » (« Downloads ») → « Composants » (« Components ») puis en cliquant sur « Installer » (« Install ») sur la ligne correspondant à l'outil.

Finalement, vous pouvez extraire le fichier QB64 téléchargé et exécuter le fichier setup_osx.command.

II-D - Compilation d'un programme en ligne de commande

Vous pouvez utiliser votre propre éditeur pour programmer en QB64. Lorsque vous voulez compiler, il suffira d'appeler le programme qb64 avec l'option -c et le nom de votre fichier pour qu'il soit compilé.

III - Langage

Le langage est donc un dérivé du BASIC. Il est simple et intuitif.

III-A - Hello World

Commençons par le classique Hello World. Cela permettra de vérifier que votre configuration des outils fonctionne correctement.

Voici :

CLS
PRINT "Mon premier programme QB64 !"
END

La première ligne contient juste une commande (CLS) et permet de nettoyer l'écran (Clear Screen). La seconde, permet d'afficher (PRINT) un texte, qui suit directement la commande PRINT. Lorsque l'on fait suivre une commande de quelque chose, on appelle la partie qui suit la commande « un argument ». La dernière ligne indique simplement la fin (END).

Ici, si vous enlevez le END, cela reviendra au même, car QB64 en voyant la fin du programme, se met en pause et attend une touche.

Le programme affichera donc :

Mon premier programme QB64 !

III-A-1 - Les commandes

Les commandes sont des mots clés qui sont exécutés et qui ne retournent pas de valeur.

Les commandes sont souvent des mots d'anglais comme : FOR, NEXT, IF, THEN, GOTO. Quelquefois, les mots clés peuvent être des abréviations, comme pour CLS (CLear Screen). Une commande peut prendre en paramètres des arguments : des variables qui seront utilisées pendant l'exécution de la commande.

III-A-2 - Les arguments

Les arguments pour les commandes ne sont généralement pas placés entre parenthèses. Toutefois, cela est possible et notamment, pratique pour la lecture, pour des arguments décrivant par exemple les coordonnées X et Y.

Quelquefois, un ou des arguments peuvent être optionnels. Dans un tel cas, ils recevront une valeur par défaut.

Chaque argument est séparé par une virgule :

LINE (160, 100)-(170, 110), , B

Ici, on peut voir une série d'arguments, dont un, sans valeur, qui utilisera donc la valeur par défaut.

III-A-3 - Les variables

Les variables sont des éléments qui contiennent des valeurs (un nombre, par exemple, mais aussi une chaîne de caractères (un texte)) et ces valeurs peuvent changer au cours de l'exécution du programme. Les variables peuvent avoir le nom que vous souhaitez, mis à part celui des commandes (sinon le compilateur considérera cela comme une commande et non une variable).

money = 1000
PRINT money

Ce code affichera « 1000 ».

Si vous souhaitez afficher une variable et que vous voulez la faire précéder d'une chaîne de caractères, vous devez rajouter un ';' pour les séparer :

score = 1000
PRINT "Mon score est : " ; score

III-A-4 - Les chaînes de caractères

Les chaînes de caractères sont des variables contenant du texte. Afin de les différencier des autres variables, il est d'usage de rajouter un '$' après le nom de la variable.

Vous pouvez aussi ajouter du texte simplement avec l'opérateur '+' :

site$ = "Developpez" + ".com"

III-A-5 - Les entrées utilisateurs

À un certain point dans votre parcours en programmation, vous allez vouloir demander des informations à l'utilisateur, par exemple, pour qu'il définisse la valeur d'une variable. Cela est possible avec la commande INPUT :

INPUT "Votre nom : " ; nom$

Cela fera que le programme affiche « Votre nom : » et attendra que l'utilisateur entre son nom. La variable « nom$ » prendra la valeur de ce que l'utilisateur a entré.

III-A-6 - Les commentaires

La programmation n'est pas une tâche toujours aisée. Nous écrivons du code qui est la transformation d'une idée en un langage. Cela peut paraître simple, mais le jour (que ce soit le lendemain, ou dans un mois) où vous revenez sur votre code et que vous essayez de le relire, l'idée que vous aviez en l'écrivant sera peut-être oubliée.

Pour éviter ces problèmes et rendre la lecture d'un code aisée, vous pouvez rajouter des commentaires. Les commentaires sont du texte, qui ne sera pas utilisé par le compilateur. Vous pouvez écrire tout ce que vous voulez, il est pour vous.

En BASIC, un commentaire commence par ' :

' Ceci est un commentaire
' Je peux écrire ce que je veux. Even in english.
' Je peux aussi mettre du code toto = 5
' Qu'il soit juste ou pas, peu importe, le compilateur ignore les commentaires
solution = 42 ' Je peux aussi écrire des commentaires après un code
' Le but d'un commentaire n'est pas de décrire ce que signifie la ligne, mais sa conséquence
' Ici, j'ai simplement voulu définir la solution à ma variable, variable qui sera utilisée plus loin et comparée avec ce que l'utilisateur va répondre

III-B - Déroulement du programme

Le programme suit généralement le code écran, ligne par ligne, de haut en bas. Mais il devient vite nécessaire de briser ce déroulement linéaire, afin de lui faire répéter des choses, ou encore, de n'exécuter des morceaux de code uniquement si certaines conditions sont vérifiées.

III-B-1 - Les conditions

Les conditions permettent d'indiquer à l'ordinateur d'exécuter un code, uniquement si certains facteurs sont vérifiés. Pour indiquer une telle condition, la commande s'appelle IF (si). Après le IF, vient la condition à vérifier. Et pour indiquer l'action à faire en cas de commande vérifiée, vous devez utiliser THEN (alors), suivi de l'action à exécuter :

IF money < 1000 THEN PRINT "Vous ne pouvez pas acheter ceci"

Qui peut se traduire par :

Si le contenu de la variable money est inférieur à 1000, alors, afficher « Vous ne pouvez pas acheter ceci ».

Parmi les tests, vous pouvez utiliser :

<

Inférieur à

>

Supérieur à

=

Égal à

<>

Différent de

>=

Supérieur ou égal à

<=

Inférieur ou égal à

De plus, il existe deux autres mots clés : AND (ET) et OR (OU) qui permettent de lier des conditions :

IF money < 1000 AND diamant < 5 THEN PRINT "Vous ne pouvez pas acheter ceci"

Qui peut se traduire par :

Si le contenu de la variable money est inférieur à 1000 et que le contenu de la variable diamant est inférieur à 5, alors, afficher « Vous ne pouvez pas acheter ceci ».

III-B-2 - Les boucles

Les boucles permettent de répéter un morceau de code plusieurs fois.

III-B-2-a - La boucle FOR

La boucle FOR permet de répéter un code, en utilisant un compteur. À chaque passage dans la boucle, le compteur va être incrémenté d'une valeur (STEP (pas)). Lorsqu'il a atteint une valeur finale (TO), la boucle n'est plus exécutée et le programme continue :

FOR i = 0 TO 5 STEP 1
PRINT "J'ai ecrit " ; i ; " fois cette phrase"
NEXT

Le mot clé NEXT, permet d'indiquer la fin de la boucle.

Qui affichera :

J'ai ecrit 1 fois cette phrase
J'ai ecrit 2 fois cette phrase
J'ai ecrit 3 fois cette phrase
J'ai ecrit 4 fois cette phrase
J'ai ecrit 5 fois cette phrase

Après la boucle, la variable i contient 6.

Le code peut se traduire ainsi :

Pour une variable i, ayant pour valeur initiale 0. La boucle s'arrêtera lorsque la variable i vaudra 5. La variable i sera incrémentée de 1 à chaque tour (chaque appel à NEXT). Afficher le message « J'ai ecrit 'contenu de la variable i' fois cette phrase ».

Le NEXT permet d'effectuer l'incrémentation de la variable compteur (dans l'exemple, le compteur est la variable i). Le NEXT indique aussi que le programme doit revenir à la ligne du FOR et vérifier la valeur finale, avant de réexécuter (ou non) le code du FOR.

Il n'est pas obligatoire d'écrire STEP 1 lorsque l'incrément est de 1. En effet, c'est sa valeur par défaut.

Il est possible d'avoir un STEP négatif. Veuillez toutefois donner une valeur initiale plus grande que la valeur finale, sinon la boucle sera simplement ignorée.

III-B-2-b - La boucle DO

La boucle DO vous permet de créer des boucles s'exécutant tant qu'une condition est vraie (ou tant qu'une condition n'est pas vérifiée).

i = 0
DO WHILE i <= 5
PRINT "J'ai ecrit " ; i ; " fois cette phrase"
i=i+1
LOOP

Cette boucle effectue la même chose que la boucle FOR précédente. Elle peut être traduite de la façon suivante :

Une variable i ayant pour valeur 0.
Faire, tant que le contenu de la variable i est inférieur ou égal à 5 :
afficher « J'ai ecrit 'contenu de la variable i' fois cette phrase ».
Incrémenter i.
Boucler (revenir à la condition du DO).

À la place du WHILE, vous pouvez utiliser le mot clé UNTIL (Jusqu'à). La différence est au niveau de la logique. Le WHILE exécute la boucle, tant que la condition est valide. Le UNTIL exécute la boucle jusqu'à ce que la condition soit valide :

i = 0
DO UNTIL i = 6
PRINT "J'ai ecrit " ; i ; " fois cette phrase"
i=i+1
LOOP

Ce code écrit la même chose que la boucle précédente, sauf que le programme, cette fois, attend jusqu'à ce que i soit égal à 6.

Il existe une dernière particularité. La condition peut, soit être :

- après le DO, comme nous l'avons vu jusqu'ici ;

- après le LOOP.

Si vous mettez la condition après le LOOP, vous êtes sûr que le programme exécute au moins une fois le code de la boucle.

Vous ne pouvez pas mettre de condition en même temps après le DO et le LOOP.

III-B-3 - Les procédures

III-B-3-a - SUB

Le mot clé SUB permet de définir un bloc de code que vous pouvez exécuter en l'appelant avec CALL. Lorsque l'ordinateur arrive sur le mot clé CALL, il exécutera le contenu de ce qui est défini entre SUB et END SUB, puis continuera ce qui suit le CALL :

CALL direBonjour
PRINT "Au revoir tout le monde !"

SUB direBonjour
PRINT "Hello World"
END SUB

Les SUB doivent être placés en fin de code.

En réalité, le mot clé CALL n'est pas obligatoire, mais il rend le code plus clair.

III-B-3-b - FUNCTION

Le mot clé FUNCTION est similaire au mot clé SUB. Il permet de définir un morceau de code à exécuter, mais lorsque vous utilisez FUNCTION, il est possible de retourner une valeur.

PRINT "Hello World"
retour = direAurevoir
PRINT "C'est fini"

FUNCTION direAurevoir
PRINT "Au revoir"
END FUNCTION

Ce qui affiche :

Sortie de l'application

Hello World
Au revoir
C'est fini

Comme vous pouvez le remarquer, pour une fonction, il est nécessaire de récupérer une valeur (ici, dans la variable retour).

Tout comme pour les SUB, les FUNCTION doivent être définies en fin de code.

Ici, la variable retour aura pour valeur 0, car nous n'avons précisé aucune valeur de sortie.

Pour indiquer une valeur à retourner, il faut simplement définir une valeur à une variable du nom de la fonction :

retour = donneCinq
PRINT retour

FUNCTION donneCinq
donneCinq = 5
END FUNCTION

Ce qui affichera '5'.

III-B-3-c - Les arguments

Pour rendre les SUB et les FUNCTION un peu plus polyvalents et réutilisables, il est possible de leur passer des arguments :

PRINT somme(10, 20)

FUNCTION somme (a, b)
somme = a + b
END FUNCTION

Ce code affichera '30'.

IV - Exercice : jeu des allumettes

Pour apprendre la programmation et devenir bon dans ce domaine, il est important de pratiquer et de s'entraîner. Pour appliquer les quelques concepts vus précédemment, nous allons faire un petit jeu.

IV-A - Règles

C'est un jeu à deux joueurs. Quinze allumettes sont posées sur la table et chacun des deux joueurs peut prendre 1, 2 ou 3 allumettes tour à tour. Celui qui prend la dernière allumette a perdu.

IV-B - Réflexion

Lorsque vous avez un problème, quel qu'il soit, vous devez le décomposer et en garder l'essentiel. Ici, les mots clés ont été mis en gras. Il y a certes peu d'informations, mais l'exercice est simple.

Nous avons quinze allumettes au début. Donc :

nbAllumettes = 15

Le jeu ne se termine que lorsqu'un joueur a pris la dernière allumette. Cela sous-entend que le jeu fonctionne tant qu'il reste des allumettes donc nous pouvons inclure la partie, dans une boucle ayant pour condition :

DO WHILE nbAllumettes <> 0

LOOP

Ensuite, il faut que l'on sache combien d'allumettes le joueur veut. On utilisera donc INPUT, mais son choix est limité, donc, nous devons rajouter un test. Mais ce test ne sera pas un simple IF, sachant que s'il prend un choix invalide, nous devons lui faire choisir autre chose. Donc ce sera une boucle, tant qu'il n'a pas choisi le bon nombre :

allumettesPrises = 0
DO
INPUT "Combien d'allumettes prenez-vous " ; allumettesPrises
LOOP UNTIL allumettesPrises >= 1 AND allumettesPrises <= 3

Le test utilisé est allumettesPrises >= 1 ET allumettesPrises <= 3, il était possible aussi de faire :

allumettesPrises = 1 OU allumettesPrises = 2 OU allumettesPrises = 3.

Toutefois, le test n'est pas complet. En effet, il est possible au joueur de prendre plus d'allumettes qu'il n'en reste sur la table. Nous ne voulons pas que ce soit le cas, donc nous rajoutons une condition :

DO
PRINT "Joueur " ; joueur
INPUT "Combien d'allumettes prenez-vous " ; allumettesPrises
LOOP UNTIL allumettesPrises >= 1 AND allumettesPrises <= 3 AND allumettesPrises <= nbAllumettes

Pour simuler le geste de « prendre des allumettes », il suffit de soustraire le nombre d'allumettes prises du nombre d'allumettes restantes :

nbAllumettes=nbAllumettes-allumettesPrises
PRINT "Il reste " ; nbAllumettes ; " allumettes"

Et on peut boucler.

Vous pouvez déjà tester le jeu, il est fonctionnel, mais pas parfait. En effet, il manque la gestion des joueurs. Ici, on ne fera rien de compliqué, simplement un joueur 1 et un joueur 2 qui s'alternent.

Donc, avant la boucle principale, on ajoutera :

joueur=1

On commence certes, par le joueur 1. C'est un choix arbitraire.

Pour un peu plus de clarté, nous pouvons rajouter :

PRINT "Joueur " ; joueur

dans la boucle lorsque le joueur sélectionne le nombre d'allumettes.

Ensuite, une fois que les allumettes sont retirées de la table, nous devons passer au tour de l'autre joueur.

Une simple incrémentation ne suffit pas, sinon, au bout du troisième tour, un troisième joueur apparaîtrait. Il existe néanmoins une astuce : nous avons deux joueurs, il suffit de soustraire la variable joueur à trois :

joueur=3-joueur

Vous pouvez tester :

- si joueur indique le premier joueur (et vaut 1), 3 - 1 = 2, nous sommes passés au second joueur ;

- si joueur indique le second joueur (et vaut 2), 3 - 2 = 1, nous repassons au premier joueur. Parfait !

Finalement, après la boucle principale, nous rajoutons :

PRINT "Joueur " ; joueur ; " a gagné"

IV-C - Code final

PRINT "Jeu des allumettes en QB64 pour Developpez.com"

joueur=1
nbAllumettes = 15
PRINT "Vous avez 15 allumettes, vous pouvez en prendre soit 1, 2, ou 3"
DO WHILE nbAllumettes <> 0

allumettesPrises = 0
DO
PRINT "Joueur " ; joueur
INPUT "Combien d'allumettes prenez-vous " ; allumettesPrises
LOOP UNTIL allumettesPrises >= 1 AND allumettesPrises <= 3 AND allumettesPrises <= nbAllumettes

nbAllumettes=nbAllumettes-allumettesPrises
PRINT "Il reste " ; nbAllumettes ; " allumettes"

joueur=3-joueur
LOOP

PRINT "Joueur " ; joueur ; " a gagné"

IV-D - Améliorations

Il est possible d'améliorer le jeu. Pour vous entraîner et mieux maîtriser QB64, vous pouvez :

- faire en sorte que le jeu demande si les joueurs veulent faire une nouvelle partie. Si oui, alors, on relance une partie (nbAllumettes = 15), sinon, on termine le programme ;

- placer la demande du nombre d'allumettes dans une fonction. La fonction doit accepter deux arguments, le joueur actuel et le nombre d'allumettes restantes et retourner le choix du joueur ;

- vous pouvez l'améliorer comme vous le souhaitez. Il est possible de changer la couleur d'affichage avec le mot clé COLOR.

V - Remerciements

Je tiens à remercier Vetea pour ses judicieuses remarques.

Merci aussi à Phanloga et f-leb pour leur relecture orthographique.