Auteur : Asher256
Mise à jour : Avril 2003
URL : http://qbworld.asher256.com

Table des matières :

• 1- Introduction
• 2- Avant toute chose : TASM
• 3- Méthode pour compiler un fichier *.ASM en fichiers *.LIB et *.QLB
• 4- Comment appeler des fonctions en assembleur depuis QuickBasic ?
• 5- Comment passer des arguments à une fonction en assembleur ?
• 6- Que signifie le mot-clé BYVAL en QuickBasic ?
• 7- Comment retourner une variable de type LONG ?
• 8- Pourquoi ne pas utiliser l’assembleur NASM ?
• 9- Conclusion

1- Introduction :

Il est toujours très utile d’intégrer des routines en assembleur dans vos jeux vidéo, utilitaires, etc.

La création d’une bibliothèque en assembleur pour optimiser les performances est indispensable dans de nombreux cas. Ce document n’a pas pour vocation de vous enseigner le langage assembleur, mais vous expliquera comment concevoir des routines (PROC) pour les exécuter directement depuis votre programme QuickBasic.

Pour s’approprier pleinement ce document, le lecteur doit posséder de bonnes bases en assembleur (segments, offsets, pile…), ainsi qu’une très bonne maîtrise de QuickBasic et de l’environnement MS-DOS.

2- Avant toute chose : TASM

TASM est un excellent assembleur 16 bits. C’est l’outil que nous utiliserons dans ce tutoriel, bien que vous puissiez également recourir à MASM de Microsoft ou à l’excellent NASM.

La seule manière de lier QuickBasic et l’assembleur repose sur l’utilisation des fichiers objets (.OBJ). Après avoir assemblé votre code source avec TASM pour obtenir un fichier *.OBJ, vous utiliserez les utilitaires BC.EXE et LINK.EXE (fournis avec QuickBasic) pour compiler le fichier *.OBJ en bibliothèques *.LIB et *.QLB.*

Pour intégrer votre code assembleur à votre programme *.BAS, il vous suffira de lancer l’environnement via la commande QB.EXE /L asm.qlb. Bien que cette démarche puisse paraître complexe de prime abord, vous constaterez qu’elle est en réalité très simple !

3- Méthode pour compiler un fichier *.ASM en fichiers *.LIB et *.QLB :

Vous devez disposer de TASM (TASM.EXE), de LINK.EXE, ainsi que de l’environnement QuickBasic 4.5 accompagné de ses utilitaires dédiés, LIB.EXE et LINK.EXE :

Prenons pour exemple le fichier assembleur suivant :

lib.asm

Assemblez-le d’abord en fichier objet (lib.obj) avec TASM, puis générez les fichiers lib.qlb and lib.lib. Les fichiers *.QLB permettent d’exécuter vos routines au sein de l’interpréteur QuickBasic, tandis que les fichiers *.LIB sont requis lors de la compilation finale en exécutable (*.EXE).

Voici les commandes MS-DOS pour générer les fichiers .QLB et .LIB (il est recommandé de créer un fichier de commandes de type Batch pour automatiser cette tâche) :

del lib.lib
TASM lib.asm
LIB lib.lib +lib.obj
LINK /qu lib.lib,lib.qlb,NULL,c:\qb45\bqlb45.lib

La première commande supprime le fichier lib.lib préexistant, puis TASM assemble lib.asm en lib.obj.

Ensuite, l’utilitaire LIB.EXE de QuickBasic intègre le fichier lib.obj dans la bibliothèque lib.lib (en la créant si elle n’existe pas).

Enfin, LINK.EXE convertit le fichier lib.lib en fichier de chargement rapide lib.qlb. Veillez à remplacer c:\qb45 par le chemin réel de votre répertoire QuickBasic.

IMPORTANT : Si vous utilisez un fichier Batch, n’oubliez pas de préfixer les commandes TASM, LIB et LINK par l’instruction CALL.

Voyons désormais comment structurer nos premières routines et comment retourner une valeur de type INTEGER dans une fonction QuickBasic…

4- Comment appeler des fonctions en assembleur depuis QuickBasic ?

Une solide compréhension de l’assembleur est nécessaire pour aborder les notions suivantes.

Afin de garantir la compatibilité avec QuickBasic, veillez à toujours respecter la structure de départ suivante lors de la création de votre fichier assembleur :

.MODEL MEDIUM , BASIC ; Modèle compatible avec QuickBasic
.STACK 100h ; Allocation de l'espace de pile (256 octets)
.DATA ; Section des variables 
variable DB 'salut !!!!!!!!!'
.CODE
; Vos routines PROC ici
END

Créons une routine sous forme de fonction qui retourne la valeur 10 à QuickBasic. Voici notre premier fichier source assembleur, test.asm :

'------------------------------------- TEST.ASM ----------------------------------
.MODEL MEDIUM , BASIC ; Modèle compatible avec QuickBasic
.STACK 100h ; Allocation de l'espace de pile (256 octets)
.DATA ; Section des variables 
.CODE
PUBLIC salut ; La fonction est déclarée publique pour être visible par QuickBasic
salut PROC FAR ; Toujours utiliser la directive PROC FAR
         MOV AX,10 ; Par convention, QuickBasic récupère la valeur contenue dans le registre AX comme résultat

         RET ; Ne jamais omettre l'instruction RET
salut ENDP
END
'------------------------------------- TEST.ASM -----------------------------------

Une fois le fichier test.asm assemblé en bibliothèques test.lib et test.qlb selon la méthode précédente, lancez QuickBasic via la commande qb.exe /L test.qlb.

Puis, codez l’appel au sein du fichier test.bas :

'------------------------------------- TEST.BAS ----------------------------------
DECLARE FUNCTION salut% ( ) ' La fonction est déclarée avec le suffixe % (INTEGER) car le registre AX est sur 16 bits
DIM variable AS INTEGER
variable = salut ' Appel de la fonction salut
PRINT variable ' Affichage du résultat
'------------------------------------- TEST.BAS ----------------------------------

Appuyez sur F5

À l’exécution, le programme affichera la valeur 10 !

En résumé, pour retourner une valeur de type INTEGER, il suffit de charger cette valeur dans le registre AX.

5- Comment passer des arguments à une fonction en assembleur ?

En assembleur, il est impossible de déclarer le passage de variables de haut niveau au sein de la directive PROC comme on le ferait en langage évolué :

PUBLIC salut
salut (var1,var2) PROC FAR
         ; Instructions
         RET
salut ENDP

Cette syntaxe est incorrecte. En réalité, QuickBasic transmet l’adresse mémoire de chaque argument en l’empilant dans la pile (STACK). Prenons pour exemple la déclaration suivante :

DECLARE SUB salut( var1 AS INTEGER, var2 AS INTEGER, var3 AS INTEGER)

QuickBasic empile les adresses respectives de var1, var2 et var3. Pour accéder à ces données depuis votre routine assembleur, vous devez initialiser un pointeur de pile stable au début de votre procédure à l’aide du registre BP :

PROC SALUT
         PUSH BP ; Sauvegarde du registre BP sur la pile
         MOV BP,SP ; Initialisation du pointeur de cadre de pile
         ; Instructions
         POP BP ; Restauration du registre BP
         RET nombre_octets_passés ; Libération de l'espace occupé par les arguments
ENDP

NOTE : L’instruction RET doit impérativement être suivie du nombre total d’octets occupés par les arguments sur la pile. Dans notre exemple, avec 3 variables de type INTEGER (2 octets chacune), nous utiliserons RET 6.

L’adresse de var3 se situera à l’emplacement [BP+06], celle de var2 à [BP+08] et celle de var1 à [BP+10]. Voici comment charger la valeur de var1 dans le registre AX :

PROC SALUT
         PUSH BP ; Sauvegarde du registre BP sur la pile
         MOV BP, SP ; Initialisation du pointeur de cadre de pile
        ; Instructions de la routine
         MOV bx, [BP+10] ; Chargement de l'adresse de var1 dans BX
         MOV ax, [bx] ; Chargement de la valeur pointée par BX dans AX
         POP bp ; Restauration du registre BP
         RET 6 ; Libération des 6 octets occupés par les trois arguments (3 * 2 octets)
ENDP

Voici l’organisation théorique de la pile (STACK) lors de l’exécution de la routine :

10 Adresse de var1
08 Adresse de var2
06 Adresse de var3
04 BASIC RETURN SEGMENT
02 BASIC RETURN OFFSET
00 BP

Si votre routine nécessite la sauvegarde du registre de segment DS (via un PUSH DS), l’organisation de la pile sera décalée de deux octets :

12 Adresse de var1
10 Adresse de var2
08 Adresse de var3
06 BASIC RETURN SEGMENT
04 BASIC RETURN OFFSET
02 BP
00 DS

Le registre DS étant empilé après BP, toutes les adresses relatives se trouvent décalées. L’adresse de var1 devient alors accessible via la position [BP+12].

La modification de la valeur d’un argument s’effectue tout aussi simplement que sa lecture :

MOV BX, [BP+10] ; Chargement de l'adresse de var1 dans BX
MOV [BX], 20 ; Écriture de la valeur 20 à l'adresse pointée par BX

6- Que signifie le mot-clé BYVAL en QuickBasic ?

Modifions notre déclaraction de la manière suivante :

DECLARE SUB salut( BYVAL var1 AS INTEGER, BYVAL var2 AS INTEGER, BYVAL var3 AS INTEGER)

Quel est le rôle du modificateur BYVAL placé devant les arguments ?

Le mot-clé BYVAL indique à QuickBasic de transmettre directement la valeur numérique de l’argument au lieu de son adresse mémoire. Cela vous permet de lire la variable directement depuis la pile, sans avoir à récupérer son adresse au préalable dans un registre d’index comme BX.

Par exemple, pour obtenir directement la valeur de var1 (INTEGER) dans AX :

MOV AX, [BP+10]

Vous accédez ainsi directement à la donnée. Attention cependant : sous cette configuration, il est impossible de modifier la variable d’origine dans le programme QuickBasic, puisque seule sa valeur numérique a été transmise, et non son adresse.

7- Comment retourner une variable de type entier long (LONG) ? (contribution de Strix Slayer)

Cette opération est également très accessible. Alors qu’un entier classique (16 bits) se retourne dans le registre AX, un entier long (32 bits) utilise une paire de registres : le mot de poids fort est placé dans DX, et le mot de poids faible dans AX.

Reprenons l’exemple précédent :

Le fichier : Toto.asm

PUBLIC Toto
PROC Toto
         MOV DX, 00h     ; Chargement du mot de poids fort dans DX
         MOV AX, 5        ; Chargement du mot de poids faible dans AX
         RETF
ENDP

Dans l’environnement QuickBasic, chargez la bibliothèque *.QLB correspondante et codez l’appel dans le fichier Toto.bas :

Le fichier: Toto.bas

DECLARE FUNCTION Toto&
PRINT Toto&

Le programme affichera alors la valeur 5 !

