QB64 : Installation et introduction au Quick Basic

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.

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▲

I-A-2. Exemples de jeux▲

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.

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 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.

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é.

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).

Le programme affichera donc :

Mon premier programme QB64 !

III-A-1. Les commandes▲

III-A-2. Les arguments▲

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

III-A-3. Les variables▲

money = 1000 
PRINT money

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

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

site$ = "Developpez" + ".com"

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

INPUT "Votre nom : " ; nom$

III-A-6. Les commentaires▲

' 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

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▲

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

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

III-B-2. Les boucles▲

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

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

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

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

III-B-3. Les procédures▲

CALL direBonjour 
PRINT "Au revoir tout le monde !" 

SUB direBonjour 
PRINT "Hello World" 
END SUB

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

FUNCTION direAurevoir 
PRINT "Au revoir" 
END FUNCTION

Hello World
Au revoir
C'est fini

retour = donneCinq 
PRINT retour 

FUNCTION donneCinq 
donneCinq = 5 
END FUNCTION

PRINT somme(10, 20) 

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

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.

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

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é"

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.