Pour faire des jeux demandant plus de ressources (tels que Jetpack Joyride, Fruit Ninja...) il est possible d'utiliser le langage C sur Graph 75.
Les programmes écrits en langage C ont le format .g1a (incompatible avec le .g1m, qui est un format basique), et sont appelés "addins".
Il est possible de mettre ces fichiers g1a dans une Graph 35 si on l'a tweakée.

Dans ce tutoriel, j'assumerai que vous connaissez déjà le C, et donc que vous êtes familiers avec le concept de structure, pointeurs, variables, etc.
Si ce n'est pas le cas, je vous invite à aller voir le tutoriel d'Openclassrooms : https://openclassrooms.com/courses/apprenez-a-programmer-en-c
Allez jusqu'à la fin du chapitre 2, la SDL ne vous servira pas ici.

Partie 1 : Installation des outils

Si vous êtes sous Linux, allez voir du côté de Gint. Sinon, vous êtes sous windows, et vous devrez donc installer le SDK de Casio. si vous avez un mac, je vous plains

Sous windows, vous utiliserez le SDK Casio. Lors de l'installation, ne le mettez pas dans un dossier avec des parenthèses tel que "Program Files (x86)" !

Certaines parties de ce tutoriel concernant les restrictions du C ne s'appliquent pas à Linux.

Partie 2 : Découverte du SDK

Une fois le SDK installé, ouvrez le. Vous aurez ça :


Nous allons commencer par créer un nouveau projet. Pour ce faire, faites : Project → New puis remplissez les champs.



Il vous dira "No program file could be found in the project! You might build the project first."
Ce message d'erreur indique qu'il n'y a pas de fichier .g1a (normal, on vient de le créer, et on n'a pas encore compilé).
Pour le compiler, appuyez sur "Project" puis faites "Rebuild All". Dans la fenêtre "Build", vous devriez avoir ça :



Si à la fin vous avez une erreur ressemblant à Invalid parameter specified in option "input" : ""C:\Program Files (x86)\CASIO\fx-9860G SDK\OS\FX\lib\setup.obj"" c'est que vous l'avez installé dans un dossier avec des parenthèses ! Refaites tout le tutoriel en lisant bien cette fois.

Ensuite, faites "Run" (ou F5) afin de faire tourner le programme dans l'émulateur intégré. Agrandissez un peu la fenêtre "Display" pour que l'écran s'agrandisse. Ensuite, allez dans le menu puis trouvez votre addin qui est tout en bas (ou tapez "A" pour y accéder directement, si vous êtes flemmard).



