Il y a quelques jours, dans deux
précédents articles, je te présentais mon adaptation du mini-jeu
WHIS pour en faire un jeu compatible avec la
NumWorks, sous la forme d'une version
Epsilon et d'une version un peu améliorée qui ne fonctionne qu'avec
Upsilon, ainsi qu'une version
Casio Graph Math+ qui profite de la grande mémoire de travail de son application Python.
Pour présenter très succintement le jeu : c'est un jeu de cartes qui se joue à 4 joueurs dans sa version originale (c'est un mini-jeu du jeu
Tales of Eternia) et dont le principe ressemble beaucoup au jeu du
UNO, mais en remplaçant les chiffres par les éléments
Eau,
Feu et
Vent. Le but est de réussir à jouer toutes les cartes de sa main avant que les autres joueurs ne fassent de même avec leurs cartes.
Voici un aperçu des 14 cartes du jeu :
Une présentation assez complète du jeu, des règles et des cartes est consultable dans l'
article qui présente les versions
NumWorks du jeu.
Après avoir fait une version NumWorks Epsilon, une version NumWorks Upsilon et une version Casio Graph Math+, il était impensable de ne pas faire une version Casio Graph 90+E !
D'autant plus que cette dernière à toutes les fonctions de la Casio Graph Math+. Enfin, toutes, non, pas tout à fait !
Ces deux calculatrices ont des
capacités matérielles remarquables et en particulier une grande mémoire de stockage et une grande mémoire de travail (
) mais leur
implémentation de Python est malheureusement
incomplète.
En effet, elles ne gèrent pas les caractères accentués ou avec une cédille. Ceux-ci ont donc été retirés, jusqu'à amélioration de la situation. Mais ce n'est pas le plus important.
De plus, elles sont dépourvues du module
time et la
Graph 90+E, contrairement à la
Graph Math+, est également dépourvue de la fonction
getkey(). Cette fonction permet de gérer en temps réel l'appui sur les touches de la calculatrice et son abscence complique cruellement la conception de jeux graphiques nécessitant une interaction avec le joueur !
Sans
getkey(), toute interaction implique de quitter l'interface graphique, de poser une question puis de traiter la réponse après validation (ou alors il faut ruser, comme le fait
critor en interceptant l'instruction d'arrêt du script générée par l'appui sur la touche
AC/ON, la
seule touche qui est reconnue, ce qui est fonctionnel mais malgré tout assez peu ergonomique
).
Mais
la légende raconte qu'un add-in permet de lancer des jeux Python sur les Casio Graph 90+E avec un affichage très rapide et la possibilité d'utiliser les modules Python de la NumWorks.Cet add-in est en fait
PythonExtra. Nous le devons au travail remarquable de la communauté de
Planète-Casio et en particulier de
Lephe.
Et c'est à notre cher et talentueux
SlyVTT que nous devons l'intégration des modules de la
NumWorks dans la
version 0.3.0 de cet add-in, qui permet maintenant de profiter de l'ensemble des scripts et jeux de la
NumWorks directement sur la
Graph 90+E.
Qui plus est, il est tout à fait possible de créer un jeu Python en utilisant à la fois des modules Python de
Casio portés dans
PythonExtra, des modules Python de
NumWorks portés dans
PythonExtra mais également des modules Python propres à
PythonExtra, tels que
gint.
On peut, par exemple, importer la fonction
sleep du module
time qui permet de faire une pause de durée déterminée dans l'exécution d'un script, et au passage remplacer le bricolage de recodage de cette fonction que j'ai utilisé dans la version
Graph Math+.
Ce formidable add-in
PythonExtra fournit toutes les fonctions qui manquent pour pouvoir adapter la version
Graph Math+ du jeu
WHIS en une version
Graph 90+E !
Petite précision qui a toute son importance : le jeu doit être exécuté depuis l'add-in pour fonctionner correctement.
La simple importation de la fonction
getkey() du module
ion de
NumWorks suivie du remplacement des
getkey() par des
keydown() en adaptant le nom des touches permet de rendre le jeu exécutable sur la
Graph 90+E avec
PythonExtra !
Il y a donc tout ce qu'il faut sur la
Graph 90+E pour y faire fonctionner mon adaptation du jeu
WHIS !
Cependant, l'affichage est alors extrèmement lent et l'image de l'écran de titre met environ 2 min pour être affichée, dans un lent déroulement qui rappelle un rideau qui descend.
Va-t-il falloir renoncer à cette belle image ?
L'image de l'écran de titre de la version
Graph Math+ du jeu
WHIS fait 185×185 pixels et elle est encodée puis tracée pixel par pixel avec la commande
set_pixel du module
casioplot. Si l'affichage de cette image prend 6 ou 7 secondes sur la
Graph Math+, il prend tout de même près de 2 min sur la
Graph 90+E que ça soit avec la version
kandinsky (sans double buffering, donc avec effet rideau qui descend) ou avec la version
casioplot (avec double buffering) de la fonction
set_pixel !
Pour le jeu
Orlog, l'image de l'écran de titre (la tête de loup) ne comporte que 4 couleurs et il aurait été possible de modifier l'encodage de l'image pour la traiter ligne par ligne en stockant chaque ligne sous forme de rectangles dont il faudrait seulement conserver la couleur et la longueur (c'est d'ailleurs la méthode effectivement retenue pour les images des divinités et qui accélère beaucoup leur affichage !). Pour l'image de l'écran de titre du jeu
WHIS, il y a bien plus de 4 couleurs et il n'est pas forcément pertinent et efficace de stocker l'image sous forme de rectangles, la plupart des rectangles ayant une longueur de 1 pixel.
Il a donc fallu trouver une parade pour ne pas avoir à renoncer à ce bel écran de titre (ou à deux minutes de notre temps à chaque lancement du jeu) !
C'est notre cher
SlyVTT qui a trouvé une solution en proposant de faire appel aux fonctions de dessin du module
gint de
PythonExtra. Ce module permet en effet d'encoder des images de différentes manières suivant le nombre de couleurs souhaitées et l'espace dont on dispose pour la longue chaîne de caractères qui résulte de l'encodage de l'image.
Ensuite, chaque image est tracée à la position souhaitée avec la commande
dimage(x,y,IMAGE) où IMAGE est le nom de la variable qui stocke (entre autres) la chaîne de caractères générée lors de l'encodage de l'image et x et y sont les positions horizontales et verticales où on souhaite placer le coin supérieur gauche de l'image.
Armé de son courage, de son talent et de sa patience, notre cher et talentueux
SlyVTT a encodé toutes(!) les images du jeu (28 pour les visages + 14 cartes + 3 éléments + la pioche + l'image de titre) en un format géré par
gint et ses fonctions de dessin ! Sans entrer dans les détails, cet encodage se fait avec une ligne de commande (par image) qui nécessite d'avoir le
fxSDK installé sur son ordi. Bravo pour le petit script brillamment pensé pour automatiser le traitement et merci beaucoup pour ce grand coup de pouce !
Qui plus est,
gint utilise le double buffering, ce qui signifie qu'on peut afficher une image puis préparer l'image suivante sans l'afficher et ne l'afficher que lorsqu'on le souhaite, avec la commande
dupdate() (ce qui équivaut à la commande
show_screen() du module
casioplot qui utilise aussi le double buffering).
En utilisant les fonctions de dessin du modeul
gint et l'encodage des images qui convient, l'affichage de l'image de titre ne prend plus que 6 ou 7 secondes au lieu de 2 min !
Toutefois, remplacer les quelques lignes de la fonction
IMG que j'ai codée pour décoder et afficher les images dans la version
Graph Math+ par un simple
dimage(x,y,carte) n'était pas fonctionnel.
En effet, j'ai utilisé un dictionnaire (un des types d'objets Python) pour faire l'association entre le nom d'une carte (une chaîne de caractères de 3 lettres) et la chaîne de caractères qui contient de manière codée les données de l'image correspondante. Ma fonction
IMG utilise alors le nom de la carte sous forme d'une chaîne de caractères pour aller chercher (dans le dictionnaire
Image) les données à afficher.
Le souci est que
gint utilise des noms de variable pour aller chercher les données à afficher, et non pas des noms sous forme de chaîne de caractères.
Pour transformer un nom de variable en chaîne de caractères, il suffit d'utiliser la commande
str(). Par exemple, pour transformer
Pio en
"Pio", il suffit d'utiliser la commande
str(Pio) dans laquelle on peut remplacer le nom Pio par ce que l'on souhaite, y compris de manière automatique pour le nom de chaque carte.
En revanche, dans mon cas j'ai besoin de faire la réciproque ! Le nom des
Cartes est une chaîne de caractères et la fonction
dimage() attend comme paramètre un nom de variable. Je n'ai pas trouvé d'autre solution que de créer un dictionnaire qui, à un nom écrit sous forme d'une chaîne de caractères, associe un nom de variable. En fait, le nom de variable est le même que la chaîne de caractères mais sans les guillemets.
Ce qui ressemble à ça :
- Code: Select all
def sansguillemet(carte):
return {'Vsi':Vsi, 'Vtq':Vtq, 'Vsp':Vsp, 'Esi':Esi, 'Etq':Etq, 'Esp':Esp, 'Fsi':Fsi, 'Ftq':Ftq, 'Fsp':Fsp, 'Tev':Tev, 'Tvf':Tvf, 'Tfe':Tfe, 'Lum':Lum, 'Obs':Obs, 'Pio':Pio, 'Eau':Eau, 'Feu':Feu, 'Vent':Vent, "Reid_content":Reid_content, "Reid_content_yeux":Reid_content_yeux, "Reid_content_yeux_fermes":Reid_content_yeux_fermes, "Reid_neutre":Reid_neutre, "Reid_neutre_yeux":Reid_neutre_yeux, "Reid_neutre_yeux_fermes":Reid_neutre_yeux_fermes, "Reid_boude":Reid_boude, "Reid_boude_yeux":Reid_boude_yeux, "Reid_boude_yeux_fermes":Reid_boude_yeux_fermes, "Farah_contente":Farah_contente, "Farah_neutre":Farah_neutre, "Farah_neutre_yeux":Farah_neutre_yeux, "Farah_neutre_yeux_fermes":Farah_neutre_yeux_fermes, "Farah_boude":Farah_boude, "Farah_boude_yeux":Farah_boude_yeux, "Farah_boude_yeux_fermes":Farah_boude_yeux_fermes, "Meredy_contente":Meredy_contente, "Meredy_neutre":Meredy_neutre, "Meredy_neutre_yeux":Meredy_neutre_yeux, "Meredy_neutre_yeux_fermes":Meredy_neutre_yeux_fermes, "Meredy_boude":Meredy_boude, "Keele_content":Keele_content, "Keele_content_yeux":Keele_content_yeux, "Keele_content_yeux_fermes":Keele_content_yeux_fermes, "Keele_neutre":Keele_neutre, "Keele_neutre_yeux":Keele_neutre_yeux, "Keele_neutre_yeux_fermes":Keele_neutre_yeux_fermes, "Keele_boude":Keele_boude, "Titre":Titre}[carte]
L'affichage d'une carte est alors demandé avec la commande
IMG(20,50,sanguillemet("Esp")) pour afficher la carte
Eau
spéciale, c'est-à-dire
Prisme.
Un autre point qui ne me permettait pas de simplement retirer les guillemets de tous mes noms de carte est que la fonction
animation qui s'occupe de l'animation des visages des personnages concatène des chaînes de caractères pour aller chercher la bonne image à afficher. Sans utiliser de guillemets, je ne sais pas comment réassembler ces morceaux de chaînes de caractères pour former un nom de variable pour ensuite aller chercher la bonne image.
La fonction
IMG qui s'occupe de l'affichage des images comporte également un paramètre
affichage qui permet de ne pas systématiquement afficher l'image générée. Lorsqu'on veut afficher l'écran de fin de manche ou de fin de partie, par exemple, il est souhaitable d'afficher l'image une fois que le visage des quatre personnages est généré, sans montrer l'affichage successif de chacun des visages.
Petite remarque : le module
gint permet également d'importer une fonction
getkey() pour la reconnaissance de l'appui sur les touches, mais son utilisation ne m'est pas du tout familière, contrairement à la fonction
keydown du module
ion de
NumWorks. C'est donc cette dernière que j'ai utilisée.
Finalement, les versions
Graph Math+ et
Graph 90+E + PythonExtra de mon adaptation du jeu
WHIS sont identiques pour ce qui est de la jouabilité et sont quasiment identiques visuellement, à réorganisation près des différents éléments affichés. En effet, le Python de la
Graph Math+ donne accès à une zone graphique de 384×192 pixels tandis que
PythonExtra utilisé sur la
Graph 90+E donne accès à une zone graphique de 396×224 pixels (et il aurait été dommage de se priver de cet espace supplémentaire) !
Ce qui nous donne donc, tout comme dans la version pour la
Graph Math+ :
- Un bel écran de titre au lancement du jeu.
- Un jeu entièrement bilingue avec deux langues : français et anglais
- Un écran d'accueil coloré qui montre quelques unes des cartes du jeu et qui propose d'en savoir plus sur les Cartes, d'en savoir plus sur les Règles ou de lancer une partie avec Jeu .
- Un menu Cartes qui montre chacune des 14 cartes du jeu et qui donne quelques explications les concernant
- Un menu Règles qui explique les règles du jeu tout en présentant les cartes par élément.
- La possibilité de choisir le nombre de joueurs humains lorsqu'on lance une partie
- La possibilité de choisir les personnages attribués aux joueurs humains, dans le cas d'un nombre compris entre 1 et 3.
- Dans le cas du choix de 0 joueur humain, le choix d'afficher ou non les cartes de chacun des 4 joueurs gérés par la machine lorsque c'est son tour de jouer
- Dans le cas d'un choix d'au moins 2 joueurs humains, la nécessité d'appuyer sur EXE pour afficher les cartes du joueur dont c'est le tour, pour plus de discrétion.
- Un affichage simple sous la forme d'un cadre coloré qui entoure le visage et le score des personnages et qui indique de quel joueur c'est le tour de jouer (cadre violet) et ensuite s'il joue (cadre vert) ou pioche (cadre rouge) une carte.
- Un cadre rouge qui entoure la pioche et montre le nombre de cartes piochées.
- Dans le cas de l'utilisation d'une carte Lumière, Obscurité ou Prisme, un menu de choix de l'élément demandé au joueur suivant.
Ici, Farah joue une des deux cartes Lumière qu'elle a en main (la 2ème se voit à peine) puis choisit Feu. Ensuite, ses cartes sont redessinées et on voit la carte Lumière qu'il lui reste. - Un écran de fin de manche qui résume les scores de chaque joueur
- Un écran de fin de partie qui résume, en couleurs, les scores obtenus par chaque joueur et qui propose de relancer une partie sans même devoir quitter le jeu.
Au fait, comment joue-t-on ?- On utilise les flèches gauche et droite pour sélectionner une carte ou l'élément demandé dans le cas de l'utilisation des cartes Prisme, Lumière ou Obscurité.
- On valide avec EXE ou F1.
- On pioche volontairement ou on passe son tour volontairement avec la touche Shift.
Et comment lance-t-on le jeu ?Pour jouer à cette version spécialement améliorée, il faut d'abord copier l'add-in
PythonExtra sur la
Graph 90+E puis copier le script Python du jeu. Ensuite, depuis la calculatrice, il faut lancer
PythonExtra puis aller chercher le script Python dans l'arborescence et le lancer.
Bon jeu !
Téléchargements : 
by 
La Graph 90+E est un superbe modèle de calculatrice graphique à écran couleur et programmable en Python que Casio a sorti en France pour la rentrée 2017.
Pour cette rentrée 2024 en France, Casio remplace la Graph 90+E de rentrée 2017 par un tout nouveau modèle couleur programmable en Python, la Graph Math+.
Par la suite, nous découvrions également que le modèle australien succédant à la fx-CG50AU allait s'appeler pour sa part fx-1AU GRAPH, et te révélions à cette dernière occasion leurs nouveaux visuels trouvés dans l'émulateur Graph Math+ pour clé USB, apparemment avec des boîtiers en thème sombre à l'opposé de la Graph Math+.
Les choses se concrétisent enfin, Casio Amérique vient toujours de promettre l'annonce d'une nouvelle génération de calculatrices graphiques à l'occasion du congrès NCTM à Chicago les 26 et 27 septembre prochains, avec une image de teasing ne laissant malgré l'ombrage aucun doute sur le fait qu'il s'agira de la fx-CG100.
Et l'actualité ne s'arrête pas là, c'est aujourd'hui au tour de Casio Australie d'officialiser la sortie de la fx-1AU GRAPH, avec une disponibilité annoncée pour Juillet 2025 (cela n'empêche pas que ce pourrait être plus tôt pour la fx-CG100 internationale, l'Australie ayant un calendrier scolaire décalé puisqu'étant dans l'hémisphère Sud, allant de fin Janvier à début Décembre).
