Développement GameBoy #1bis : re-Hello World

Présentation de la GameBoy

GameBoy originale (DMG)

La GameBoy première du nom, aussi appelée DMG (pour Dot Matrix Game), est une console portable sortie en 1989 au Japon et aux États-Unis et en 1990 chez nous.

Elle a été conçue par l'équipe R&D1 de Nintendo, la même équipe qui créa les fameuses Game & Watch. Bien que tout le monde attribue la création de la console à Gunpei Yokoi, alors responsable de la division R&D1 chez Nintendo, la réalité n'est pas aussi simple : de nombreux ingénieurs ont participé à sa création et il semblerait que l'on doive la GameBoy telle qu'on la connaît aujourd'hui à son bras droit, Satoru Okada.

Quoi qu'il en soit, l'histoire du développement de la console est pleine de rebondissements, et elle a même failli ne jamais voir le jour : le projet à tout bonnement été annulé en cours de route. Mais heureusement elle a été sauvée grâce à l'entêtement d'une poignée d'ingénieurs qui ont continué à travailler dessus en secret ! Bien que l'histoire de cette console me passionne, il ne s'agit pas du sujet de cet article. Si l'histoire de la création de la GameBoy vous intéresse, je vous recommande le livre « L’Histoire de Nintendo Vol.4 » de Florent Gorges, édité par Omaké Books, qui est probablement l'ouvrage le plus complet existant à ce jour sur le sujet !

On va donc passer aux caractéristiques techniques de la machine. La GameBoy embarque :

• un CPU 8-bit (dérivé du Zilog Z80), cadencé à 4.194304 MHz,
• 8 ko de RAM,
• 8 ko de mémoire vidéo,
• un écran de 2.6" affichant 4 niveaux de gris à une résolution de 160×144 pixels,
• du son stéréo (en branchant des écouteurs car la console n'inclut qu'un unique haut-parleur),
• un port link permettant de connecter plusieurs consoles entre elles,
• le tout alimenté par 4 piles AA de 1.5v.

GameBoy Pocket

Quelques années plus tard, en 1995, sortira la GameBoy Pocket. Ses caractéristiques sont identiques à sa grande sœur si ce n'est sa taille 30 % plus petite, un écran de meilleure qualité (et qui ne tire plus sur le vert-jaune), un port Link miniaturisé et les piles qui passent de 4 piles AA à 2 piles AAA.

La GameBoy Pocket sera suivie en avril 1998 par la GameBoy Pocket Light, qui est identique à la Pocket mais qui rajoute un rétroéclairage à l'écran. Cette version est sortie uniquement au Japon et n'a pas rencontré un immense succès : il faut dire qu'elle a été très vite éclipsée par la GameBoy Color, qui a été annoncée dans la foulée et qui est sortie à peine 6 mois plus tard !

GameBoy Color

En novembre 1998 sort donc la GameBoy Color (abrégé en GBC ou quelques fois en CGB). Elle est assez similaire aux précédentes GameBoy, mais avec un écran couleur, comme son nom l'indique, et des performances boostées : plus de mémoire vidéo, un CPU équipé d'un mode double-speed (deux fois plus rapide), un port infrarouge,... Cette console reste cependant rétrocompatible avec les jeux de la GameBoy monochrome, et il est même possible de développer des jeux en couleurs qui fonctionnent également sur les anciennes générations de consoles.

GameBoy Advance

C'est ici que s'arrête la liste des machines visées par cette série d'articles, mais histoire d'être à peu près complet, on va quand même dire quelques mots sur la GameBoy Advance (GBA), sortie en 2001.

