💾 Archived View for blog.flozz.fr › 2019 › 09 › 18 › developpement-gameboy-1bis-re-hello-world captured on 2024-08-31 at 12:09:37. Gemini links have been rewritten to link to archived content
⬅️ Previous capture (2023-04-19)
-=-=-=-=-=-=-
2019-09-18
Bienvenue dans cet article d'initiation au développement GameBoy. Si vous vous demandez comment faire pour programmer sur la célèbre console portable de Nintendo, vous êtes au bon endroit ! On va voir tout au long de cet article quelles sont les caractéristiques de la console, comment se procurer tous les outils nécessaires pour compiler et tester nos jeux et on terminera avec un petit exemple tout simple en langage C (un « Hello world » quoi).
--------------------------------------------------------------------------------
⚠️ Warning
--------------------------------------------------------------------------------
IMPORTANT : Cet article remplace mon précédent article « Développement GameBoy 1 : Hello World ».
« Développement GameBoy 1 : Hello World »
Le précédent article expliquait comment utiliser GBDK, un kit de développement pour la GameBoy qui n'a pas été mis à jour depuis 2002, ce qui ne serait pas un problème si le compilateur qu'il embarque n'était pas complètement bogué. On va donc traiter ici d'une chaîne d'outils beaucoup plus à jour, composée du compilateur SDCC et de la bibliothèque gbdk-n (plus de détails dans la suite de l'article).
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
📝️ Note:
--------------------------------------------------------------------------------
Cet article fait partie d'une série sur le développement GameBoy en C avec le compilateur SDCC et la bibliothèque gbdk-n. Cette série est toujours en cours et de nouveaux articles paraissent de temps à autre.
Articles de la série :
--------------------------------------------------------------------------------
GameBoy originale (nom de code DMG)
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 !
« L’Histoire de Nintendo Vol.4 »
On va donc passer aux caractéristiques techniques de la machine. La GameBoy embarque :
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 !
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.
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.
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. 😉️
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 :
--------------------------------------------------------------------------------
📝️ Note:
--------------------------------------------------------------------------------
NOTE : Dans cette série d'articles, je vais traiter du développement de jeux en noir et blanc, donc compatibles avec toutes les consoles de la gamme GameBoy, excepté la GameBoy Micro. Je traiterai peut-être à l'avenir des spécificités propres à la GameBoy Color (étant donné que c'est une évolution des générations précédentes). Je n'aborderai par contre pas la GameBoy Advance (ou alors ce sera dans très longtemps, dans une autre série d'articles).
--------------------------------------------------------------------------------
Il existe aujourd'hui plusieurs solutions pour développer sur GameBoy :
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.
première version de cet article
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 :
--------------------------------------------------------------------------------
📝️ Note:
--------------------------------------------------------------------------------
NOTE : Dans la suite de cet article j'utiliserai toutefois mon propre fork de gbdk-n. Andreas semble en effet avoir assez peu de temps à consacrer à ce projet aujourd'hui et les correctifs tardent parfois à être mergés.
--------------------------------------------------------------------------------
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]
@kdridi me signale sur Twitter
Si vous êtes sous Linux, il est fort probable que SDCC soit présent dans les dépôts de votre distribution : il suffira donc d'installer SDCC et ses bibliothèques avec votre gestionnaire de paquets habituel.
Pour Debian et Ubuntu, la commande suivante installera tout le nécessaire :
sudo apt install build-essential sdcc sdcc-libraries
Si vous êtes sous Windows, il vous faudra télécharger la dernière version de SDCC sur le site officiel :
https://sourceforge.net/projects/sdcc/files/sdcc-win64/
À l'heure où j'écris cet article, la dernière version disponible est la 3.9.0. Il faudra donc télécharger le fichier sdcc-3.9.0-x64-setup.exe.
Une fois l'installateur téléchargé, lancez-le pour installer la chaîne de compilation, en faisant toutefois attention aux deux points suivants :
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 :
https://github.com/flozz/gbdk-n
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.
Sous Linux, on va compiler la bibliothèque à l'aide du Makefile. Pour ce faire, il suffit de taper la commande suivante depuis un terminal ouvert à la racine du projet (depuis le dossier où se trouve le Makefile quoi) :
make
La compilation va prendre un certain temps et si tout s'est bien passé, les fichiers crt0.rel et et gb.lib devraient être maintenant présents dans le dossier lib/ :
$ ls lib/ crt0.rel gb.lib
Pour Windows, on va compiler la bibliothèque en utilisant le fichier Make.bat. Commencez par ouvrir un terminal dans le dossier du projet, et ensuite, tout dépend du terminal en question :
La compilation va prendre un certain temps et si tout s'est bien passé, les fichiers crt0.rel et et gb.lib devraient être maintenant présents dans le dossier lib\.
--------------------------------------------------------------------------------
📝️ Note:
--------------------------------------------------------------------------------
NOTE : Certains utilisateurs de Windows rencontrent des difficultés à compiler la bibliothèque GBDK-n alors que tout fonctionne bien quand il s'agit de compiler un programme par la suite... Étant donné que je n'ai jamais réussi à reproduire ce problème, tout ce que je peux faire c'est vous fournir une version déjà compilée de la bibliothèque. Téléchargez donc le ZIP ci-dessous et placez les fichiers qui s'y trouvent dans le dossier lib\ :
Vous devriez donc vous retrouver avec les fichiers suivants :
--------------------------------------------------------------------------------
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 :
Capture d'écran du débogage d'une ROM dans l'émulateur BGB
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.
Si vous êtes sous Linux, vous ne pourrez bien évidemment pas faire fonctionner directement BGB, puisque c'est un programme pour Windows. Mais il existe fort heureusement une solution : WINE. Il s'agit d'un logiciel permettant de faire fonctionner des applications Windows sous Linux (et sous Mac OS aussi accessoirement).
On va donc commencer par installer WINE. Ce dernier devrait se trouver dans les dépôts de votre distribution, sous Debian, Ubuntu et leurs dérivés, il suffira donc de taper la commande suivante :
sudo apt install wine
Ensuite, pour lancer l'émulateur, il suffira de taper la commande suivante :
wine chemin/vers/bgb.exe
Pour lancer directement la ROM de votre jeu, vous pourrez taper la commande suivante :
wine chemin/vers/bgb.exe chemin/vers/votre/jeu.gb
Enfin, une petite astuce : BGB intègre un mode « watch », qui permet de recharger automatiquement la ROM lorsqu'elle est modifiée (donc à chaque fois qu'on recompile le jeu pour le tester). C'est extrêmement pratique. Pour activer le mode « watch », il faut utiliser la commande suivante :
wine chemin/vers/bgb.exe --watch chemin/vers/votre/jeu.gb
Sous Windows, pour lancer l'émulateur, il suffit de double-cliquer sur le fichier bgb.exe.
Si vous souhaitez lancer l'émulateur en ligne de commande, il faudra utiliser l'une des deux commandes suivantes en fonction de votre terminal :
Les deux commandes précédentes supposent que votre terminal est ouvert dans le dossier où se trouve l'exécutable de BGB.
En plus de simplement lancer l'émulateur en ligne de commande, il est possible de le lancer directement avec la ROM de votre jeu :
Enfin, une petite astuce : BGB intègre un mode « watch », qui permet de recharger automatiquement la ROM lorsqu'elle est modifiée (donc à chaque fois qu'on recompile le jeu pour le tester). C'est extrêmement pratique. Pour activer le mode « watch », il faut utiliser l'une des commandes suivantes :
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.
--------------------------------------------------------------------------------
📝️ Note:
--------------------------------------------------------------------------------
NOTE : Oui on va tout mettre dans le dossier du projet, y compris l'émulateur (qui va rajouter plein de bordel dedans quand on va le lancer...), je fais ça pour simplifier les commandes dans la partie suivante, libre à vous de vous organiser autrement si vous le préférez, mais il faudra alors adapter les commandes en fonction. 😉️
--------------------------------------------------------------------------------
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 :
Apperçu du dossier de projet une fois le fichier hello.c ajouté
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.
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 :
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.
Pour compiler notre exemple sous Linux, ou sous Windows si vous utilisez Git Bash, il faut commencer par ouvrir un terminal dans le dossier du projet, et y entrer les commandes qui vont suivre.
Comme vu plus tôt, la première chose à faire c'est de compiler les fichiers de code source. Dans notre cas, on n'en a qu'un : "hello.c". On va pouvoir le compiler avec la commande suivante :
./gbdk-n/bin/gbdk-n-compile.sh hello.c
Normalement, un certain nombre de fichiers ont été générés. Le seul qui nous intéresse pour le moment est "hello.rel".
Maintenant qu'on a compilé notre programme, il faut effectuer l'édition des liens. On va donc donner au linker l'ensemble des fichiers ".rel" qui composent notre programme... et vu qu'on n'en a qu'un, cela donne la commande suivante :
./gbdk-n/bin/gbdk-n-link.sh hello.rel -o hello.ihx
Si tout c'est bien passé, le fichier "hello.ihx" devrait avoir été créé (ainsi qu'un certain nombre d'autres fichiers qui ne nous intéressent pas pour le moment). On y est presque !
Il ne nous reste plus qu'à générer la ROM depuis notre fichier ".ihx" :
./gbdk-n/bin/gbdk-n-make-rom.sh hello.ihx hello.gb
Vous devriez à présent avoir votre ROM, nommée "hello.gb", dans le dossier courant.
Si vous utilisez Windows avec CMD.exe, les instructions pour compiler notre exemple sont sensiblement les mêmes que dans la section ci-dessus : seules les commandes diffèrent un peu.
Ainsi, pour compiler les fichiers de code source, la commande devient :
gbdk-n\bin\gbdk-n-compile.bat hello.c
Puis pour effectuer l'édition des liens, la commande sera :
gbdk-n\bin\gbdk-n-link.bat hello.rel -o hello.ihx
Et enfin pour générer la ROM, la commande devient la suivante :
gbdk-n\bin\gbdk-n-make-rom.bat hello.ihx hello.gb
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 :
Capture d'écran du programme s'exécutant dans 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 !
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/.
https://github.com/flozz/gameboy-examples/
Exemples pour GameBoy sur Github
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 :
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
Le dépôt « Awesome GameBoy Development » sur Github
La chaîne « Gaming Monsters » sur Youtube
--------------------------------------------------------------------------------
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é !
--------------------------------------------------------------------------------
