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

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

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 les nouveaux articles paraissent à un rythme d'environ un par mois.

Articles de la série :

Présentation de la GameBoy

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 !

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

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

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étro-compatible 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

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 était 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 grace à 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 Advance SP

GameBoy Micro

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

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

Cartouche de jeu GameBoy

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

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.

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.

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 signal sur Twitter que SDCC peut s'installer avec brew sur Mac OS X : brew install sdcc]

Linux

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

Windows

Si vous êtes sous Windows, il vous faudra télécharger la dernière version de SDCC sur le site officiel :

À 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 :

  • Sélectionnez « Full » comme type d'installation, et vérifiez bien que la case « SDCC GBZ80 library » est cochée.

    Capture d'écran montrant les choix à faire pendant l'installation
  • À la fin de l'installation, assurez-vous que la case « Add C:\... to the PATH » soit bien cochée, vous aurez des soucis pour compiler dans le cas contraire. 😉️

    Capture d'écran montrant la case à cocher pour rajouter le dossier de SDCC au PATH

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 :

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

    Capture d'écran montrant les boutons pour télécharger un dépôt en ZIP sur Github.

    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.

Linux

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

Windows

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 :

  • Si vous utilisez CMD.exe, tapez la commande suivante :

    make
    
  • Si vous utilisez Git Bash, tapez alors la commande :

    ./Make.bat
    

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

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 :

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 :

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.

Linux

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

Windows

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 :

  • si vous utilisez CMD.exe, entrez la commande suivante :

    bgb
    
  • si vous utilisez Git Bash, il faudra alors entrer la commande :

    ./bgb.exe
    

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 :

  • CMD.exe :

    bgb chemin\vers\votre\jeu.gb
    
  • Git Bash :

    ./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 l'une des commandes suivantes :

  • CMD.exe :

    bgb --watch chemin\vers\votre\jeu.gb
    
  • Git Bash :

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

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 :

Apperçu du dossier de projet

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

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.

Linux et Windows avec Git Bash

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.

Windows avec CMD.exe

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

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 :

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 !

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

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 :

  • 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 :


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