La GameBoy Advance peut véritablement être considérée comme une nouvelle console. Il ne s'agit plus de l'évolution du matériel existant, elle est basée sur une tout autre architecture matérielle que ses prédécesseurs : la GameBoy Advance possède en effet un processeur ARM 32 bit (oui on parle bien du même ARM utilisé dans nos téléphones, mais les puces de l'époque étaient bien sûr beaucoup moins puissantes 😉️). La console connaîtra deux mises à jour matérielles : la GameBoy Advance SP et la GameBoy Micro.

Malgré une architecture différente, la GameBoy Advance et la GameBoy Advance SP peuvent toutes les deux faire tourner des jeux GameBoy et GameBoy Color grâce à la présence d'une puce dédiée. Cette possibilité sera toutefois supprimée pour la GameBoy Micro, qui ne supporte donc que les jeux GameBoy Advance.

GameBoy Advance SP

GameBoy Micro

Et pour être totalement complet sur les consoles de la famille GameBoy, il convient de mentionner la Super GameBoy (SGB) sortie en 1994, ainsi que sa seconde itération, la Super GameBoy 2 qui est sortie en 1998 uniquement au Japon. Il s'agit d'une cartouche pour la Super NES, permettant d'y insérer des jeux GameBoy afin d'y jouer sur sa TV. Il y aurait beaucoup à dire à son sujet et sur ses particularités matérielles mais ce sera pour une autre fois. 😉️

Super GameBoy

Maintenant qu'on a parlé des consoles, on va parler des jeux. Les jeux GameBoy sont distribués sous forme de cartouches interchangeables dont les caractéristiques varient d'un jeu à l'autre :

• de 32 ko à 4 Mo de ROM (mémoire en lecture seule contenant le jeu et ses données),
• de la RAM optionnelle (avec une pile) pour sauvegarder des données,
• et parfois d'autres éléments, comme une horloge, un port infrarouge, un vibreur ou même une caméra !

Cartouche de jeu GameBoy

Développer sur GameBoy

Il existe aujourd'hui plusieurs solutions pour développer sur GameBoy :

• On peut écrire notre jeu en assembleur : c'est ce que faisaient les développeurs de l'époque. L'assembleur permet de contrôler très précisément ce qui se passe sur la machine, mais demande en contrepartie beaucoup plus de travail, car on doit écrire notre programme dans un langage très proche de celui compris par le microprocesseur.
• On peut également écrire notre jeu en C, qui est un langage de plus haut niveau que l'assembleur. Le C permet d'écrire un jeu relativement rapidement, la principale contrepartie étant que notre programme pourra consommer un peu plus de ressources sur la machine si on ne fait pas attention.
• Et enfin, on peut créer un jeu sans écrire une seule ligne de code (oui oui, vous avez bien lu !) grâce à GB Studio. Alors ne vous emballez pas, ça permet uniquement de développer des petits RPG très limités, mais ça peut être un bon début (en tout cas le projet semble prometteur). 😀️

Dans cet article (et dans tous les suivants), je vais aborder la programmation sur GameBoy en C.

Pour développer en C sur GameBoy, on utilisait traditionnellement GBDK (littéralement GameBoy Developers Kit). C'est d'ailleurs de lui dont je parle dans la première version de cet article. Le problème, c'est que GBDK n'est plus développé depuis 2002 et que le compilateur qu'il embarque (une très vieille version de SDCC masquée derrière une surcouche) est bogué, j'en ai fait les frais lorsque j'ai essayé de développer un projet un peu plus compliqué qu'un exemple pour mes articles. Si je devais résumer le problème : vous écrivez du code C tout à fait juste, mais le compilateur va générer dans certains cas du code machine erroné, ce qui fait que le programme qui s'exécute sur la GameBoy ne correspond pas à celui que vous avez écrit et fait n'importe quoi. Cela donne des bugs incompréhensibles et très difficiles à déboguer. C'est pourquoi je ne peux plus le recommander aujourd'hui et c'est la raison qui m'a poussé à mettre à jour mes articles et à écrire ce nouvel article d'introduction que vous êtes en train de lire.

Du coup, si GBDK est bogué, comment on fait pour développer en C sur GameBoy ? Eh bien c'est assez simple : on utilise une version récente de SDCC (les bugs de 2002 sont corrigés depuis bien longtemps). Le problème c'est que SDCC sait générer du code pour le microprocesseur de la GameBoy (architecture GBZ80), mais il n'inclut aucune bibliothèque pour nous aider dans notre tâche. Heureusement, Andreas Karlsson a récupéré et mis à jour les bibliothèques de GBDK pour les rendre compatibles avec les versions actuelles de SDCC. Cette version mise à jour des bibliothèques de GBDK se nomme gbdk-n.

Donc pour résumer, on va utiliser :

• SDCC comme chaîne de compilation,
• et les bibliothèques gbdk-n.

Installer SDCC, la chaîne de compilation

On va donc commencer par installer la chaîne de compilation SDCC. Je vais vous donner ici les explications pour Linux et pour Windows.

Je m'excuse pour les utilisateurs de Mac OS X, mais je n'ai pas de Mac sous la main, il faudra vous débrouiller avec la documentation de SDCC. Si toutefois quelqu'un se sent de rédiger une procédure d'installation pour Mac OS, je veux bien l'ajouter à cet article. 😉️ [EDIT: @kdridi me signale sur Twitter que SDCC peut s'installer avec brew sur Mac OS X : brew install sdcc]

sudo apt install build-essential sdcc sdcc-libraries

Télécharger et compiler gbdk-n

Maintenant qu'on a tout le nécessaire pour compiler des programmes pour la GameBoy, il nous faut télécharger et compiler la bibliothèque gbdk-n. Pour la télécharger c'est très simple :