8- Pourquoi ne pas utiliser l’assembleur NASM ? (contribution de Strix Slayer

Il est tout à fait possible d’utiliser l’assembleur NASM pour développer des routines exploitables sous QuickBasic. La mise en œuvre est particulièrement simple. En en-tête de votre fichier source, il vous suffit de spécifier :

[BITS 16]

Aucune autre configuration n’est requise. La déclaration d’une fonction s’effectue tout aussi simplement :

Ma_Fonction:
     .....
         [Votre code assembleur ici]
     .....
     RETF

Il suffit ensuite d’indiquer au compilateur que cette fonction doit être accessible globalement via la directive suivante :

GLOBAL Ma_Fonction

Et le tour est joué !

Seule contrainte syntaxique : la directive GLOBAL Ma_Fonction doit impérativement précéder l’étiquette de la fonction (Ma_Fonction:).

Vous constatez que la mise en œuvre est très accessible.

Pour générer le fichier objet compatible (*.OBJ), exécutez simplement la commande MS-DOS suivante :

NASM monfichier.asm -fobj

Les étapes de liaison ultérieures restent identiques à celles décrites pour TASM.

Voici un court exemple récapitulatif illustrant cette méthode :

Le fichier Toto.asm :

[BITS 16]
GLOBAL Toto
Toto:
    MOV AX, 5
    RETF

Le fichier Toto.bas :

DECLARE FUNCTION Toto%
PRINT Toto%

9- Conclusion :

Ce document vous a présenté les fondements techniques nécessaires pour associer le langage assembleur à QuickBasic et concevoir vos propres bibliothèques d’optimisation.

Vous avez découvert comment transmettre des arguments de type INTEGER ou LONG, déclarer et appeler des fonctions de bas niveau, modifier la valeur d’une variable passée par référence, ou encore optimiser les accès mémoire grâce au passage par valeur avec la directive BYVAL.

Si ce tutoriel vous a accompagné efficacement dans votre apprentissage, n’hésitez pas à m’adresser vos retours d’expérience et d’encouragement par e-mail.

Bonne programmation et à bientôt !

Dans le monde IT, pas mal de leçons ont été tirées depuis le passage désastreux de l’ouragan Sandy.  Les ingénieurs ont compris que la proximité des Data Centers représentait une véritable menace pour la préservation du patrimoine informatique américain. Le danger qui se traduisait par la perte définitive des bases de données était loin d’être fictif.

C’est la raison pour laquelle des projets ont été fraichement lancés en faveur de la construction de plusieurs centres éparpillés  de manière à ce qu’une prochaine catastrophe n’ait aucun véritable impact sur le monde du web.

Lire la suite

Bittorrent est la plus grande platforme de téléchargements P2P. Le partage des fichiers torrents a fait débat pendant des années chez les protecteurs des droits d’auteurs qui ont finit par obtenir gain de cause dans plusieurs pays.

Cela dit, Bittorrent a tout de même obtenu le statut d’un logiciel innocent et clean puisqu’il ne peut deviner le caractère illégal de certains fichiers torrents partagés par des utilisateurs anonymes.

Lire la suite

Gmail prend la vie privée très au sérieux, en redirigeant tous vos courriels indésirables et inutiles dans le dossier spam.

Comme vous, JE DETESTE LES SPAMS 🙂 . Mais si, comme moi, vous souhaitez rediriger TOUS vos emails Gmail vers un autre email (y compris vos spams), il est nécessaire que vos spams soient dans la boite de réception.

Et même si votre but n’est pas de rediriger vos emails, comme les spams sont régulièrement supprimés par Gmail (que vous les ayez lus ou pas), vous pourriez rater un email important.

En effet, Gmail fait souvent des erreurs, en envoyant de VRAIS emails importants, que vous désirez lire, dans les spams. Une fois dans les spams, ils ne seront ni redirigés vers votre email principal, ni lus par vous. Lire la suite

Inutile de vous énerver la prochaine fois que vous tombez sur un répondeur ou une messagerie vocale, car nous vous dévoilons aujourd’hui quelques astuces qui vous feront gagner du temps et de la bonne humeur en allant droit au but.

La messagerie vocale

Ne perdez plus de temps avec les messageries vocales, dès que vous commencerai à écouter la voix du répondeur, appuyez sur #. Cette étape va vous éviter le rituel de la voix automatique et du bip sonore. La touche #  peut être remplacée par * chez d’autres opérateurs. Lire la suite

Si vous voulez tester Ubuntu, sachez d’abord que son lancement peut se faire de plusieurs façons. Pour vous aider donc à faire vos premiers pas dans ce système d’exploitation, nous vous proposons 5 méthodes simples à suivre pour un démarrage sans erreurs et efficace.

Notez aussi que les méthodes proposées sont bien différentes les unes des autres, certaines ne nécessitent même pas d’installation, d’autres peuvent exiger l’exécution d’autres logiciels comme les machines virtuelles. Prenez donc note pour bien choisir la démarche qui vous convient le plus : Lire la suite

Par Aaron Severn (22 décembre 1997)
Traduction par : Asher256 (Octobre 2002)

Introduction

Il est toujours avantageux d’intégrer des routines en langage assembleur dans vos programmes QuickBasic afin d’en optimiser la vitesse d’exécution.

Cela permet également d’appeler directement les interruptions du BIOS ou du DOS, ce qui reste irréalisable en QuickBasic natif.

Ce document n’a pas pour but de vous enseigner l’assembleur (il existe de nombreux tutoriels dédiés à ce sujet), mais plutôt de vous expliquer comment interfacer vos routines de bas niveau avec QuickBasic.

De nombreux développeurs maîtrisent le langage assembleur sans pour autant savoir comment obtenir les opcodes indispensables à l’utilisation de l’instruction CALL ABSOLUTE. Ce tutoriel est conçu pour combler cette lacune.

Utilisation de DEBUG pour générer du code machine

Dans le répertoire des commandes externes de MS-DOS (ou sous le répertoire WINDOWS\COMMAND sous Windows 95/98), vous trouverez un utilitaire nommé DEBUG.EXE.

Lorsque vous l’exécutez, le programme affiche une invite de commande sous la forme d’un simple tiret :

-

Saisissez la commande ‘a’ (pour Assemble) puis appuyez sur Entrée. L’utilitaire affiche alors une adresse mémoire de départ, par exemple :

-a
199D:0100

Vous pouvez dès lors commencer à saisir vos instructions en assembleur. Prenons un cas pratique simple : l’initialisation et l’affichage du curseur de la souris via l’interruption 33h.

Le code assembleur correspondant est le suivant :

PUSH ax
XOR  ax,ax
INT  33
INT  33
MOV  ax,1
INT  33
POP  ax
retf

Saisissez ces instructions ligne par ligne dans DEBUG.

À la fin de votre saisie, validez par une ligne vide (en appuyant directement sur Entrée). Cela indique au programme que vous avez terminé, et vous reviendrez à l’invite de commande principale (le tiret).

Saisissez maintenant la commande ‘u’ (pour Unassemble) afin de désassembler le bloc mémoire. Le code s’affiche alors à l’écran, structuré en plusieurs colonnes.

La première colonne indique l’adresse mémoire de chaque instruction, la deuxième affiche les opcodes en code machine, tandis que les colonnes suivantes d’un point de vue textuel détaillent les instructions assembleur.

La colonne qui nous intéresse pour notre programme QuickBasic est la deuxième. Vous devriez obtenir la suite d’opcodes suivante :

50
31C0
CD33
B80100
CD33
58
CB

Ces valeurs étant exprimées en hexadécimal, il conviendra de leur adjoindre le préfixe &H lors de leur intégration dans votre code QuickBasic.

Une fois les codes notés, vous pouvez quitter l’utilitaire DEBUG en saisissant la commande ‘q’ (pour Quit).

Intégration du code machine dans QuickBasic

Pour exécuter ce code, nous allons faire appel à l’instruction intégrée CALL ABSOLUTE. Les opcodes machine précedemment obtenus doivent être concaténés au sein d’une chaîne de caractères en utilisant la fonction CHR$.

Votre script QuickBasic se structurera de la manière suivante :

DIM asm as STRING

ASM = ASM + CHR$(&H50)
ASM = ASM + CHR$(&H31) + CHR$(&HC0)
ASM = ASM + CHR$(&HCD) + CHR$(&H33)
ASM = ASM + CHR$(&HB8) + CHR$(&H1) + CHR$(&H0)
ASM = ASM + CHR$(&HCD) + CHR$(&H33)
ASM = ASM + CHR$(&H58)
ASM = ASM + CHR$(&HCB)

Il ne reste plus qu’à l’exécuter. Pour ce faire, modifiez le segment par défaut de QuickBasic afin de cibler l’adresse mémorielle de la chaîne de caractères, puis invoquez l’instruction CALL ABSOLUTE en lui transmettant l’offset (adresse relative) obtenu via la fonction SADD.

Ajoutez ces lignes de code pour exécuter le programme de bas niveau :

DEF SEG = VARSEG(ASM)
CALL ABSOLUTE (SADD(ASM))
DEF SEG

Vous disposez désormais de la méthode fondamentale pour lier l’assembleur à QuickBasic. Cependant, un mécanisme indispensable reste à étudier : le passage d’arguments.

Si vous développez une routine plus complexe, telle qu’un tracé de point optimisé, vous devez lui transmettre des variables (les coordonnées X, Y et la couleur). Lorsque vous ajoutez des paramètres à l’instruction CALL ABSOLUTE, QuickBasic les empile de manière séquentielle dans la pile d’exécution (STACK). Pour y accéder depuis votre code assembleur, vous devez initialiser un pointeur de pile stable à l’aide du registre BP, selon la structure suivante :

PUSH bp
MOV bp,sp
.
.      [votre code assembleur ici]
.
POP bp

Le registre BP pointe à présent sur le sommet de la pile. Prenons un exemple où l’appel QuickBasic transmettrait trois arguments :

DEF SEG = VARSEG(ASM)
CALL ABSOLUTE (x, y, colour, SADD(ASM))

Dans cette configuration, l’organisation de la pile (STACK) se présente de la manière suivante :

0A x
08 y
06 colour
04 QBasic retour de l'offset
02 QBasic retour du segment
00 bp (est mis sur le STACK par le code ASM)

Pour lire ou modifier la valeur de x, il vous suffira donc d’accéder à l’adresse relative [bp + 0Ah]. Attention : toute utilisation ultérieure de l’instruction PUSH au sein de votre routine modifiera l’état de la pile.

Par exemple, si vous effectuez un PUSH ax, l’argument x se situera alors à l’adresse [bp + 0Ch]. Un PUSH bx supplémentaire le décalera à l’adresse [bp + 0Eh], et ainsi de suite.

Tutoriel écrit par Asher256
URL: http://qbworld.asher256.com

La plupart des développeurs QuickBasic utilisent la fonction INKEY$, mais son implémentation directe dans plusieurs structures conditionnelles successives pose souvent problème. Pourquoi ?

Voici un exemple d’implémentation déconseillée avec INKEY$ :

DO
        IF INKEY$="a" THEN PRINT "AAAAAAAAAAAA"
        IF INKEY$="b" THEN PRINT "BBBBBBBBBBBB"
        IF INKEY$="c" THEN PRINT "CCCCCCCCCCCC"
        IF INKEY$="d" THEN PRINT "DDDDDDDDDDDD"
LOOP UNTIL INKEY$ = CHR$(27)    ' Quitte si la touche Échap est pressée

Ce code ne fonctionne pas correctement. À chaque appel, la fonction INKEY$ extrait un caractère du tampon clavier (keyboard buffer). Si vous l’invoquez plusieurs fois au cours d’un même cycle de boucle, chaque condition ‘IF’ évalue une valeur différente. Pour résoudre ce problème, il faut affecter le retour de la fonction à une variable unique (par exemple C$) au début de la boucle, puis évaluer cette variable :

DO
        C$ = INKEY$     ' Affectation du caractère à la variable C$

        IF C$="a" THEN PRINT "AAAAAAAAAAAA"
        IF C$="b" THEN PRINT "BBBBBBBBBBBB"
        IF C$="c" THEN PRINT "CCCCCCCCCCCC"
        IF C$="d" THEN PRINT "DDDDDDDDDDDD"
LOOP UNTIL C$ = CHR$(27)    ' Quitte si la touche Échap est pressée

Désormais, le traitement s’exécute de manière cohérente.

Si vous souhaitez prendre en compte les caractères en majuscules et en minuscules sans dupliquer vos structures conditionnelles (par exemple éviter d’écrire systématiquement ‘IF C$ = « a » OR C$ = « A »‘), vous pouvez utiliser la fonction LCASE$. Celle-ci convertit une chaîne de caractères en minuscules. Il suffit alors de l’appliquer à votre variable lors du test :

IF LCASE$(c$) = "a" THEN (...)

Les touches directionnelles

Dans le cadre du développement d’un jeu vidéo, la gestion des déplacements se fait généralement via les touches directionnelles du clavier plutôt que par des touches alphabétiques.

La détection d’une touche directionnelle via INKEY$ renvoie une chaîne de deux caractères. Le premier est un caractère nul, CHR$(0), indiquant une touche étendue, et le second correspond au code de balayage (scan code) de la touche.

La syntaxe s’établit comme suit :

CHR$(0) + CHR$(code_de_balayage)

Voici un exemple d’implémentation :

DO
        C$ = INKEY$
        IF c$ = CHR$(0) + CHR$(72) THEN PRINT "Flèche haut..."
        IF c$ = CHR$(0) + CHR$(80) THEN PRINT "Flèche bas..."
        IF c$ = CHR$(0) + CHR$(75) THEN PRINT "Flèche gauche..."
        IF c$ = CHR$(0) + CHR$(77) THEN PRINT "Flèche droite..."
LOOP UNTIL C$ = CHR$(27)
END

Note : Le préfixe CHR$(0) est indispensable pour identifier les codes étendus.

(article invité écrit par Noel)

L’iPhone est le téléphone mobile le plus utilisé par les hommes d’affaires aux États-Unis. Son plus grand rival, le BlackBerry, comporte lui aussi des fonctions similaires et aussi efficaces. Que ce soit l’IPhone 2, 3 ou même 4, la majorité de ces téléphones ont des avantages et inconvénients qui motivent ou découragent les utilisateurs…

Découvrons ensemble ces avantages et inconvénients…
Lire la suite

Tutoriel écrit par : Tom Rathbone le 23/08/1999
Traduit en français par : Asher256 (Septembre 2002)

J’ai reçu de nombreux e-mails de personnes me demandant des routines 3D pour QuickBasic. Plutôt que de répondre individuellement, j’ai décidé d’écrire ce tutoriel afin d’en faire profiter le plus grand nombre.

Ce document constitue un excellent point de départ pour quiconque souhaite s’initier à la création d’effets graphiques 3D en QuickBasic. J’espère également qu’il facilitera la compréhension des concepts mathématiques sous-jacents, car il est indispensable de maîtriser ces notions pour exploiter efficacement ces routines.

Dans ce premier volet, j’expliquerai comment projeter des points de l’espace 3D vers un plan 2D à l’aide d’un algorithme simple. Je fournirai également une routine permettant d’effectuer des rotations de points dans l’espace 3D.

Convertir une coordonnée 3D en 2D

Une coordonnée 3D se présente sous la forme (X, Y, Z). Cependant, pour restituer ce point sur un écran bidimensionnel, nous devons prendre en compte sa profondeur relative par rapport à la surface d’affichage.

Les équations permettant de projeter ces points découlent de principes trigonométriques simples. Ce tutoriel s’appuyant sur la trigonométrie, si ces notions vous sont totalement inconnues, je vous conseille vivement d’emprunter quelques ouvrages de mathématiques pour vous y familiariser.

Voici les formules de projection :

X2D = 256 * (X3D / (Z3D + Zoffset)) + Xoffset
Y2D = 256 * (Y3D / (Z3D + Zoffset)) + Yoffset

Les valeurs de décalage (offsets) dépendent des dimensions de votre écran.

Bien entendu, manipuler ces équations manuellement à chaque affichage de point serait fastidieux. Je vous conseille donc d’encapsuler cet algorithme de projection dans une routine réutilisable. Idéalement, nous pouvons intégrer directement cette conversion dans nos fonctions d’affichage globales (SUB), ce qui permet d’effectuer la projection et le tracé en un seul appel.

Une routine 3D PSET

Implémentation de la routine XPSET :

DECLARE SUB XPSET (x3d!,y3d!,z3d!,col%)

SUB XPSET (x3d!, y3d!, z3d!,col%)
      zoom = 200
      depth = 40
      x2d% = zoom * (x3d! / (z3d! + depth)) + 160
      y2d% = zoom * (y3d! / (z3d! + depth)) + 100
      PSET (x2d%, y2d%), col%
END SUB

Note : Vous pouvez ajuster les variables de zoom et de profondeur (depth) afin de les adapter à vos propres modèles 3D.

Attention : Si la coordonnée de profondeur (z3d!) est inférieure ou égale à l’inverse de la constante de profondeur (par exemple -40 dans notre cas), vous provoquerez une division par zéro, entraînant le plantage du programme. Nous verrons plus tard comment implémenter un test de validation pour contourner ce problème.

Au fil de cette série de tutoriels, nous bâtirons une bibliothèque complète de sous-programmes de ce type, que vous pourrez intégrer librement dans vos productions.

Afficher les coins d’un cube

Appliquons à présent notre nouvelle routine pour tracer les sommets d’un cube de couleur rouge.

SCREEN 13
DECLARE SUB XPSET (x3d!,y3d!,z3d!,col%)
XPSET 10,10,10,4
XPSET 10,10,-10,4
XPSET 10,-10,-10,4
XPSET -10,-10,-10,4
XPSET -10,-10,10,4
XPSET -10,10,10,4
XPSET -10,10,-10,4
XPSET 10,-10,10,4
END

La valeur fixe 10 peut bien évidemment être remplacée par une variable.

Exercice pratique : Essayez de faire évoluer ce programme en introduisant une variable pour définir la taille du cube, ainsi que trois variables de translation pour gérer ses déplacements sur les axes X, Y et Z.

Les rotations

Il existe trois axes de rotation possibles pour faire pivoter un objet dans l’espace 3D : les axes X, Y et Z. Cela signifie que nous devons appliquer trois transformations distinctes pour calculer nos nouvelles coordonnées.

Pour faire pivoter une coordonnée 2D d’un angle ‘a’, nous utilisons le produit matriciel suivant :

[x] * [ cos(a)  -sin(a) ] = [x2]
[y] * [ sin(a)   cos(a) ] = [y2]

où x et y sont les coordonnées initiales, x2 et y2 sont les nouvelles coordonnées, et ‘a’ est l’angle de rotation exprimé en radians.

Note sur les radians : Pour ceux qui l’ignorent, un tour complet (360 degrés) équivaut à 2 * PI radians (soit environ 6,283 radians). Vous pouvez convertir des degrés en radians à l’aide de la formule suivante : r = (d / 360) * 2 * PI (où d représente les degrés, r les radians, et PI la constante valant environ 3,142).

Si vous ne comprenez pas parfaitement ces concepts théoriques, ne vous inquiétez pas. Voici l’implémentation correspondante en QuickBasic :

x2 = (x * COS(rotZ!)) - (y * SIN(rotZ!))
y2 = (x * SIN(rotZ!)) + (y * COS(rotZ!))

Ces lignes effectuent la rotation de n’importe quel point autour de l’axe Z, l’angle rotZ! étant exprimé en radians. Maintenant que nous avons la formule pour le premier axe, voici celles pour les deux autres :

X3 = (x2 * COS(rotY!)) - (z * SIN(rotY!))
Z2 = (x2 * SIN(rotY!)) + (z * COS(rotY!))

Y3 = (y2 * COS(rotX!)) - (Z2 * SIN(rotX!))
Z3 = (y2 * SIN(rotX!)) + (Z2 * COS(rotX!))

En injectant les coordonnées initiales X, Y et Z dans ces blocs d’équations, nous obtenons les coordonnées finales transformées X3, Y3 et Z3.

Deux approches logicielles s’offrent à nous : concevoir une fonction dédiée qui retourne les coordonnées calculées, ou intégrer ces calculs directement au sein de nos routines d’affichage.

Bien que les deux approches présentent des avantages, la seconde option s’avère souvent plus efficace à l’exécution. Appliquons ces transformations à la routine XPSET développée dans le premier tutoriel pour créer une nouvelle procédure nommée XRPSET.

Ajoutez la déclaration suivante dans votre module principal :

DECLARE SUB XRPSET (x3d!,y3d!,z3d!,rotx!,roty!,rotz!,col%)

Créez ensuite la routine correspondante :

SUB XRPSET (x3d!, y3d!, z3d!,rotx!,roty!,rotz!,col%)
        zoom = 200
	depth = 40
	x2! = (x3d! * COS(rotZ!)) - (y3d! * SIN(rotZ!))
	y2! = (x3d! * SIN(rotZ!)) + (y3d! * COS(rotZ!))
	x3! = (x2! * COS(rotY!)) - (z3d! * SIN(rotY!))
	z2! = (x2! * SIN(rotY!)) + (z3d! * COS(rotY!))
	y3! = (y2! * COS(rotX!)) - (z2! * SIN(rotX!))
	z3! = (y2! * SIN(rotX!)) + (z2! * COS(rotX!))
	x2d% = zoom * (x3! / (z3! + depth)) + 160
        y2d% = zoom * (y3! / (z3! + depth)) + 100
        PSET (x2d%, y2d%), col%
END SUB

Utilisation de la routine

Reprenez l’exemple du cube présenté dans le premier tutoriel et remplacez les appels à XPSET par XRPSET.

Par exemple:

XPSET 10,10,10,4

Devient:

XRPSET 10,10,10,rotx!,roty!,rotz!,4

Modifiez dynamiquement les variables de rotation pour observer le cube pivoter dans l’espace.

L’anticrénelage

L’anticrénelage (anti-aliasing) est une technique utile pour travailler dans des résolutions basses comme le mode SCREEN 13. Elle permet d’obtenir des animations nettement plus fluides. Prenons l’exemple d’un champ d’étoiles (starfield) : en raison de la taille des pixels en mode SCREEN 13, les déplacements et les transitions peuvent sembler saccadés.

Nous devons trouver un moyen d’afficher des éléments graphiques à des coordonnées intermédiaires, situées entre deux pixels entiers. La solution consiste à calculer la contribution lumineuse du point sur les quatre pixels adjacents qu’il chevauche. L’intensité lumineuse attribuée à chaque pixel est directement proportionnelle à la surface couverte. Si ces explications théoriques vous semblent abstraites, vous pouvez en observer le rendu concret dans la démonstration 3D de vagues disponible sur mon site web.

N.B. L’anticrénelage ne fonctionne qu’après la configuration d’une palette de dégradés. J’expliquerai en détail l’utilisation de l’instruction PALETTE dans un prochain tutoriel, mais vous pouvez utiliser le code suivant pour initialiser un dégradé en mode SCREEN 13 :

FOR p = 1 TO 63
PALETTE p, p + 256 * p + 65536 * p
NEXT

Les indices de couleur de 1 à 63 forment désormais un dégradé de niveaux de gris parfait.

La routine d’anticrénelage :

SUB aaset (x!, y!, c%)
X1% = FIX(x!)
Y1% = FIX(y!)
x2% = x1% + 1
y2% = y1% + 1
xm! = x! - x1%
ym! = y! - y1%
c1% = (1 - xm!) * (1 - ym!) * c%
c2% = xm! * (1 - ym!) * c%
c3% = (1 - xm!) * ym! * c%
c4% = xm! * ym! * c%
PSET (x1%, y1%), c1%
PSET (x2%, y1%), c2%
PSET (x1%, y2%), c3%
PSET (x2%, y2%), c4%
END SUB

Fluidité des animations

Une première méthode consiste à synchroniser le rendu avec le balayage vertical du moniteur (V-Sync) avant de dessiner ou d’effacer l’écran. Pour cela, utilisez l’instruction suivante :

WAIT &H3DA, 8

Une autre approche repose sur l’utilisation d’un tampon d’affichage (double buffering), un mécanisme similaire aux tampons masqués de la bibliothèque DirectQB. Voyons comment exploiter simplement l’instruction PCOPY native de QuickBasic.

Cette fonctionnalité est restreinte au mode SCREEN 9, ce qui limite l’affichage à 16 couleurs pour une résolution de 640×480 pixels. Initialisez le mode graphique de la manière suivante :

SCREEN 9,0,1,0

Grâce à cette configuration, toutes les instructions de tracé graphique et textuel s’exécutent en arrière-plan sur la page mémoire 1, tandis que le moniteur affiche le contenu stable de la page 0. Une fois l’intégralité du dessin finalisée sur la page masquée, il suffit de copier la page 1 vers la page 0 pour afficher instantanément l’image complète à l’écran.

Lorsque votre calcul de trame est terminé, utilisez la commande suivante pour basculer l’affichage :

PCOPY 1,0

Lorsque vous vous connectez sur Internet via un Wifi publique ou un cyber-café, n’importe quelle personne faisant partie du réseau pourrait sniffer vos logins et mots de passes, envoyés en clair (en clair = sites qui ne sont pas en https), avec un logiciel comme Ettercap.

Vous ne risquez rien avec Gmail, Facebook et les autres sites, car ils sont en https, mais beaucoup d’autres ne le sont pas (cela pourrait être un phpmyadmin, dans votre serveur ne contenant pas de https par exemple).

Pour que les informations qui transitent sur Internet soient sécurisées, il est nécessaire de passer par un tunnel chiffré, comme un VPN ou un proxy SSH Socks.

Dans cet article, vous allez découvrir comment transformer un simple serveur SSH en proxy socks, grâce au logiciel Putty sous Windows.

Grâce au proxy socks, toutes vos communications avec les sites http passeront par un tunnel SSH chiffré, invisibles aux pirates qui sniffent dans le réseau local ! Suivez le guide : Lire la suite

DirectQB ou Future Library? Quelle librairie choisir et comment l’installer ?

Que choisir?

FutureLib est une bibliothèque très complète car elle prend en charge les modes graphiques VESA avec des résolutions allant jusqu’à 1024×768 en 16 millions de couleurs. Le large choix de modes disponibles la rend particulièrement attractive. Cependant, il ne faut pas occulter le revers de la médaille. En raison de la grande variété de modes supportés et du fait que de nombreuses routines de FutureLib sont écrites en QuickBasic « Haut niveau », cette bibliothèque s’avère parfois plus lente que DirectQB. Il est donc nécessaire de disposer d’une configuration matérielle véloce pour que vos programmes fonctionnent et que les animations restent fluides (particulièrement dans des résolutions élevées telles que le 800×600 en 24 bits).

DirectQB est une bibliothèque intégralement développée en langage assembleur. Elle offre d’excellentes performances en matière de rapidité, mais ne prend en charge qu’un seul mode graphique (le mode 13h, SCREEN 13, 320×200 en 256 couleurs). Malgré cette limitation, elle rencontre un franc succès auprès des développeurs. Selon un sondage réalisé en 2000, environ 65% des jeux QuickBasic sont conçus avec DirectQB, contre seulement 35% pour FutureLib.

Il convient de préciser que les routines de rendu 3D (polygones), 2D (sprites) et audio (WAV) restent tout à fait comparables entre FutureLib et DirectQB. Comme vous pouvez le constater, ces deux solutions possèdent chacune leurs propres avantages et inconvénients.

Installer DirectQB

• Site officiel: http://www.ecplusplus.com

Procédure d’installation

1. Ouvrez le fichier dqbman.bas à l’aide de la commande suivante :

qb.exe /l qb.qlb dqbman.bas

2. Sélectionnez les modules (graphismes, son, images…) dont vous avez besoin.
3. Validez avec la touche Entrée et spécifiez le chemin d’accès de votre environnement QuickBasic (par exemple : c:\qb45), puis validez de nouveau.

Une barre de progression s’affiche à l’écran. Une fois l’opération terminée, vous obtiendrez les trois fichiers suivants : dqb.lib, dqb.qlb et directqb.bi. Copiez-les dans le répertoire de votre QuickBasic.

Détail des fichiers générés

• dqb.lib : Bibliothèque requise pour compiler vos programmes DirectQB en *.exe.
• dqb.qlb : Bibliothèque requise pour interpréter vos programmes DirectQB au sein de l’EDI de QuickBasic 4.5.
• directqb.bi : Fichier d’inclusion contenant les déclarations des routines et des constantes. ATTENTION : il doit impérativement être inclus au début de votre code source.

Utilisation dans un projet

Pour développer un programme avec DirectQB, vous devez charger la bibliothèque dqb.qlb lors du lancement de QuickBasic via l’option /l :

qb.exe /l dqb.qlb programme.bas

Vous devez ensuite inclure le fichier directqb.bi au tout début de votre script *.bas :

REM $include: 'directqb.bi'

Vous pouvez désormais concevoir vos propres jeux vidéo en QuickBasic avec DirectQB.

Installer Future Library

• Site officiel: http://www.qb45.com

Procédure d’installation

1. Exécutez l’utilitaire flbuild.exe.
2. Dans le menu principal, accédez à : setup->program.
3. Dans les champs qbasic 4.5, compiler path et library path, saisissez le chemin d’accès où se trouve QuickBasic 4.5 (par exemple : c:\qb45), puis validez en cliquant sur OK.
4. Enfin, sélectionnez l’option : File->Build Qbasic 4.5 Library.

Vous obtiendrez les fichiers future45.lib, future45.qlb et future.bi. Copiez-les dans le répertoire de votre QuickBasic.

Détail des fichiers générés

• future45.lib : Bibliothèque requise pour compiler vos programmes FutureLib en *.EXE.
• future45.qlb : Bibliothèque requise pour interpréter vos programmes FutureLib au sein de l’EDI de QuickBasic 4.5.
• future.bi : Fichier d’inclusion contenant les déclarations des routines et des constantes. ATTENTION : il doit impérativement être inclus au début de votre code source.

Utilisation dans un projet

Pour développer un programme avec FutureLib, vous devez charger la bibliothèque future45.qlb lors du lancement de QuickBasic :

qb.exe /l future45.qlb programme.bas

Vous devez également inclure le fichier future.bi au début de votre programme :

REM $include: 'future.bi'

Vous pouvez désormais développer vos propres applications QuickBasic à l’aide de Future Library.

Rapid Tic Tac Toe est le premier jeu que j’ai développé en 2001 capable d’offrir un véritable défi à un joueur humain.

Le Tic Tac Toe, également connu sous le nom de Morpion, est un jeu de réflexion pour deux joueurs se déroulant sur une grille de 3 × 3 cases. Les participants jouent à tour de rôle en plaçant leur symbole (X ou O) dans une case libre. L’objectif est d’aligner trois symboles identiques horizontalement, verticalement ou en diagonale. Le premier joueur qui réussit cet alignement remporte la partie. Si toutes les cases sont occupées sans qu’aucun alignement ne soit réalisé, la partie se termine par un match nul. Simple à comprendre mais stratégique dans sa mise en pratique, le Tic Tac Toe est un jeu apprécié par les joueurs de tous âges.

Si vous débutez ou manquez d’expérience, il y a de fortes chances que l’ordinateur l’emporte. Si vous maîtrisez bien le jeu, vous obtiendrez probablement un match nul. En revanche, si vous parvenez à gagner, n’hésitez pas à me contacter pour m’expliquer votre stratégie. Vos retours me permettront d’améliorer davantage l’algorithme.

TÉLÉCHARGER : rapid-tictactoe.zip

(Ce projet est également disponible dans le dépôt GitHub : Asher256/asher256-legacy.)

Écrit par Asher256, en Septembre 2001
URL: http://qbworld.asher256.com

Ce tutoriel vous enseignera les techniques pour optimiser votre code QuickBasic.

Les routines PSET et POINT : des performances limitées

Avant toute chose, évitez d’utiliser les modes graphiques SCREEN 7 ou SCREEN 12, qui sont aujourd’hui obsolètes. Privilégiez le mode SCREEN 13 (résolution de 320×200 pixels en 256 couleurs).

Les routines PSET natives de QuickBasic manquent d’efficacité. Si vous tentez de simuler un effacement d’écran (CLS) en redessinant chaque point avec PSET, l’affichage se fera pixel par pixel de manière très lente.

Exemple illustrant la lenteur de la routine PSET :

DEFINT A-Z:SCREEN 13
t! = TIMER

FOR c = 1 TO 10         ' Changement de couleur
        FOR y = 0 TO 199
                FOR x = 0 TO 319
                        PSET (x,y),c+50
                NEXT
        NEXT
NEXT

A$ = INPUT$(1)

SCREEN 0 : WIDTH 80
PRINT "Temps d'affichage : "; TIMER - t!; " secondes."

Voici une approche alternative bien plus performante utilisant les accès mémoire :

DEFINT A-Z              ' Utilisation systématique des INTEGER pour la rapidité
DIM offset AS LONG      ' Type LONG car l'adresse de l'offset dépasse 32767
SCREEN 13

DEF SEG = &HA000        ' Pointage du segment de la mémoire vidéo
t! = TIMER
FOR c = 1 TO 3          ' Changement de couleur
        FOR offset = 0 TO 63999
                POKE offset, c
        NEXT
NEXT
DEF SEG                 ' Restauration du segment par défaut de QuickBasic
A$ = INPUT$(1)

SCREEN 0 : WIDTH 80
PRINT "Temps d'affichage : "; TIMER - t!; " secondes."

Sur un processeur Pentium à 100 MHz, le premier exemple requiert environ 3,6 secondes pour vider l’écran, tandis que le second n’a besoin que de 0,8 seconde. Une fois le code source compilé en binaire autonome (*.EXE), l’exécution devient quasi instantanée (moins de 0,2 seconde).

Pourquoi la routine PSET de QuickBasic est-elle si lente ? C’est parce qu’elle effectue de nombreuses vérifications en arrière-plan : validation de la résolution active, détermination du format d’affichage et vérification du nombre maximal de couleurs (2, 16, 256, etc.). Cette surcharge logicielle propre aux instructions de haut niveau pénalise les performances. Pour contourner cela, il est possible d’intégrer du code assembleur via l’instruction CALL ABSOLUTE ou en liant directement des modules objets gérés par TASM ou MASM au format *.QLB.

Analysons à présent le fonctionnement technique de notre effacement d’écran via la commande POKE. Le tampon vidéo (framebuffer) est localisé à l’adresse mémoire &HA000:0000. La valeur &HA000 représente le segment, que l’on sélectionne à l’aide de l’instruction DEF SEG. L’offset (l’adresse relative) commence à 0 et se termine à 63999. L’écran en mode SCREEN 13 comptant 320×200 pixels, cela représente un total de 64000 emplacements distincts. L’indexation débutant à 0, la dernière adresse est naturellement égale à 64000 – 1, soit 63999.

Pour afficher un point isolé à l’écran, il faut calculer son offset précis à l’aide d’une formule simple : multiplier la coordonnée Y par la résolution horizontale de l’écran (320), puis y ajouter la coordonnée X. Voici l’implémentation de cette routine :

DEFINT A-Z      ' Utilisation des INTEGER pour optimiser les calculs
SUB Opset (x AS INTEGER,y AS INTEGER,couleur AS INTEGER)

        DIM offset AS LONG      ' L'offset pouvant dépasser 32767, le type LONG est requis
        DEF SEG = &HA000        ' Pointage du segment de la mémoire vidéo

        offset = x + (y * 320)  ' Calcul de l'adresse relative via la formule
        POKE offset, couleur    ' Écriture directe de la couleur en mémoire

        DEF SEG                 ' Restauration du segment par défaut de QuickBasic
END SUB

Après avoir intégré cette procédure (SUB) dans votre fichier *.BAS, vous pouvez l’invoquer ainsi :

Opset 100,100,15

Un pixel s’affichera aux coordonnées spécifiées. Vous disposez maintenant d’un équivalent rapide à PSET pour le mode SCREEN 13.

Bien que l’opération x + (y * 320) soit efficace, elle peut s’avérer insuffisante pour les exigences d’un moteur de jeu vidéo en temps réel. Pour atteindre des performances optimales, il est recommandé de transcrire cette routine en langage assembleur.

Il existe d’ailleurs une astuce pour optimiser l’opération y * 320 en remplaçant l’instruction de multiplication (MUL), relativement lourde, par des décalages de bits vers la gauche (SHL).

Le nombre 320 n’étant pas une puissance de 2, l’astuce consiste à décomposer la multiplication :

MOV AX, y        ; Chargement de la coordonnée Y dans AX
MOV BX, ax       ; Duplication de Y dans BX
SHL BX,6         ; Multiplie BX par 64  (2^6)
SHL AX,8         ; Multiplie AX par 256 (2^8)
ADD AX, BX       ; AX = (Y * 256) + (Y * 64) = Y * 320
MOV BX, x        ; Chargement de la coordonnée X dans BX
ADD AX, BX       ; AX = (Y * 320) + X (L'offset final est dans AX)
                 ; Il ne reste plus qu'à configurer le registre ES

Puisque 320 équivaut à 256 + 64, cette décomposition est tout à fait exacte. Prenons un exemple concret :

offset = 4 + (2 * 320)
       = 4 + 640
       = 644

Appliquons la méthode par décalage de bits (SHL) :

offset = 4 + (2 * 256) + (2 * 64)
       = 4 + 512 + 128
       = 644

Le résultat est strictement identique, mais l’utilisation de l’instruction SHL permet d’économiser des cycles processeur précieux par rapport à l’instruction MUL, dont l’exécution matérielle reste plus longue.

Pour remplacer l’instruction POINT de QuickBasic (qui lit la couleur d’un pixel à l’écran), vous pouvez appliquer la même formule de calcul d’offset associée à l’instruction PEEK : « couleur = PEEK(offset) ».

Ces routines d’optimisation de bas niveau s’avèrent indispensables pour concevoir des algorithmes rapides de tracés de lignes, de cercles, ou pour développer une routine d’affichage de sprites (PUT) performante. Si vous débutez, l’utilisation de l’instruction POKE en QuickBasic offre déjà un excellent compromis, bien que rien ne puisse égaler la vélocité pure d’un code écrit en assembleur.

Le choix des types de variables : SINGLE, LONG, INTEGER, DOUBLE

Une question essentielle se pose lors de la phase de conception : quel type de variable privilégier pour optimiser la rapidité d’exécution ?

Sachez qu’il faut impérativement bannir l’usage des types à virgule flottante tels que SINGLE ou DOUBLE au sein de vos boucles critiques, sous peine de ralentir considérablement votre application.

Utilisez prioritairement le type INTEGER. Stocké sur 2 octets, il s’avère simple et extrêmement rapide à traiter par le processeur. Le type LONG (4 octets) ne doit être mobilisé que lorsque vos valeurs risquent de dépasser la limite supérieure des entiers signés (32767). Dans le cadre du développement de jeux vidéo standard sur cette plateforme, vos coordonnées et indices dépasseront rarement ce seuil.

Pour forcer l’interprétation de toutes vos variables non déclarées en tant qu’INTEGER par défaut, il vous suffit de placer cette directive au tout début de votre code source :

DEFINT A-Z

Cet article propose un recensement exhaustif des productions de la scène francophone QuickBasic diffusées par le portail QBWorld entre 2000 et 2006. Cette compilation regroupe l’intégralité des ressources répertoriées dans le code source original du site, incluant les tutoriels destinés aux débutants comme aux utilisateurs avancés, les utilitaires de développement, les bibliothèques graphiques et sonores en assembleur, ainsi que l’ensemble des jeux et mini-programmes.

Jeux

Flying War

• Auteur : Asher256
• Taille : 28 Ko
• Liens de référence : Fichier de téléchargement
• Description : Dans ce jeu en ASCII, vous vous retrouvez à bord d’une fusée spatiale ayant perdu le contrôle au milieu de l’immensité de l’espace ! Votre objectif est de manœuvrer l’appareil en utilisant les touches directionnelles pour vous déplacer vers la gauche et la droite.

MisterKid

• Auteur : Asher256
• Taille : 239 Ko
• Liens de référence : Fichier de téléchargement
• Description : Très apprécié par de nombreux programmeurs QBasic, MisterKid a été une véritable réussite sur la scène francophone et anglophone au cours de l’année 2001. Il contient 5 mondes et 12 stages à découvrir, tous regorgeant de monstres qui n’ont qu’un seul objectif : vous éliminer ! Côté technique, MisterKid utilise DirectQB pour l’affichage et la bibliothèque FmLib pour les effets sonores (FX) et les musiques (FMS).
  (BAS,EXE)

Le Bon Compte 3

• Auteur : Georges Thoral
• Taille : 258 Ko
• Liens de référence : Fichier de téléchargement
• Description : Nouvelle version du Bon Compte, un jeu inspiré du célèbre programme télévisé Des chiffres et des lettres. De nombreuses améliorations sont au rendez-vous.
  (EXE,BAS)

Labyrinthe

• Auteur : Pawlowski Jeremy
• Taille : 231 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un labyrinthe en 3D très bien réalisé où vous pouvez rencontrer des personnages et des monstres. Le but est de vaincre le Comte puis de sortir sain et sauf.

Mastermind Thoral

• Auteur : Georges Thoral
• Taille : 178 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un clone du célèbre jeu Mastermind.
  (EXE,BAS)

Dinosaure

• Auteur : Timothée Naux
• Taille : 102 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un jeu de plateforme proche de QBS-Mario ! Cette fois-ci, c’est un dragon qui incarne le héros et doit naviguer dans un monde truffé d’obstacles. J’encourage vivement son auteur à continuer, car c’est un très bon début !
  (EXE)

EyeBall

• Auteur : Badjas productions
• Taille : 321 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un jeu où vous contrôlez des extraterrestres qui jouent au volley-ball. Ce titre comporte de superbes graphismes et de magnifiques effets spéciaux. Côté technique, il utilise la bibliothèque DirectQB pour les graphismes et QMidi pour la gestion des fichiers MIDI.

Orion

• Auteur : Laurent Vanaerde
• Taille : 40 Ko
• Liens de référence : Fichier de téléchargement
• Description : Vous pilotez une fusée qui doit détruire tout ce qui bouge à l’écran.
  (EXE,BAS)

Hacked Nibbles

• Auteur : Endorphin
• Taille : 54 Ko
• Liens de référence : Fichier de téléchargement
• Description : La version modifiée (hackée) du célèbre jeu Nibbles (le serpent) fourni historiquement par Microsoft.
  (EXE,BAS)

Morpion

• Auteur : Laurent Vanaerde
• Taille : 38 Ko
• Liens de référence : Fichier de téléchargement
• Description : Le jeu du morpion. Bien que graphiquement minimaliste et sans support de la souris, l’intelligence artificielle est bien conçue.
  (EXE,BAS)

QBTetris

• Auteur : JeffKey
• Taille : 53 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un clone de Tetris développé en QBasic !
  (EXE,BAS)

Cookie Delivery

• Auteur : JAWS V-Soft
• Taille : 133 Ko
• Liens de référence : Fichier de téléchargement
• Description : Développé par le créateur de Mini RPG. Dans chaque niveau, vous devez briser des paquets au marteau tout en évitant les monstres. C’est un bon divertissement malgré des graphismes passables.
  (EXE,BAS)

Space Commando II

• Auteur : TopGun Software
• Taille : 252 Ko
• Liens de référence : Fichier de téléchargement
• Description : Vous incarnez un commando qui doit éliminer des extraterrestres verts. Un jeu réussi qui intègre des scrollings multidirectionnels, des systèmes de particules et divers monstres. Le buffer d’affichage reste cependant un peu étroit, une concession inévitable face aux limitations techniques de la mémoire conventionnelle.
  (EXE)

Super Stack

• Auteur : Oren Bartal
• Taille : 234 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un jeu vidéo particulièrement réussi ! Dans la lignée de Tetris, ce titre de réflexion s’avère aussi soigné graphiquement qu’agréable à jouer. Un incontournable à ne pas rater. Côté technique, le programme s’appuie sur DirectQB pour l’affichage.

Sonic-Xtreme V7

• Auteur : Prodigy 2000
• Taille : 585 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un clone de Sonic en QBasic. On ne peut pas le qualifier de copie conforme du titre original de SEGA, car le projet souffre de graphismes perfectibles, d’une gestion approximative des collisions et de déplacements imprécis.

MiniRPG II

• Auteur : JAWS-V Soft
• Taille : 87 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un petit jeu de rôle humoristique. Vous incarnez un personnage qui fuit une prétendante déterminée à l’épouser à tout prix. Le style visuel est très inspiré de l’univers des mangas.
  (BAS)

Promzone

• Auteur : SV Reanimator
• Taille : 412 Ko
• Liens de référence : Fichier de téléchargement
• Description : Vous incarnez un cambrioleur qui doit se déplacer furtivement, trouver des clés, déverrouiller des portes et neutraliser des policiers. Le titre bénéficie de graphismes soignés pour le genre et d’une ambiance sonore dynamique. Côté technique, Promzone exploite DirectQB pour l’affichage et les effets sonores, ainsi que QMidi pour la musique de fond.
  (BAS,EXE)

Wetspot 2

• Auteur : Angelo Mottola
• Taille : 390 Ko
• Liens de référence : Fichier de téléchargement
• Description : La suite de Wetspot 1 sorti en 1996. Un jeu d’arcade au principe simple : vous contrôlez un crabe qui doit éliminer tous les monstres présents à l’écran. Pour ce faire, il suffit de pousser des blocs pour les projeter sur vos ennemis. Côté technique, Wetspot 2 utilise QMidi pour les musiques (.mid), DMAPLAY pour les fichiers audio (.wav) et la bibliothèque BlastLib pour la partie graphique.
  (EXE)

Cyclone

• Auteur : SV Reanimator
• Taille : 218 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un excellent jeu d’hélicoptère doté de beaux graphismes et d’effets environnementaux réalistes (lumière, eau, pluie). L’objectif est de secourir des civils. Côté technique, Cyclone utilise DirectQB pour l’affichage et les effets sonores.
  (BAS,EXE)

Little Pixy II

• Auteur : TMB Productions
• Taille : 338 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un jeu de plateforme très attachant. Vous incarnez le Père Noël (ou son fils) et devez collecter des objets pour valider les différents niveaux. Le gameplay peut toutefois s’avérer répétitif à long terme. Côté technique, les graphismes ont été conçus sous PaintShop Pro et la gestion de la mémoire étendue s’effectue via XMS Handler.
  (EXE)

Utilitaires

FmSong

• Auteur : Asher256
• Taille : ~138 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un tracker permettant de composer des musiques au format FMS pour les intégrer directement dans vos productions QBasic. J’ai notamment conçu les musiques de MisterKid avec cet outil. Les morceaux peuvent être chargés en code source grâce à la bibliothèque FmLib. Côté technique, FmSong nécessite une carte AdLib ou Sound Blaster 100 % compatible.

Sprites Util

• Auteur : Hilaire Tomas
• Taille : 208 Ko
• Liens de référence : Fichier de téléchargement
• Description : Utilitaire facilitant la manipulation de sprites en mode SCREEN 12 (640×480, 16 couleurs). Le package inclut plusieurs démonstrations techniques.
  (BAS,EXE)

QBFTP

• Auteur : Maxime Cheramy
• Taille : 4 Ko
• Liens de référence : Fichier de téléchargement
• Description : Outil pour transférer vos fichiers vers votre serveur d’hébergement. Il s’appuie sur le programme ftp.exe fourni nativement avec Windows. Personnellement, je l’utilise pour mettre à jour mon site internet !

CreaPal

• Auteur : Dark Lanfeust
• Taille : 34 Ko
• Liens de référence : Fichier de téléchargement
• Description : Utilitaire permettant de générer vos propres palettes de couleurs standards ou avec des effets de dégradés.

Menu

• Auteur : Anonyme
• Taille : 5,06 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un petit utilitaire distribué avec son code source, permettant d’ajouter des menus interactifs en mode texte dans vos propres applications.

PCX2BSV

• Auteur : Arf Enterprises
• Taille : 21 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un convertisseur pour transformer un fichier image PCX au format BSAVE de QBasic. Ce programme est distribué sous licence shareware (évalué à 5 $).

GIF2BSV

• Auteur : James Kurth
• Taille : 2 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un convertisseur pour transformer un fichier image GIF au format BSAVE de QBasic.

QMidi 4.1

• Auteur : Jesse Dorland
• Taille : 135 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un code source (.BAS) indispensable si vous souhaitez jouer des fichiers MIDI sous l’environnement QBasic. Ce dossier regroupe le code à inclure ainsi que le fichier d’aide qmidi.doc détaillant les fonctions d’appel.

CPut 1.0

• Auteur : Der Linden
• Taille : 6 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une routine permettant d’afficher un sprite via la commande PUT lorsqu’il dépasse des limites physiques de l’écran, évitant ainsi un plantage de QBasic. Par exemple, il devient possible d’afficher un sprite de 20×20 pixels en coordonnées (320, 100) sur un écran de 320×200 sans générer d’erreur de débordement.

SoundLab

• Auteur : Angelo Mottola
• Taille : 21 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un outil de création d’effets sonores (FX) accompagné d’un fichier d’exemple .BAS pour charger et exécuter vos créations.

USplit

• Auteur : Asher256
• Taille : 44 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un programme utilitaire pratique servant à segmenter les fichiers volumineux en plusieurs morceaux, facilitant par exemple leur stockage sur une série de disquettes.

Mouse

• Auteur : Anonyme
• Taille : 1 Ko
• Liens de référence : Fichier de téléchargement
• Description : Code d’intégration permettant d’exploiter les mouvements et les clics de la souris dans une application QBasic.

Loading Jasc palette

• Auteur : Lord Agnathian
• Taille : 1 Ko
• Liens de référence : Fichier de téléchargement
• Description : Routine permettant d’importer directement les fichiers de palettes de couleurs (.PAL) générés par Jasc PaintShop Pro.

Fade

• Auteur : Kitsoft Productions
• Taille : 3 Ko
• Liens de référence : Fichier de téléchargement
• Description : Petit module utilitaire pour implémenter des effets de fondu de palette (Fade In / Fade Out).

Load and Save BMP v8.0

• Auteur : Stephen L. Maxson
• Taille : 3 Ko
• Liens de référence : Fichier de téléchargement
• Description : Deux sous-programmes, Loadbmp8 et Savebmp8, conçus pour charger et sauvegarder des images bitmap (BMP) au sein de vos créations QuickBasic.

CCL

• Auteur : Asher256
• Taille : 44 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un logiciel utilitaire pour chiffrer des fichiers. Il s’avère également nécessaire pour déchiffrer certains des codes sources que je mets à disposition.

PlayWav

• Auteur : Lord Agnathian
• Taille : 2 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une extension (add-on) logicielle permettant d’intégrer et de jouer des fichiers audio WAV de manière simple et rapide grâce à une routine unique : PlayWav().

Bibliothèques

FmLib 1.5

• Auteur : Asher256
• Taille : 50 Ko
• Liens de référence : Fichier de téléchargement
• Description : Nouvelle version de la bibliothèque dédiée à la lecture des fichiers .FMS générés par le tracker FmSong. Vos compositions s’intègrent désormais facilement dans vos projets. Le plus : aucun programme résident (TSR) n’est requis en tâche de fond (s’affranchit de SBMIDI ou SBSIM).

DirectQB

• Auteur : Angelo Mottola
• Taille : 207 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une bibliothèque intégralement écrite en assembleur, garantissant une excellente vitesse d’exécution. Elle opère exclusivement en mode 13h (320x200x256 couleurs) et s’appuie sur la mémoire EMS. Elle embarque de nombreuses routines : gestion audio (WAV) par transfert DMA, affichage de sprites, double buffer, clipping, calculs 3D (polygones), décodage d’images (BMP, PCX, GIF) et gestion de fichiers d’archives (Datafiles).
  Le plus : Une solution particulièrement véloce et performante.
  Le moins : Limitée à un seul mode graphique.

EMS Lib

• Auteur : Anonyme
• Taille : 207 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une bibliothèque prête à l’emploi permettant d’exploiter la mémoire EMS afin de s’affranchir de la barrière historique des 640 Ko de base, étendant l’espace adressable jusqu’à 15 Mo.
  Le plus : Un code source .BAS extrêmement pratique.
  Le moins : Aucun point négatif relevé.

Blast Library

• Auteur : Andrew L. Ayers
• Taille : 207 Ko
• Liens de référence : Fichier de téléchargement
• Description : Bibliothèque d’affichage optimisée pour le mode 13h, écrite en assembleur (plus rapide que DirectQB). Elle utilise des transferts directs en mémoire vidéo. Elle intègre les fonctions classiques réécrites : PUT, GET, PRINT, CLS…
  Le plus : Une rapidité d’exécution optimale.
  Le moins : Un catalogue de fonctions un peu restreint et un seul mode supporté.

Future Library

• Auteur : Future Software
• Taille : 207 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une solution complète prenant en charge de nombreux modes d’affichage graphiques VESA (jusqu’à 1024×768 en 16 millions de couleurs). Elle propose la gestion de polygones 3D, le support audio (fichiers WAV), le double/triple buffering ainsi que le chargement d’images (BMP, PCX…).
  Le plus : Bibliothèque riche offrant un large choix de résolutions graphiques.
  Le moins : Le revers de la médaille réside dans sa lenteur d’exécution.

Graphisme (GFX)

Matrix

• Auteur : Papouss
• Taille : 962 octets
• Liens de référence : Fichier de téléchargement
• Description : Une simulation textuelle de l’effet de code défilant du film Matrix.
  (BAS)

Parallaxe Bêta 0.1

• Auteur : Matthieu Lalère
• Taille : 115 Ko
• Liens de référence : Fichier de téléchargement
• Description : Deux démonstrations de scrolling parallaxe (gestion de plusieurs plans superposés) exploitant la bibliothèque EMS Lib pour le stockage des segments. Les routines préservent ainsi la mémoire conventionnelle des 640 Ko de QBasic. L’exécution s’avère un peu lourde sur de vieilles configurations, mais le code constitue un excellent support d’étude. L’un des exemples rappelle l’effet de perspective marine de Donkey Kong Country 2.
  (EXE,BAS)

Graph Pack

• Auteur : Dark Lanfeust
• Taille : 2 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une collection regroupant 5 fichiers sources d’effets visuels (fractales, champs d’étoiles, etc.).
  (BAS)

Démonstration de Neige

• Auteur : Michel Fabien
• Taille : 2 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une très belle simulation de chute de flocons de neige.
  (BAS)

VScroll

• Auteur : Anonyme
• Taille : 311 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une démonstration de scrolling vertical (similaire au rendu de Zelda III) sous l’environnement SCREEN 13. Cette démo est particulièrement réussie. Le code source étant ouvert, profitez-en pour analyser son fonctionnement.
  (BAS)

CPlasma

• Auteur : Anonyme
• Taille : 1 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un magnifique effet de plasma coloré.
  (BAS)

FSim 3D

• Auteur : Anonyme
• Taille : 2 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une simulation de vol affichée en 3D fil de fer.
  (BAS)

3D Texture

• Auteur : Asher256
• Taille : 58 Ko
• Liens de référence : Fichier de téléchargement
• Description : Démonstration d’un véritable moteur 3D texturé développé en QBasic. Ce projet a été mis de côté au cours de l’année 2001. Les routines de calcul géométrique restent parfaitement réutilisables après analyse du code source.
  (BAS,EXE)

QBasic Worm

• Auteur : Biskbart
• Taille : 28 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une démonstration technique axée sur la génération de cartes aléatoires destructibles dans le style du jeu Worms.
  (BAS,EXE)

Star Field 3D

• Auteur : Asher256
• Taille : 28 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une démonstration d’un champ d’étoiles évoluant en perspective 3D.
  (BAS,EXE)

FEU

• Auteur : Asher256
• Taille : 39 Ko
• Liens de référence : Fichier de téléchargement
• Description : Démonstration d’un algorithme de simulation de flammes en temps réel.
  (BAS,EXE)

3D Flight Simulator v4.3

• Auteur : Red Baron
• Taille : 2 Ko
• Liens de référence : Fichier de téléchargement
• Description : Démonstration d’un simulateur de vol en 3D faces pleines (sans textures). Visuellement minimaliste, le programme s’avère mathématiquement et techniquement bien structuré.
  (BAS)

Tutoriels Divers

Acquérir un bon style de programmation

• Auteur : Benjamin Renaut
• Taille : 11 Ko
• Liens de référence : Fichier de téléchargement
• Description : Ce document enseigne les bonnes pratiques d’ingénierie logicielle pour structurer son code, le rendre lisible et faciliter sa maintenance par soi-même ou ses collaborateurs. Bien que les exemples s’appuient sur le QBasic, ces concepts universels s’appliquent à tous les langages de programmation.

Comment Linux écrasa Windows

• Auteur : Cynbe
• Taille : 10 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un essai d’analyse historique et technique captivant à lire absolument.

Utiliser le programme ftp.exe

• Auteur : Asher256
• Taille : 2 Ko
• Liens de référence : Fichier de référence
• Description : Guide pratique expliquant comment utiliser l’utilitaire en ligne de commande ftp.exe afin de transférer vos productions vers un serveur distant, idéal pour automatiser le déploiement d’une page web.

Tutoriels QBasic pour Débutants

Tutoriel chiffrement et palettes

• Auteur : dzouato
• Taille : 483 Ko
• Liens de référence : Fichier de téléchargement
• Description : Deux guides d’introduction pour apprendre à chiffrer vos fichiers de données et à manipuler les registres des palettes graphiques sous QBasic.

Tutoriel COMPLET QBasic pour débutant

• Auteur : Philippe-Henry Marcy
• Taille : 483 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un ouvrage complet de 80 pages au format PDF détaillant les fondements de la programmation sous QuickBasic, accompagné de nombreux cas pratiques. Un grand bravo à l’auteur pour ce travail de documentation remarquable.

Tutoriel QBasic

• Auteur : Anonyme
• Taille : 68 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un guide d’initiation bien structuré permettant aux débutants d’acquérir de solides bases en algorithmique.

Warrior QB Tutorial

• Auteur : Warrior
• Taille : 135 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un excellent manuel didactique couvrant l’éventail complet des fonctionnalités de base de QBasic, incluant notamment les interruptions matérielles pour la gestion de la souris.

Slasky Tutorial

• Auteur : Slasky
• Taille : 23 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un parcours d’apprentissage progressif structuré par étapes, vivement recommandé pour l’initiation des grands débutants.

Raptor’s Tutorial

• Auteur : Flavien Charlon
• Taille : 23 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un autre document d’initiation à la programmation, un peu plus condensé que le tutoriel de Slasky.

Basic Tutorial

• Auteur : Asher256
• Taille : 67 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une introduction synthétique concentrée sur l’apprentissage et l’usage des instructions de base PRINT et INPUT.

Tutoriels QBasic Avancés

ProcTasm – Edition II

• Auteur : Asher256
• Taille : 7 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un document technique avancé dédié à l’intégration de routines en assembleur au sein du QuickBasic. Il explique comment concevoir et lier du code machine pour maximiser les performances d’exécution des jeux et logiciels. Cette seconde édition corrige des erreurs de la première mouture et s’enrichit de deux articles rédigés par Strix Slayer.

L’assembleur dans le QBasic

• Auteur : Aaron Severn
• Taille : 2 Ko
• Liens de référence : Fichier de téléchargement
• Description : Guide expliquant comment utiliser l’utilitaire DEBUG pour injecter des routines de bas niveau directement dans vos binaires QBasic (traduit de l’anglais).

La 3D dans le QBasic, TOME 2

• Auteur : Tom Rathbone
• Taille : 2 Ko
• Liens de référence : Fichier de téléchargement
• Description : Suite du premier volet, se focalisant sur les matrices de rotation géométrique et l’application d’un effet d’anticrénelage (antialiasing) sur le tracé de points.

La 3D dans le QBasic, TOME 1

• Auteur : Tom Rathbone
• Taille : 2 Ko
• Liens de référence : Fichier de téléchargement
• Description : Traduction d’un guide technique abordant les fondamentaux mathématiques de la projection tridimensionnelle : comment projeter un point de coordonnées 3D sur un plan d’affichage en 2D.

Le graphisme 3D en QBasic

• Auteur : Aaron Severn
• Taille : 3 Ko
• Liens de référence : Fichier de téléchargement
• Description : Traduction en français d’un cours anglophone synthétisant la logique algorithmique globale requise pour implémenter un moteur 3D fonctionnel.

QB Libs

• Auteur : Asher256
• Taille : 2,07 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une étude comparative entre les deux grandes bibliothèques d’extensions de l’époque : DirectQB et FutureLib. Quels sont les critères de choix ? Comment mener à bien leur installation ?

Le clavier dans le QBasic

• Auteur : Asher256
• Taille : 1,40 Ko
• Liens de référence : Fichier de téléchargement
• Description : Astuces techniques pour intercepter les codes de balayage (scancodes) et optimiser la gestion des entrées clavier.

L’optimisation en QBasic

• Auteur : Asher256
• Taille : 3 Ko
• Liens de référence : Fichier de téléchargement
• Description : L’interpréteur QBasic s’avère particulièrement lent si l’on ne maîtrise pas ses spécificités. Ce tutoriel compile les techniques indispensables pour optimiser l’exécution de votre code source.

L’animation comme dans QBSMario

• Auteur : Asher256
• Taille : 40 Ko
• Liens de référence : Fichier de téléchargement
• Description : Ce cours détaille la mise en place d’un système d’animation cyclique simple de sprites pour vos jeux vidéo, à l’image du moteur de QBS-Mario.

ProgsOnline

• Auteur : ProgsOnline
• Taille : 67 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un tutoriel complet abordant des problématiques de développement variées : champs d’étoiles 2D/3D, routines de scrollings, algorithmes de chiffrement, etc.

Divers (MISC)

Rapid Tic Tac Toe

• Auteur : Asher256
• Taille : 401 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un jeu de morpion doté d’une routine d’intelligence artificielle particulièrement efficace.
  (BAS, EXE)

Niki version II

• Auteur : Asher256
• Taille : 147 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un programme d’agent conversationnel (chatbot) simulant une amie dotée d’un dictionnaire de réponses interactif.
  (BAS,EXE)

Mini Programmes (MINIPROG)

QB Apollo 11

• Auteur : Timothée Naux
• Taille : 138 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un mini-jeu de simulation physique où vous devez faire atterrir un module lunaire en gérant sa poussée.
  (EXE)

Airfighter

• Auteur : Timothée Naux
• Taille : 255 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un jeu d’affrontement spatial tactique contre un opposant géré par l’ordinateur.
  (EXE,BAS)

Devines

• Auteur : Anonyme
• Taille : 39 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un grand classique d’initiation : le joueur doit deviner un nombre entier généré de manière pseudo-aléatoire par la machine.

Jumanji

• Auteur : Clood200
• Taille : 42 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un jeu de société virtuel basé sur des lancers de dés, où chaque case déclenche des actions ou des mini-jeux dédiés.
  (EXE,BAS)

Glouton

• Auteur : Timothée
• Taille : 34 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une déclinaison de Pac-Man où l’objectif est de collecter divers objets dans un temps imparti. Une première réalisation particulièrement prometteuse et réussie pour cet auteur.
  (BAS)

Race 2.0

• Auteur : CMT
• Taille : 34 Ko
• Liens de référence : Fichier de téléchargement
• Description : Nouvelle mouture de Race ! Un duel de rapidité sur le même clavier où il faut presser sa touche le plus vite possible pour vaincre son adversaire.
  (BAS,EXE)

Puissance 4

• Auteur : Guillaume Cannaux
• Taille : 39 Ko
• Liens de référence : Fichier de téléchargement
• Description : Adaptation fidèle du célèbre jeu de stratégie. L’objectif est d’aligner 4 jetons identiques. Se joue à deux joueurs.
  (BAS,EXE)

Minimini RPG

• Auteur : Anonyme
• Taille : 39 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une implémentation ultra-minimaliste de jeu de rôle en mode texte.
  (EXE,BAS)

Pong Massacreur

• Auteur : LTB
• Taille : 39 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une version revisitée et nerveuse du célèbre jeu de Pong.
  (EXE,BAS)

Pass

• Auteur : Laurent Vanaerde
• Taille : 1 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une routine légère permettant d’intégrer une invite d’authentification par mot de passe dans vos applications.
  (BAS)

Crypton

• Auteur : Anonyme
• Taille : 1 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un utilitaire compact de chiffrement, fourni avec son code source complet pour en étudier les mécanismes de masquage binaire.
  (BAS)

Etoiles

• Auteur : Michel Fabien
• Taille : 2 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une petite démonstration d’un champ d’étoiles défilant en deux dimensions.
  (BAS)

Eau

• Auteur : Michel Fabien
• Taille : 2 Ko
• Liens de référence : Fichier de téléchargement
• Description : Rendu élémentaire simulant un effet aquatique. Bien que visuellement simple, le code est hautement didactique pour les novices.
  (BAS)

MasterMind

• Auteur : TOUF
• Taille : 4 Ko
• Liens de référence : Fichier de téléchargement
• Description : L’adaptation QuickBasic du célèbre jeu de réflexion. Les graphismes spartiates n’altèrent en rien l’intérêt du gameplay.
  (BAS)

Yahtzee

• Auteur : Laurent Vanaerde
• Taille : 4 Ko
• Liens de référence : Fichier de téléchargement
• Description : Le célèbre jeu de dés du Yam’s codé pour la console DOS.
  (BAS)

L5

• Auteur : BestAmiForLaVie
• Taille : 4 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un petit utilitaire textuel compilant l’intégralité des paroles des chansons du groupe pop L5.
  (BAS)

QBPainter

• Auteur : HOSSEN Karim
• Taille : 4 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un utilitaire rudimentaire d’édition graphique pixel-art en QBasic.
  (BAS)

Race Bêta

• Auteur : CMT
• Taille : 32 Ko
• Liens de référence : Fichier de téléchargement
• Description : Version préliminaire du jeu de duel où la victoire repose sur le martèlement frénétique de la barre d’espace.
  (BAS,EXE)

Nibbles

• Auteur : Jerome Bertrand
• Taille : 50 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un jeu de serpent traditionnel. L’accent est mis sur l’efficacité du gameplay et la clarté du code source fourni en annexe.
  (BAS,EXE)

Helico

• Auteur : Adrien Aury
• Taille : 36 Ko
• Liens de référence : Fichier de téléchargement
• Description : Une démonstration technique illustrant le comportement physique d’un hélicoptère en vol stationnaire.
  (EXE)

Slus Fight

• Auteur : Anonyme
• Taille : 21 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un jeu de combat aux visuels basiques, mais doté d’un code source rigoureusement commenté en anglais.
  (BAS,EXE)

Tous les exercices

• Auteur : Anonyme
• Taille : 6 Ko
• Liens de référence : Fichier de téléchargement
• Description : Un ensemble pédagogique de 18 fichiers sources .BAS à complexité linéaire, idéal pour guider pas à pas l’apprentissage des développeurs débutants.
  (BAS)

Conclusion

Malgré les contraintes inhérentes à l’environnement DOS et les limites de la mémoire conventionnelle de 640 Ko de QBasic, les développeurs ont su concevoir des solutions applicatives avancées. L’usage conjoint de bibliothèques en assembleur (comme DirectQB) et de trackers sonores dédiés illustre une volonté d’optimisation rigoureuse. Cette archive constitue un ensemble cohérent qui documente l’apprentissage pratique de l’informatique et du développement logiciel au sein d’une communauté de passionnés.« `

CCL est un logiciel de chiffrement XOR en Quick Basic, que j’ai développé en 2001, conçu pour renforcer la sécurité de vos fichiers, qu’ils soient au format TXT, HTML, EXE, ZIP, et bien d’autres encore.

L’un des avantages de ce crypteur est son absence totale d’en-tête ajouté au fichier chiffré ; le contenu est crypté directement avec votre clé unique. Cependant, il est impératif de ne pas oublier cette clé, car elle est essentielle pour déchiffrer vos fichiers.

CCL fonctionne en ligne de commande DOS, étant développé en QBasic 4.5. Vous pouvez crypter vos fichiers en utilisant simplement la commande suivante dans votre invite de commande DOS :

ccl.exe [lect:][chemin][fichier.ext] [clef]

Le fichier sera automatiquement chiffré. Pour une utilisation plus pratique, il est conseillé de placer « ccl.exe » dans votre répertoire C:\WINDOWS\COMMAND, ce qui vous permettra d’appeler le programme depuis n’importe quel répertoire. Si vous détenez des fichiers sensibles tels que votre journal personnel, des fichiers contenant tous vos mots de passe, ou des sources *.bas que vous souhaitez protéger, n’hésitez pas à utiliser CCL.

Il est important de noter que CCL est un logiciel libre, donc je vous encourage à l’améliorer et le partager avec vos amis et collègues pour les aider à renforcer la sécurité de leurs fichiers.

Auteur: Asher256
Page officielle: CCL

Télécharger CCL 4.0 (exe et source code .bas):

Télécharger: ccl.zip

(Ce projet est aussi disponible dans le dépôt Git : Asher256/asher256-legacy.)

English description: Mister Kid is a side-scrolling platform game that I wrote in Quick Basic in 2000. It will transport you to a colorful and thrilling adventure through 12 levels and 5 worlds. With each level, you will encounter new obstacles, enemies, and challenges that will test your skills and wits. From the forest to the world of sand, you will need to keep your eyes peeled and stay focused if you want to succeed.

Description en Français: Mister Kid est un jeu de plateforme que j’ai écrit en Quick Basic en 2000 qui est très apprécié par beaucoup de programmeurs QBasic, qui vous transportera dans une aventure colorée et palpitante à travers 12 niveaux et 5 mondes. Le jeu reprend les même principes de Mario, mais avec un défi que vous adorerez ! A chaque niveau, vous rencontrerez de nouveaux obstacles, ennemis et défis qui mettront à l’épreuve vos compétences et votre intelligence. De la forêt au monde de sable, vous devrez garder l’oeil ouvert rester concentré si vous voulez réussir. Mister Kid est paru dans les pages BestOF du magazine Freelog et dans Vplanet. Cela m’a fait plaisir de lire les article sur Mister Kid et m’a encouragé à en faire encore plus!

Official web page / Page officielle: MisterKid
Author / Auteur: Asher256

Download Mister Kid | Télecharger Mister Kid

DOWNLOAD MISTER KID: misterkid.zip

(Misterkid is also available in the GitHub repository: Asher256/asher256-legacy.)

English: Unzip misterkid.zip in a new directory and then execute « mk.exe ». Controls: Press Left and Right to move the character and ALT to jump. Play MisterKid on Windows, Linux, or Mac OS X: It can be played with the DOS emulator DOSBOX (available on Windows, Linux, and Mac OS X). It is recommended to change Dosbox CPU cycles to max by modifying the following option in the configuration file « ~/.dosbox/dosbox*.conf »:

[cpu]
cycles=max

Francais: Dézippez misterkid.zip dans un nouveau répertoire puis exécutez « mk.exe ». Appuyez sur la touche gauche et droite pour déplacer le personnage et ALT pour sauter.

Watch a Video: Mister Kid – DOS Platform Game – Full Game Walkthrough No Commentary (Gameplay, Playthrough)

Link to the video: Mister Kid – DOS Platform Game – Full Game Walkthrough No Commentary (Gameplay, Playthrough)

English: For those interested in watching a full walkthrough with no commentary for the platform game Mister Kid, you can check out the video above. This will allow you to fully experience the game’s visuals and sounds without any distractions or interuptions. Watching the complete game walkthrough can also help you learn new strategies and techniques to overcome the game’s difficulty, because Mister Kid is a challenging game! IMPORTANT: Completing Mister Kid can take a significant amount of time, ranging from 1 hour to 5 hours, factoring in potential game overs due to its difficulty level. This video provides a brief overview of the game, without including the time it may take for the player to learn and master each level.

Français: Comme le jeu Mister Kid est connu pour être difficile, regarder une vidéo complète du gameplay sans commentaire peut vous aider à apprendre de nouvelles stratégies et techniques pour surmonter la difficulté du jeu. En observant comment un joueur expérimenté navigue à travers chaque niveau et surmonte les obstacles du jeu, vous pouvez obtenir des informations sur la façon d’améliorer votre propre gameplay. Profitez de la vidéo et bonne chance !

IMPORTANT: Il existe maintenant un nouvelle version d’UltraSplitter pour
Windows et GNU/Linux à cette adresse : https://www.asher256.com/projects/ultrasplitter/

USplit est un utilitaire DOS écrit en Quick Basic, que j’ai développé en 2000, conçu pour diviser des fichiers en plusieurs fragments. Contrairement à d’autres logiciels de découpage qui se contentent de diviser les fichiers, Ultra Splitter stocke les morceaux directement sur le disque dur et génère automatiquement un fichier batch appelé « unsplit.bat » pour reconstituer le fichier original.

Ce programme m’a permis de transporter le compilateur C++ DJGPP, d’une taille de 10 Mo, en le transférant sur mon ordinateur personnel en utilisant 8 disquettes.

Auteur: Asher256
Page officielle: usplit

Télecharger Ultra splitter

Télecharger UltraSplitter: usplit.zip (44 Ko)

Décompressez usplit.zip dans un nouveau répertoire, puis exécutez usplit.exe et consultez la documentation disponible dans les fichiers .txt.

This project is also available in the GitHub repository: Asher256/asher256-legacy.

English: FM-Song is a DOS software that I wrote in Quick Basic that can be used for creating music that is user-friendly. It is especially designed for creating QBasic video games music, because you can use the FM-Lib library to incorporate your music into your QBasic program. From a technical perspective, FM-Song can play up to 8 musical instruments at once, and you can choose from over 76 different instruments to create your perfect sound. If you wish to see FM-Song and FM-Lib in action, you can download MisterKid, a game whose music was made using FM-Song. With this demo, you can experience the quality of FM-Song’s sound (For a MS-DOS program) and its effectiveness in creating music for video games.

Français: FM-Song est un logiciel DOS que j’ai écrit en Quick Basic convivial et intuitif, qui permet de créer des musiques. FM-Song peut jouer jusqu’à huit instruments de musique simultanément et offre plus de 76 instruments différents à votre disposition (Piano, flute…). pour enrichir votre composition. FmSong et Fm-Lib sont fonctionnent avec la carte son compatible avec Sound Blaster. FM-Song peut être émulé avec Dosbox dans des ordinateurs récents. FM-Song vous offre la possibilité d’utiliser vos musiques dans vos programmes QBasic grâce à la bibliothèque logicielle Fm-Lib (incluse avec FmSong). Vous pouvez utiliser FM-Song pour ajouter une bande son personnalisée à vos jeux vidéo ou pour créer des morceaux de musique originaux pour vos projets créatifs. Avec FmLib, vous avez la possibilité de charger vos musiques *.fms dans votre programme QBasic. La librairie Fmlib joue la musique en arrière-plan (elle ne ralentit pas votre programme).

Official web page / page officielle: FM-Song
Author / auteur: Asher256

Download FM-Song / Télécharger FM-Song:

Télécharger FM-Song: fmsong.zip (version 1.3.2)

English: Includes the tracker software, the Fm-Lib library, an instrument editor, 76 musical instruments et 75 musics (*.fms).

Français: Inclue le logiciel de création de musique FMS, ) la dernière version de la librairie Fm-Lib, un logiciel d’édition d’instruments, 76 instruments de musique et 75 musiques FMS.

(FM-Song is also available in the GitHub repository: Asher256/asher256-legacy.)

Watch: FM-Song Music – DOS Software Tracker written in Quick Basic – Retro Music

This video will allow you to see FM-Song in action:

Link to the video: FM-Song Music – DOS Music Tracker Software written in Quick Basic – FmSong QBasic Retro Music

English: FM-Song is a DOS Music Tracker Software for creating music that is user-friendly. FmSong is especially designed for Quick Basic DOS video games because you can use the FM-Lib library to incorporate your FmSong music into your QBasic games. Nowadays, FMSong can be used to create music for retro QBasic indie games. From a technical perspective, FM-Song can play up to 8 musical instruments at once, and you can choose from over 70 different instruments to create your perfect sound. This video will allow you to see FM-Song in action ! (FM-Song can be emulated on Windows, Linux, and Mac OS X using DOSBOX or DOSBOX-X)

RECOMMENDATION: Je vous recommande d’essayer le jeu de plateforme MisterKid, qui est techniquement plus avancé que QBSmario.

QBSMario est mon tout premier jeu vidéo graphique créé en Quick Basic en 1999. Ce jeu a joué un rôle important car il m’a motivé à poursuivre la programmation en QBasic. QBSMario est relativement court (il s’agit simplement d’une démonstration) et il ne comporte ni ennemis ni défilement.

À sa sortie au début de l’an 2000, QBSMario a suscité l’enthousiasme au sein de la communauté QBasic francophone, car il n’existait alors aucun jeu comparable créé en QBasic dans la scène francophone. Depuis lors, de nombreux autres jeux, inspirés par des titres comme QBSMario, ont vu le jour en QBasic (comme MisterKid, par exemple). Toutefois, QBSMario a laissé une empreinte dans la scène Quick Basic francophone.

Auteur: Asher256
Page officielle: QBasic Super Mario

Télecharger Quick Basic Super mario

Télecharger QB Super Mario: qbsmario.zip

Dézippez qbsmario.zip dans un nouveau répertoire puis exécutez start.bat.

(Ce projet est aussi disponible dans le dépôt Git : Asher256/asher256-legacy.)

Écrit par Aaron Severn le 19 décembre 1997
Traduit par Asher256 en 1999

Pour beaucoup de gens, le concept mathématique de l’espace 3D est peu familier,
bien que nous y évoluions au quotidien. La notion la plus importante à retenir
en 3D est la suivante : la taille apparente des objets varie en fonction de leur
distance (éloignés ou proches). Si notre cerveau interprète cela naturellement,
ce n’est pas le cas d’un ordinateur. Il faut donc un certain travail pour
transformer un écran 2D en un monde 3D.

Tout d’abord, examinons les repères dans l’espace. Graphiquement, l’espace 3D
(R3) ressemble à ceci :

            						       z     y
                      		Y est l'axe horizontal          \    |
              y      z  	x est l'axe vertical 		 \   |
              |     /   	z est l'axe de profondeur         \  |
	      |    /		qui sort de l'écran                \ | é
              |   /		é est l'angle XY                    \|________
              |  /              et est l'angle de l'axe Z                    x
            é | /
      ________|/
      x					Et un cube en 3D

    				     ______
				   /|      /|
				  / |     / |
				 /__|____/  |
				|   |    |  |
				|   |____|__|
				|  /     |  /
				| /      | /
				|/_______|/

Les notations ci-dessus seront utilisées tout au long de ce texte.

Les deux problèmes que nous devons résoudre sont :

• Comment créer l’effet de profondeur sur un écran plat ?
• Comment faire pivoter des points dans l’espace ?

Maintenant que nous avons les bases, répondons à la première question.

Le dessin d’un objet 3D sur un moniteur 2D

La solution à ce problème est très simple. Pensez-y un instant. Supposons que
nous ayons une boîte transparente à l’écran ; nous voulons que la face la plus
proche de nous paraisse plus grande que la face la plus éloignée. Comment
procéder ? Il suffit de diviser les coordonnées des points par rapport à leur
distance (la profondeur).

Voici ce que cela signifie pour l’affichage de points en 3D. Nous partons de
trois coordonnées, mais nous n’en avons besoin que de deux pour l’écran. Il faut
donc diviser deux des coordonnées par la troisième. Voici les formules :

x2D = 256 * (x3D / (z3D + zCenter)) + xCenter
y2D = 256 * (y3D / (z3D + zCenter)) + yCenter

Dans ces formules, (x2D​,y2D​) représente le point qui sera affiché à l’écran, et
(x3D​,y3D​,z3D​) est le point dans l’espace 3D. Les variables xCenter​ et yCenter​
représentent les coordonnées du centre de l’objet à l’écran, tandis que zCenter​
représente la position de l’observateur (cette valeur est généralement de 256).
Les deux équations sont multipliées par 256 pour ajuster l’objet à la
perspective de l’observateur.

Vous pouvez utiliser ces formules pour dessiner n’importe quel objet 3D sur un
écran 2D.

La rotation 3D

Un objet 3D immobile à l’écran n’a que peu d’intérêt. Il est bien plus captivant
de le faire bouger ou pivoter. Comment y parvenir ? Les mathématiques impliquées
ici sont assez complexes. N’étant pas moi-même un expert en mathématiques, je ne
vous ferai pas perdre de temps avec de mauvaises explications. Je vais
simplement vous donner les formules finales, avec lesquelles vous pourrez faire
tourner des objets toute la nuit.

Tout d’abord, vous aurez besoin des deux angles illustrés dans le diagramme de
la première section : θ (theta) et ϕ (phi). Nous devrons également utiliser ρ
(rho), qui représente la distance entre le point et l’origine (0,0,0). Passons
directement aux formules. Ci-dessous, (xO​,yO​,zO​) représente la position initiale
du point dans l’espace 3D et (xR​,yR​,zR​) représente le point après rotation :

xR = -xO * SIN(é) + yO * COS(é)
yR = -xO * COS(é) * SIN(í) - yO * SIN(é) * SIN(í) - zO * COS(í) + p
zR = -xO * COS(é) * COS(í) - yO * SIN(é) * COS(í) + zO * SIN(í)

Si vous implémentez ces formules correctement, vous serez capable d’écrire un
programme générant de belles rotations 3D. Pour voir un cas concret, consultez
le code source ci-dessous.

Programme d’exemple

DEFINT A-Z

TYPE pnt                                        'type for each 3D point
    x AS INTEGER                                'x coord (horizontal)
    y AS INTEGER                                'y coord (vertical)
    Z AS INTEGER                                'z coord (into the screen)     p AS INTEGER                                'dist from center of object END TYPE

numLines = 12 - 1

DIM lO(numLines, 1) AS pnt                      'Original line coords
DIM lR(numLines, 1) AS pnt                      'Rotated coords
DIM scrX(numLines, 1)                           'screen x coord
DIM scrY(numLines, 1)                           'screen y coord
DIM oldX(numLines, 1)                           'old x coord for erasing DIM oldY(numLines, 1)                           'old y coord for erasing

DIM s!(359)                                     'trig tables
DIM c!(359)

CONST PI = 3.141592

FOR i = 0 TO 359                                'create sine and cosine    s!(i) = SIN(i * (PI / 180))                  'look up tables to speed up    c!(i) = COS(i * (PI / 180))                  'the math
NEXT

' Read two points instead of one.
FOR i = 0 TO numLines
   READ lO(i, 0).x, lO(i, 0).y, lO(i, 0).Z, lO(i, 0).p
   READ lO(i, 1).x, lO(i, 1).y, lO(i, 1).Z, lO(i, 1).p
NEXT

SCREEN 13
CLS

xCenter = 160: yCenter = 100: zCenter = 256
theta = 0: phi = 0
thetaRot = 2: phiRot = 2

justStarted = 1
DO
  FOR i = 0 TO numLines
     ' Save the old values of x and y so we can erase the balls later.      oldX(i, 0) = scrX(i, 0): oldY(i, 0) = scrY(i, 0)
     oldX(i, 1) = scrX(i, 1): oldY(i, 1) = scrY(i, 1)

     ' Rotate both points on each axis.
     lR(i, 0).x = -lO(i, 0).x * s!(theta) + lO(i, 0).y * c!(theta)
     lR(i, 0).y = -lO(i, 0).x * c!(theta) * s!(phi) - lO(i, 0).y * s!(theta)            * s!(phi) - lO(i, 0).Z * c!(phi) + lO(i, 0).p
     lR(i, 0).Z = -lO(i, 0).x * c!(theta) * c!(phi) - lO(i, 0).y * s!(theta)            * c!(phi) + lO(i, 0).Z * s!(phi)

     lR(i, 1).x = -lO(i, 1).x * s!(theta) + lO(i, 1).y * c!(theta)
     lR(i, 1).y = -lO(i, 1).x * c!(theta) * s!(phi) - lO(i, 1).y * s!(theta)            * s!(phi) - lO(i, 1).Z * c!(phi) + lO(i, 1).p
     lR(i, 1).Z = -lO(i, 1).x * c!(theta) * c!(phi) - lO(i, 1).y * s!(theta)            * c!(phi) + lO(i, 1).Z * s!(phi)

     ' Translate both points from 3D to 2D.
     IF (lR(i, 0).Z + zCenter) <> 0 THEN
       scrX(i, 0) = 256 * (lR(i, 0).x / (lR(i, 0).Z + zCenter)) + xCenter        scrY(i, 0) = 256 * (lR(i, 0).y / (lR(i, 0).Z + zCenter)) + yCenter      END IF

     IF (lR(i, 1).Z + zCenter) <> 0 THEN
       scrX(i, 1) = 256 * (lR(i, 1).x / (lR(i, 1).Z + zCenter)) + xCenter        scrY(i, 1) = 256 * (lR(i, 1).y / (lR(i, 1).Z + zCenter)) + yCenter      END IF
  NEXT i

  ' Erase the old lines.
  WAIT &H3DA, 8
  IF justStarted = 0 THEN
    FOR i = 0 TO numLines
       LINE (oldX(i, 0), oldY(i, 0))-(oldX(i, 1), oldY(i, 1)), 0
    NEXT i
  END IF

  ' Draw the new lines.
  FOR i = 0 TO numLines
     LINE (scrX(i, 0), scrY(i, 0))-(scrX(i, 1), scrY(i, 1)), 11
  NEXT i

  theta = (theta + thetaRot) MOD 360
  phi = (phi + phiRot) MOD 360

  justStarted = 0
LOOP UNTIL INKEY$ = CHR$(27)

' Lines are stored in format (X1,Y1,Z1,p1)-(X2,Y2,Z2,p2)
DATA -50,50,50,1,50,50,50,1
DATA 50,-50,50,1,50,50,50,1
DATA 50,50,-50,1,50,50,50,1
DATA -50,-50,50,1,-50,50,50,1
DATA -50,50,-50,1,-50,50,50,1
DATA -50,-50,50,1,50,-50,50,1
DATA -50,50,-50,1,50,50,-50,1
DATA -50,-50,-50,1,50,-50,-50,1
DATA -50,-50,-50,1,-50,50,-50,1
DATA 50,-50,-50,1,50,-50,50,1
DATA 50,-50,-50,1,50,50,-50,1
DATA -50,-50,-50,1,-50,-50,50,1