(ne faites pas attention à la skin rouge, j'ai tuné mon SDK)

Bref, maintenant on va modifier un peu le code. Allez dans le dossier où est votre projet. Vous devriez avoir ces fichiers :


MainIcon.bmp est un bitmap monochrome qui sera affiché dans le menu, éditez le pour créer l'icône de votre programme (paint suffit).

Ouvrez tutoriel.c avec votre éditeur de texte préféré (je conseille notepad++). Il est possible d'éditer le fichier directement depuis le SDK, mais il n'y a aucune coloration syntaxique et la police n'est même pas monospacée.

Ici, la fonction main() sera cette fonction :


C'est par cette fonction que votre programme commencera.
Les paramètres isAppli et optionNum ne vous serviront pas. En fait, un addin peut être lancé soit du menu principal, soit avec un E-act (qui a d'ailleurs disparu avec la mort de la 75+E, et qui de toute façon ne servaient à rien sauf à y mettre ses cours). Etant donné que votre addin sera toujours lancé depuis le menu principal, vous pouvez ignorer ces variables.

La première chose à noter est : il n'y a pas de printf(). Normal, la calculatrice n'a pas de notion de flux d'entrée et de sortie comme sur PC. Il faudra faire des "locate" comme en Basic. Ici, le locate est divisé en 2 parties : une fonction locate(int x, int y) qui place le curseur à la position x,y et Print(char* str) qui affiche le string à l'écran à la position du curseur.
Il n'y a pas non plus de scanf(), mais il ne vous manquera pas : j'imagine que vous voulez faire des jeux, or la plupart des jeux ne demandent pas de taper du texte.
Si vous avez besoin que l'utilisateur tape du texte, codez la fonction vous-même ou utilisez la librairie EasyInput.
Si vous avez besoin d'afficher un chiffre à l'écran, deux choix s'offrent à vous :
- Soit vous utilisez la fonction sprintf() qui s'utilise comme printf() mais avec un buffer, comme ceci :


- Soit vous utilisez une fonction itoa qui n'est pas dans la librairie C standard, mais la voici ci-dessous :


Je vous conseille la deuxième solution, sachant qu'utiliser sprintf() ajoute 30 ko à votre addin, ce qui est relativement beaucoup.
Attention à bien #include <stdio.h> si vous voulez utiliser sprintf(), car le compilateur du SDK ne vous fera absolument aucune erreur, il compilera et vous aurez une erreur quand vous lancerez l'addin.

Une autre différence importante est que ce qui est supporté est le C89. La différence majeure avec le C99 (que vous avez probablement utilisé dans le tutoriel) est la nécessité de déclarer des variables au tout début de la scope. Par exemple :


Cela veut aussi dire qu'on ne peut pas faire for (int i = 0; i < 20; i++), on est obligé de déclarer i avant la boucle for.

La fonction Bdisp_AllClr_DDVRAM() sert à clear (vider) le DD (Display Driver, c'est à dire l'écran) et la VRAM.
Pour savoir la différence entre le DD et la VRAM, imaginons que je doive tracer un sprite. Si je le traçais directement sur l'écran, on verrait le sprite se dessiner au fur et à mesure, et ça serait très moche.
Au lieu de ça, on trace le sprite sur la VRAM, puis on envoie la VRAM au DD lorsqu'on a fini de tracer.
Cet envoi de la VRAM au DD n'est pas automatique, il faut l'initier avec la fonction Bdisp_PutDisp_DD(). Certaines fonctions font ça automatiquement.

Enfin, la fonction GetKey(int *key) sert à attendre un input d'un joueur. Attention, cette fonction est bloquante, c'est à dire qu'elle arrête l'exécution du programme tant que l'utilisateur n'a pas appuyé sur une touche ; nous verrons par la suite d'autres fonctions qui ne sont pas bloquantes. À noter que GetKey met à jour le DD (il envoie la VRAM au DD).

Partie 3 : Utilisation de MonochromeLib

MonochromeLib est une librairie incontournable des programmeurs casio : elle améliore grandement la vitesse des fonctions de dessin (et donc les fps).
Téléchargez la en allant ici : https://www.planet-casio.com/Fr/logiciels/voir_un_logiciel_casio.php?showid=86
Vous aurez des fichiers MonochromeLib.c et MonochromeLib.h, déplacez les dans le dossier où est votre projet.
Ensuite, il faut les ajouter à votre projet. Dans le SDK, tout à gauche, faites un clic droit sur "Source Files", puis "Add", puis naviguez jusqu'à votre projet et sélectionnez les 2 fichiers (ctrl+clic).



Ouvrez le fichier MonochromeLib.h. Vous remarquerez des #define commentés : c'est pour éviter de prendre trop de place (sinon, des fonctions pas utilisées sont exportées dans l'addin, et ça l'alourdit inutilement).
Je vous conseille de décommenter celles là :



Enfin, dans tutoriel.c, ajoutez #include "MonochromeLib.h" puis remplacez le Bdisp_AllClr_DDVRAM() par ML_clear_vram().
Allez dans le SDK, faites "Project - > Rebuild All" (si c'est grisé, appuyez sur "Run" → "Stop"). L'addin devrait compiler normalement, et si vous lancez l'addin il devrait montrer la même chose que précédemment... mais un peu plus vite
À l'avenir, n'utilisez pas les fonctions de dessin natives à Casio, utilisez toujours celles de MonochromeLib (ML).

Partie 4 : Gestion des touches et de l'affichage

Pour gérer les appuis sur les touches, il existe 2 fonctions :
- GetKey() qui est bloquante et affiche automatiquement la VRAM à l'écran
- IsKeyDown() qui n'est pas bloquante et n'affiche pas la VRAM à l'écran.

Laquelle utiliser ? Tout dépend de si votre jeu est en temps réel ou non. S'il n'y a pas de temps réel (par exemple sur un menu), utilisez GetKey(). Lorsqu'il y a du temps réel, utilisez IsKeyDown().

Les valeurs des touches sont trouvables dans les fichiers PDF qui sont normalement dans le dossier d'installation du SDK (fichier "Key Code List.pdf").
Attention aux modifieurs (shift + alpha) qui peuvent retourner une valeur différente (ainsi, si l'utilisateur appuie sur shift+bas, ça donnera la valeur KEY_CTRL_PAGEDOWN au lieu de KEY_CTRL_DOWN).

Par exemple, voici une boucle de jeu où on peut déplacer un carré (pseudo-code) :



Quant aux fonctions d'affichage, il y a :
- ML_pixel() pour afficher un pixel
- ML_line() pour afficher une ligne
- ML_rectangle() pour afficher un rectangle, etc
Pour toutes les fonctions, regardez MonochromeLib.h, le nom est assez explicite.

Pour afficher du texte, il y a :
- Print(char *str), précédée d'un Locate(int x, int y) pour afficher d'une manière similaire à la fonction Locate du basic
- PrintRev qui fonctionne comme Print mais inverse les couleurs (blanc sur noir)
- PrintXY(int x, int y, char* str, int type) qui affiche str aux coordonnées x,y, en noir si type = 0, en blanc si type = 1
- PrintMini qui fonctionne comme PrintXY mais affiche avec la petite police (comme la fonction Text du basic)
- BetterFont, librairie permettant d'afficher une police avec des caractères customisés
À noter que ces fonctions utilisent le codage Casio, partiellement compatible avec l'ASCII.
Pour l'exemple, nous allons afficher "agréable".
Si vous faites Print("agréable"), vous aurez remarqué que ça affiche ceci :



Ou "agr able" si vous avez sauvegardé votre fichier en ANSI au lieu d'UTF-8.
Il faut donc se conformer au codage casio. Pour le connaître, allez dans le dossier d'installation du SDK, où il y a 5 fichiers pdf. Celui qui nous intéresse est le "Character Set".
À la page 6 du PDF, on voit que le codage de "é" est 0xE60A.

Pour insérer ces octets dans un string, nul besoin d'utiliser un éditeur hexadécimal pour modifier le fichier .c (ce qui pourra d'ailleurs provoquer des erreurs de compilation) : il faut utiliser l'escape hexadécimale \x, qui ne prend normalement que 2 chiffres en argument.
Notre ligne de code sera donc Print("agr\xE6\x0Aable").
Si on l'exécute, ça fait ça :



Quel est le problème ? Apparemment le compilateur considère que le \x prend jusqu'à 3 chiffres, et donc traduit en 0xE6 et 0x0Aa → 0xAA, et 0xE6AA correspond au point du milieu dans l'encodage casio.
Pour éviter ça, il faut savoir que les strings côte à côte sont concaténés automatiquement. Rajouter 2 guillemets suffit pour que le compilateur sache qu'il faut s'arrêter à 0A :
Print("agr\xE6\x0A""able")

Partie 5 : Les syscalls

Les syscalls (system calls) sont des fonctions inhérentes à l'OS. Casio n'a pas fait de doc là dessus, mais grâce aux travaux de Simon Lothar, la plupart des syscalls sont connus : https://bible.planet-casio.com/simlo/chm/v20/

Ces syscalls ne vous serviront sûrement pas, mais ils permettent par exemple de créer un dossier customisé dans la mémoire principale/secondaire, changer le contraste, etc.

Pour utiliser un syscall, il existe différentes manières. En voici une.
Créez un fichier syscalls.src, que vous ajouterez dans le projet (de la même manière dont vous avez ajouté MonochromeLib).
Mettez-y le code suivant :


Puis, lorsque vous voulez ajouter le syscall 0x123 que vous voulez appeler monSyscall, ajoutez le code suivant (en haut du code) :



Dans votre fichier .c, il vous suffira de faire monSyscall() (avec les arguments nécessaires bien entendu).

Partie 6 : Autres fonctionnalités du SDK

Je n'ai jamais utilisé ces fonctionnalités (à tort, ça m'aurait bien servi quand je programmais sur casio), mais elles pourraient vous être utiles.

Premièrement, le SDK possède des breakpoints, qui servent à arrêter l'exécution d'un programme afin de pouvoir mieux le débugger. Il est également possible de voir la valeur des variables dans les fenêtres "global variables" et "local variables".
Lors d'une erreur, il y a une fonction "trace" qui vous pointera sur la ligne de votre code qui a causé l'erreur.
Il est également possible de faire "Run" → "Trace Into", qui vous donne :



Très pratique pour débugger, sachant qu'on ne peut pas faire de printf.

L'onglet "View" permet d'accéder à un désassembleur, mais ne connaissant pas l'assembleur SH3 je ne peux pas dire grand chose là dessus (tutoriel d'initiation).
Il permet également :
- D'avoir une vue de la mémoire flash (très utile si on veut toucher au système avec des syscalls)
- D'avoir une vue de la heap, stack, et call stack
- D'avoir une vue des registres

À noter que vous avez 8 ko de RAM statique (où sont stockées entre autres les variables globales), 32 ko de stack (la ram statique empiète sur ces 32 ko), et 64 ko de heap (dont 256 ko supplémentaires sur les SH4, mais à accéder par pointeur explicite).

Important : le SDK génère par défaut des addins SH3, qu'il faut convertir en SH4 pour les nouvelles calculatrices (> 2012).

Liens utiles :
Erreurs de compilation du SDK
Rendre le SDK compatible SH4 par défaut
Convertisseur SH3 → SH4 (ne fonctionne pas parfaitement dans le cas de syscalls touchant au clavier ou à l'écran)