• Si vous avez Git d'installé, vous pouvez télécharger le code de gbdk-n à l'aide de la commande suivante :

  git clone https://github.com/flozz/gbdk-n.git
  

  Cela téléchargera la dernière version (master) de la bibliothèque dans un dossier "gbdk-n" qui sera créé dans le dossier courant (celui dans lequel se trouve ouverte votre console).

• Si vous n'avez pas Git ou que vous n'êtes pas à l'aise avec ce dernier, pas de souci, vous pouvez vous rendre sur la page Github à l'adresse suivante :

  • https://github.com/flozz/gbdk-n

  Puis télécharger le contenu du dépôt au format ZIP en cliquant sur le bouton « Clone or download » (bouton vert en haut à droite), puis sur « Download ZIP » :

  

  Il ne vous reste plus qu'à extraire les fichiers de l'archive.

Une fois les fichiers de gbdk-n téléchargés, il ne nous reste plus qu'à compiler la bibliothèque. Et là, ça va dépendre de votre système d'exploitation.

make

$ ls lib/
crt0.rel  gb.lib

Installer un émulateur

Pour tester nos créations, nous aurons besoin d'un émulateur. N'importe lequel peut faire l'affaire, tout du moins au début, mais je vais vous recommander BGB. Il n'est pas Open Source et n'est disponible que pour Windows (on pourra le faire marcher sous Linux quand même hein 😉️), mais il propose une émulation très fidèle du matériel, et surtout il dispose de fonctionnalités de débogage qui nous seront bien utiles.

Voici un aperçu de l'émulateur et de ses outils de débogage :

Débogage d'une ROM dans l'émulateur BGB

Sur cette capture d'écran, on peut apercevoir notamment la fenêtre permettant d'observer le contenu de la mémoire vidéo de la console (les maps, les tuiles chargées, les sprites (OAM) et l'état des palettes de couleurs). On y voit également la fenêtre du débogueur (c'est celle qui fait peur avec plein de code assembleur), et la fenêtre de l'émulateur grâce à laquelle on peut jouer à notre jeu. Je ne vous en dis pas plus, je reparlerai probablement de tout ça dans un futur article. 🙂️

Si vous souhaitez utiliser BGB, il va falloir commencer par le télécharger. Ça se passe sur son site officiel :

• http://bgb.bircd.org/#downloads

Téléchargez donc le ZIP de la dernière version (la 1.5.7 au moment où j'écris ces lignes), puis décompressez-le. Le fichier qui nous intéresse dans l'archive est bgb.exe.

sudo apt install wine

wine chemin/vers/bgb.exe

wine chemin/vers/bgb.exe chemin/vers/votre/jeu.gb

wine chemin/vers/bgb.exe --watch chemin/vers/votre/jeu.gb

Écrire notre premier programme

Comme le veut la tradition, on va écrire un petit programme « Hello World » histoire de voir comment ça se passe.

Mais avant de se lancer dans la programmation, on va s'organiser un peu. On va commencer par créer un dossier pour contenir notre projet (moi je vais l'appeler HelloProject/), et on va y placer le dossier de gbdk-n ainsi que l'exécutable de BGB que nous avions téléchargés dans les étapes précédentes.

Votre dossier de projet devrait donc ressembler à ceci :

À présent on va créer un fichier "hello.c" dans ce dossier afin d'y écrire notre programme. Le dossier du projet ressemble donc à ça à présent :

Maintenant que tout est prêt, il ne nous reste plus qu'à écrire notre premier programme. Pour ce faire, nous allons ajouter le code suivant dans notre fichier "hello.c" :

#include <stdio.h>

void main(void) {
    printf("Hello world!\n");
}

Quoi, c'est tout ? Eh oui, c'est tout... Il n'y a aucune surprise ici : on aurait pu écrire exactement la même chose pour un programme destiné à s'exécuter sur un PC.

Compiler notre programme

Maintenant qu'on a écrit notre programme, il est temps de le compiler afin de pouvoir le tester dans l'émulateur. Quand on parle de « compiler » un programme, on parle généralement de partir du code source pour arriver à un exécutable (ou une ROM dans notre cas). Il s'agit en réalité d'un abus de langage : la compilation n'est que l'une des étapes nécessaires pour arriver au résultat final (mais la plupart du temps j'emploierai quand même ce terme pour désigner toute la chaîne). Nous aurons dans notre cas besoin de 3 étapes pour transformer notre code source en ROM pour la GameBoy :

1. Compilation : chaque fichier de code source (fichiers .c) va être compilé individuellement pour nous donner un ficher de code objet (avec l'extension .rel dans notre cas, mais avec un compilateur plus traditionnel, l'extension aurait plutôt été .o).
2. Édition des liens : une fois tous les fichiers de code source compilés, on utilise un éditeur de liens (ou linker en anglais) pour rassembler tous nos fichiers de code objet en un unique fichier dans lequel tous les symboles sont résolus (lors de la compilation, chaque fonction et chaque variable est identifiée par un « symbole », le compilateur ne peut pas forcément les résoudre lors de la compilation car il ne traite qu'un seul fichier à la fois, c'est donc le rôle de l'éditeur de liens de résoudre tout ça). À la sortie de cette étape, on obtient un fichier .ihx contenant notre programme. L'édition des liens est généralement la dernière étape du processus de compilation, mais dans notre cas il nous reste encore à générer la ROM.
3. Générer la ROM : c'est la dernière étape, qui va nous permettre de transformer notre programme compilé (fichier .ihx) en ROM pour GameBoy (fichier .gb).

Maintenant qu'on a vu la théorie, passons à la pratique. Et comme à chaque fois, la marche à suivre dépend de votre système d'exploitation et du terminal que vous utilisez.

./gbdk-n/bin/gbdk-n-compile.sh hello.c

./gbdk-n/bin/gbdk-n-link.sh hello.rel -o hello.ihx

./gbdk-n/bin/gbdk-n-make-rom.sh hello.ihx hello.gb

gbdk-n\bin\gbdk-n-compile.bat hello.c

gbdk-n\bin\gbdk-n-link.bat hello.rel -o hello.ihx

gbdk-n\bin\gbdk-n-make-rom.bat hello.ihx hello.gb

It is alive!

Maintenant qu'on dispose de notre ROM, il ne nous reste plus qu'à la tester ! On va donc pouvoir la lancer dans un émulateur comme vu précédemment. Voici donc à quoi ça ressemble avec BGB sous Linux :

Bon ok, pour le moment c'est juste un petit texte qu'on affiche sur l'écran, mais c'est déjà un début ! Et on va voir dans les prochains articles tout le nécessaire pour développer un vrai jeu comme à l'époque !

Télécharger l'exemple complet sur Github

L'exemple que nous avons vu dans cet article, ainsi que les exemples de l'ensemble des articles suivants, sont disponibles sur Github à l'adresse : https://github.com/flozz/gameboy-examples/.

Pour simplifier la compilation des exemples (parce qu'on ne va quand même pas s'embêter à toujours taper toutes les commandes à la main), des scripts ont été ajoutés dans le dossier de chaque exemple. Il s'agit des fichiers Makefile, destiné aux utilisateurs de Linux, et Make.bat, pour les utilisateurs de Windows.

Je ne vais pas vous détailler ici comment utiliser ces scripts car j'ai déjà expliqué tout ça dans le README du dépôt Github, mais si vous avez des questions à ce sujet, n'hésitez pas à m'envoyer un e-mail.

Vous êtes bien sûr libres de réutiliser ces scripts pour vos propres projets, mais faites attention aux points suivants :

• Dans les exemples que j'ai publiés sur Github, j'ai placé tous mes fichiers de code source (fichiers .c et .h) dans un sous-dossier src/ histoire que ce soit un peu « rangé » (au lieu de les laisser à la racine du dossier du projet comme dans le présent article). Il vous faudra faire de même si vous souhaitez utiliser les scripts tels quels.
• Dans le dépôt Github, je n'ai inclus qu'une seule copie de la bibliothèque gbdk-n (je n'allais pas la remettre dans chaque dossier d'exemple), du coup il vous faudra probablement modifier le chemin vers le dossier de gbdk-n grâce à la variable GBDK_N présente en haut de chaque script.
• Enfin, vous pouvez modifier le nom de la ROM générée via la variable PROG, également présente en haut de chaque script.

Ressources pour aller plus loin

Et voilà, ce sera tout pour cette fois, cet article est déjà bien assez long. Si vous souhaitez poursuivre l'aventure et développer votre propre jeu GameBoy, voici quelques ressources que j'aurais bien aimé avoir lorsque j'ai commencé et qui vous seront utiles :

• Mes articles sur le développement GameBoy : pour le moment la plus grosse ressource francophone disponible.
• Le dépôt « Awesome GameBoy Development » sur Github : il s'agit d'un effort de la communauté pour recenser un maximum de ressources (généralement en anglais) sur le développement GameBoy.
• La chaîne « Gaming Monsters » sur Youtube : cette chaîne contient un grand nombre de tutos vidéos (en anglais) sur le développent GameBoy.

Crédits photos : les photos de la section « Présentation de la GameBoy » proviennent de la page Wikimedia d'Evan Amos. Je vous invite à y faire un tour, c'est rempli de photos de consoles de jeux vidéo de haute qualité !