TI-Planet

de **Admin** » 26 Avr 2020, 12:49

Avant l'avènement des calculatrices graphiques, c'est Nintendo qui lança le tout premier jeu électronique de poche muni d'un écran LCD (cristaux liquides) exploitant les deux dimensions, Ball en avril 1980. Comme indiqué par sa référence AC-01, c'était le premier né de la gamme Game & Watch, largement imitée au siècle dernier par d'autres constructeurs asiatiques pour le meilleur et pour le pire. Au lieu de simples points, les pixels ici allumés à l'écran ont des formes représentant des éléments du jeu.

En 2016, Fenysk avait déjà rendu un bel hommage à ces produits avec une adaptation pour ta Graph 35/75+E de Helmet, sorti en février 1981 sous la référence CN-07, soit le 7^ème jeu de la gamme. Il est à noter que le jeu fut renommé Headache pour sa commercialisation dans plusieurs zones d'Europe, le mot anglais Helmet (casque) se retrouvant sous à l'identique en allemand et renvoyant donc aux heures sombres de l'Europe.

Jouer à des jeux pour t'occuper en confinement c'est bien, mais les créer c'est encore mieux non ?

Et bien justement Schraf se propose aujourd'hui de t'accompagner pas à pas dans l'adaptation d'un autre titre de la mythique gamme Game & Watch, Fire, mais pour ta NumWorks en tirant profit du nouveau module ion permettant enfin de détecter les appuis clavier !

Le jeu est initialement sorti en juillet 1980 en tant que 4^ème jeu de la gamme sous la dénomination RC-04.
Mais à l'époque, les décors de couleur (éléments graphiques fixes) devaient soit être de gros pixels allumés en permanence et donc consommateurs d'énergie, soit être imprimés directement sur l'écran soit au premier plan. Tu comprendras donc aisément pourquoi ils n'étaient présents qu'avec parcimonie.

A compter de 1981, Nintendo commence à intégrer des décors directement à l'intérieur de l'écran soit à l'arrière plan, et Fire bénéficie à cette occasion d'une réédition en décembre 1981 sous la référence FR-27.

C'est sur cette dernière édition que Schraf te propose de travailler.

A l'aide, l'immeuble est en flammes et les habitants se jettent dans le vide. Afin qu'ils ne se blessent pas tu dois amortir leur chute. Pour cela tu contrôles donc une paire de pompiers et devrais faire rebondir les sinistrés jusque dans l'ambulance.

Bien évidemment la difficulté augmentera progressivement, avec des habitants qui seront de plus en plus nombreux à sauter simultanément.

La NumWorks ne disposant hélas pas encore de fonctions Python dédiées à l'affichage de sprites, ces derniers seront tout sauf instantanés si effectués pixel par pixel, ce qui impactera négativement le gameplay.

En attendant mieux, Schraf se propose de contourner ce problème en remplaçant les sprites par des caractères, à la différence affichables instantanément grâce à la fonction dédiée kandinsky.draw_string().

C'est parti :

As-tu bien compris ?

Alors Schraf te met maintenant au défi d'adapter toi-même Parachute, jeu de référence PR-21 sorti dans la même gamme en juin 1981.

Petit playthrough pour t'y aider, fais-nous du beau :

Installation : https://workshop.numworks.com/python/schraf/firegw

Crédits images :

de **Admin** » 19 Avr 2020, 15:14

«L'urgent est déjà fait, l'impossible est en train de se faire, pour les miracles nous demandons 48 heures.»

Voilà qui résume bien la vie fertile de M4x1m3 en période de confinement.

Ce dernier vient en effet de porter en seulement deux jours le simulateur NumWorks pour la console de jeux portable Nintendo 3DS.

Il utilise l'écran supérieur pour l'affichage et l'écran tactile inférieur pour les touches clavier, réorganisées à cette fin.

Grâce à M4x1m3, tu vas donc enfin pouvoir jouer à la NumWorks sur ta Nintendo 3DS !

Téléchargement : archives_voir.php?id=2619353

Code source : https://github.com/numworks/epsilon/pull/1528

Source : viewtopic.php?f=102&t=23726&p=252521#p252521

de **Admin** » 19 Avr 2020, 11:27

Les capacités Python de ta calculatrice NumWorks ont été fortement étendues dernièrement.

D'une part, la version 13.1.0 a introduit en Python un nouveau module ion permettant de tester les appuis de touches.
Cela devrait t'être fort utile pour coder tes jeux et interfaces de menus !

D'autre part, le MicroPython de ta calculatrice utilise 3 types de mémoire avec les rôles suivants :

la mémoire de stockage qui accueille et conserve tes scripts Python
le stack (pile) qui, à l'exécution, accueille les références vers les objets Python créés
le heap (tas) qui, à l'exécution, accueille les valeurs de ces objets Python

En gros le stack / pile limite donc le nombre d'objets différents pouvant exister simultanément en mémoire, alors que le heap / tas limite la taille globale occupée par ces objets.
A moins d'avoir de gros besoins en terme de récursivité, le facteur limitant pour tes projets Python sur calculatrice est habituellement le heap / tas.
Or depuis la version 13.2.0, le heap / tas Python de ta NumWorks a doublé, passant de 16K à 32K.

Dans un article précédent, cent20 et ses disciples se proposaient de t'illustrer ces nouvelles possibilités dans le cadre du développement de jeux Python, avec :

des graphismes que l'on peut désormais prendre le temps de soigner au pixel près sans craindre l'erreur de mémoire
et une bibliothèque offrant une interface de menu de lancement contrôlée intuitivement à l'aide des touches fléchées

Cette dernière bibliothèque est de plus réutilisable pour tes propres projets de jeu Python sur NumWorks, elle se charge d'absolument tout ce qui précède le lancement de ta partie. Il te suffit d'un simple appel à la fonction menu() en lui fournissant dans l'ordre :

titre du jeu
texte du bouton de lancement
des listes comportant un nom suivi de une ou plusieurs valeurs qui te permettent astucieusement de traiter par exemple :
- aussi bien les choix disponibles pour une ou plusieurs options (difficulté, niveau de départ, ...)
- que l'affichage d'une ligne d'aide avec les différentes touches de contrôle, défilables de la même façon qu'une option avec les touches fléchées
- ou encore l'affichage des différents auteurs, là encore défilables de la même façon

La fonction te retourne alors automatiquement les valeurs choisies par l'utilisateur pour chaque option, tu n'as rien d'autre à faire !

Voici par exemple la simple ligne d'appel qui produit l'interface ci-dessus :

Code: Tout sélectionner: mode, dif, bor = menu("SNAKE", "Lancer la partie", ["Mode", "Classique", "Dingue"], ["Difficulté", "Moyen", "Difficile", " Extrême", "Facile"], ["Bordures", "Mortelles", "Téléportation"], ["Commandes", " Nav: Flèches", "Menu: HOME", "Rejouer: OK"], ["Crédits","Arthur J.","Vincent R."])

Aujourd'hui, cent20 revient à son tout premier jeu NumWorks exploitant le nouveau module ion, le jeu du Démineur.

cent20 te met donc justement à jour ce Démineur avec cette nouvelle interface de lancement, te donnant ainsi accès beaucoup plus intuitivement à toute la richesse de gameplay offerte par les options !

Voici la ligne d'appel correspondante, regarde comme c'est simple :

Code: Tout sélectionner: mines, triche, graphisme, com, cre = menu("Démineur", "Lancer la partie [OK]", ["Mines", 16, 19, 22, 25, 28, 31, 33, 36, 39, 42, 7, 10, 13], ["Mode Triche", "1 fois", "non", "oui"], ["Graphisme", "sobre", "classique"], ["Commandes", "Nav: Flèches", "Déminer: OK", "Drapeau: Retour", "Rejouer: Maison", "Triche: shift"], ["Crédits", "Site web$nsi.xyz/demine", "Auteur$Vincent Robert", "Contributeur$Bisam tiplanet.org", "Contributeur$Critor tiplanet.org", "Contributeur$Arthur Jacquin"])

Liens :

Téléchargements :

menu (vierge - à importer et appeler correctement pour tes projets)
menu (démonstration)
Démineur
Snake

de **Admin** » 19 Avr 2020, 00:10

Cela t'a peut-être échappé, mais les capacités Python de ta NumWorks ont été fortement étendues dernièrement.

D'une part, le MicroPython de ta calculatrice utilise 3 types de mémoire avec les rôles suivants :

la mémoire de stockage qui accueille et conserve tes scripts Python
le stack (pile) qui, à l'exécution, accueille les références vers les objets Python créés
le heap (tas) qui, à l'exécution, accueille les valeurs de ces objets Python

En gros le stack / pile limite donc le nombre d'objets différents pouvant exister simultanément en mémoire, alors que le heap / tas limite la taille globale occupée par ces objets.
A moins d'avoir de gros besoins en terme de données ou de récursivité, le facteur limitant pour tes projets Python sur calculatrice est habituellement le heap / tas.
Or depuis la version 13.2.0, le heap / tas Python de ta NumWorks a doublé, passant de 16K à 32K.

D'autre part, la version 13.1.0 a introduit en Python un nouveau module ion permettant de tester les appuis de touches.
Cela devrait t'être fort utile pour coder tes jeux et interfaces de menus !

Mais jeux et interfaces de menus, les deux choses sont liées.

C'est quoi un jeu ? Algorithmiquement, on peut le définir en tant que boucle qui répère 3 choses à l'infini :

lecture des entrées (clavier, souris, joystick, tactile, réseau...)
traitement avec mise à jour des variables codant l'état du jeu
mise à jour de l'affichage

Mais ça c'est en cours de partie. Avant le démarrage de la partie, un jeu c'est aussi justement un menu permettant de choisir nombre d'options (difficulté, niveau de démarrage, options d'affichage, ...).

cent20 et ses disciples Arthur_Jacquin et Golden Man se proposent justement ce soir de t'illustrer les formidables nouvelles capacités de la NumWorks, à la fois en terme de jeux et d'interfaces de menus, au pluriel note-le bien.

Grand fan du Python, cent20 a poussé Arthur_Jacquin à nous commencer bien évidemment par un Snake, le jeu du serpent, dont voici ci-contre l'interface de lancement.
Grâce au nouveau module ion, les touches fléchées te permettent intuitivement de sélectionner et modifer les différentes options, et on apprécie également l'affichage d'une aide avec les touches à utiliser ainsi que du nom du jeu et de l'auteur.

Comme tu le vois maintenant en cours de partie et comme déjà montré, le nouveau tas / heap de 32K permet beaucoup plus de libertés et désormais le travail des graphismes au pixel près, sans avoir à craindre l'erreur de mémoire !

Et voici maintenant comme promis un 2^ème jeu, cette fois-ci du calcul mental par Golden Man, une fois de plus aux graphismes remarquablement soignés.

Mais voyons un petit peu l'interface de lancement de ce 2^ème, car peut-être n'as-tu pas percuté plus haut. Elle est très similaire à celle du Snake, non ? Avec juste les noms et valeurs qui changent...

Car en effet, c'est littéralement une bibliothèque très complète d'interface de lancement de jeu que cent20 et Arthur_Jacquin t'ont développée, et que tu peux réutiliser clé en main pour tes propres jeux !

Il te suffit de lui fournir dans l'ordre :

titre du jeu
texte du bouton de lancement
des listes comportant un nom suivi de une ou plusieurs valeurs qui te permettent astucieusement de traiter par exemple :
- aussi bien les choix disponibles pour une ou plusieurs options
- que l'affichage des différentes touches de contrôle, défilable de la même façon qu'une option avec les touches fléchées
- ou encore l'affichage des différents auteurs, là encore défilable de la même façon

Rien de compliqué, un simple appel de fonction et la bibliothèque se charge de tout !

Par exemple, voici l'appel correspondant au jeu Snake :

Code: Tout sélectionner: mode, dif, bor = menu("SNAKE", "Lancer la partie", ["Mode", "Classique", "Dingue"], ["Difficulté", "Moyen", "Difficile", " Extrême", "Facile"], ["Bordures", "Mortelles", "Téléportation"], ["Commandes", " Nav: Flèches", "Menu: HOME", "Rejouer: OK"], ["Crédits","Arthur J.","Vincent R."])

Mais pas de défilement vertical par contre à ce jour si on spécifie plus de 5 listes nom+valeurs. Peut-être pour une prochaine fois ?

Et voici celui correspondant au jeu de calcul mental :

Code: Tout sélectionner: mode, ope, dif, rep = menu("Automatismes en calcul mental", "Calculer [OK]", ["Mode", "Classique", "Rapide"], ["Opération(s)", "+", "-", "x", "/", "+ -", " x / ", "+ - x", "+ - x /"], ["Difficulté", " modéré", "difficile", "expert", "facile"], ["Répétition", 42, 50, 100, 120, 20], ["Crédits", "Site web$nsi.xyz/calcul", "Auteur$Kevin Fedyna", "Contributeur$Vincent ROBERT"])

Enfantin, n'est-ce pas ?

N'hésite pas à aller consulter ci-dessous les pages de ces 3 projets, débordantes de détails passionnants à dévorer.

Et en attendant ta prochaine création, jusqu'à combien arrives-tu à faire grandir ton serpent ?

Liens :

Téléchargements :

menu (vierge - à importer et appeler correctement pour tes projets)
menu (démonstration)
Snake
Calcul Mental

de **Admin** » 15 Avr 2020, 00:36

Casio a sorti la semaine dernière des mises à jour 3.30 et 3.40 pour ses Graph 35+E II et Graph 90+E, avec un nouveau module Python casioplot te permettant de contrôler les pixels de l'écran. Pour te donner une référence, c'est donc l'équivalent du module kandinsky chez NumWorks.

Des possibilités déjà fort bien exploitées sur Graph 90+E par LightMare avec un script Python de rendu 3D en raytracing !

Malheureusement, une fois les appels graphiques corrigés ce même script ne marchait pas sur la NumWorks, déclenchant une erreur de mémoire.

Pourquoi ?

Il faut savoir que dans le cadre du MicroPython ou similaire des calculatrices il y a 3 types de mémoire avec les rôles suivants :

la mémoire de stockage qui accueille et conserve tes scripts Python
le stack (pile) qui, à l'exécution, accueille les références vers les objets Python créés
le heap (tas) qui, à l'exécution, accueille les valeurs de ces objets Python

En gros le stack / pile limite donc le nombre d'objets différents pouvant exister simultanément en mémoire, alors que le heap / tas limite la taille globale occupée par ces objets.

L'appel mem() avec le script mem.py suivant permet justement d'estimer la capacité du heap / tas :

Code: Tout sélectionner: def sizeenv(): s=0 import __main__ for o in dir(__main__): try:s+=size(eval(o)) except:pass return s def size(o): s,t=0,type(o) if t==str:s=49+len(o) if str(t)=="<class 'function'>":s=136 if t==int: s=24 while o: s+=4 o>>=30 if t==list: s+=64 for so in o:s+=8+size(so) return s def mem(v=1,r=1): try: l=[] try: l+=[r and 793+sizeenv()] if v*r:print(" ",l[0]) l+=[0] l+=[""] l[2]+="x" while 1: try:l[2]+=l[2][l[1]:] except: if l[1]<len(l[2])-1:l[1]=len(l[2])-1 else:raise(Exception) except: if v:print("+",size(l)) try:l[0]+=size(l) except:pass try:l[0]+=mem(v,0) except:pass return l[0] except:return 0

Aux examens français :

1,032942 Mo :
Casio Graph 90+E
1,022145 Mo :
HP Prime (version alpha)
100,560 Ko :
Casio Graph 35+E II
32,339 Ko
NumWorks (firmware Omega)
31,624 Ko
NumWorks
20,200 Ko
TI-83 Premium CE Edition Python

En classe :

2,049276 Mo :
TI-Nspire (appli MicroPython)
1,032942 Mo :
Casio Graph 90+E
Casio fx-CG50
1,022145 Mo :
HP Prime (version alpha)
257,636 Ko :
Casio Graph 35/75+E
Casio Graph 35+USB SH4
Casio Graph 75/95 SH4
Casio fx-9750/9860GII SH4
(appli CasioPython)
100,560 Ko :
Casio Graph 35+E II
Casio fx-9750/9860GIII
31,899 Ko :
Casio Graph 35+E II
Casio Graph 35+USB SH3
Casio Graph 75/95 SH3
Casio fx-9750/9860GIII
Casio fx-9750/9860GII SH3
Casio fx-9860G
(appli CasioPython)
32,339 Ko
NumWorks (firmware Omega)
31,624 Ko
NumWorks
22,605 Ko
TI-83 Premium CE + TI-Python (firmware tiers)
20,200 Ko
TI-83 Premium CE Edition Python (version 5.4)
19,924 Ko
TI-83 Premium CE + TI-Python
17,954 Ko
TI-83 Premium CE Edition Python (version 5.5)

La différence devrait te sauter aux yeux, la Graph 90+E a plus de 1 Mo de heap / tas et la NumWorks autour de 32 Ko.

Ce n'est pas la taille du script qui compte, mais elle donne un point de repère. Le script de raytracing original faisait 14 Ko.

Nous avons optimisé l'écriture de ce script et réussi à en réduire la taille à seulement 4,5 Ko soit à peine le tiers de la taille initale, et maintenant ça passe parfaitement sur NumWorks !

Nous avons de plus commencé à développer et rajouté une classe de compatibilité graphique polyscr qui permet au même script Python de contrôler les pixels de l'écran aussi bien sur Casio Graph 90/35+E II que NumWorks ou TI-Nspire CX Ndless !

Pas besoin de réécriture, la classe intercepte et traite les appels graphiques prévus respectivement pour casioplot, kandinsky et nsp, et ça marche !

Cela devrait permettre à chacun de pouvoir développer des scripts Python graphiques compatibles avec l'ensemble des modèles, à commencer par nous pour un éventuel concours de rentrée 2020.

Le script aura juste à tenir compte quelque part du nombre de pixels de l'écran, information que la classe permet justement de récupérer.

Le script tourne sur Graph 35+E II, mais son écran ne gère pas les niveaux de gris. Chaque pixel donne donc du noir ou du blanc selon la couleur qui est jugée être la plus proche, et malheureusement c'est apparemment ici toujours le noir qui l'emporte.

Ce qui est par contre extrêmement surprenant, c'est que nous n'obtenons pas mieux sur TI-Nspire. Pourtant ici il s'agit bien d'un écran en niveaux de gris 4-bits (2⁴=16 niveaux de gris différents), et jusqu'à présent les programmes Ndless prévus pour les TI-Nspire CX couleur n'avaient aucun problème à afficher en niveaux de gris lorsque lancés sur TI-Nspire monochrome...

Hélas, nous n'avons rien pu faire pour la TI-83 Premium CE Edition Python.

Son heap / tas dans sa version actuelle ne fait que 20 Ko, et il devient difficilement envisageable de réduire encore de moitié la consommation du script.
Et ce n'est hélas pas près de s'arranger, dans la prochaine version 5.5 le heap / tas tombe pour le moment à moins de 18 Ko, sans doute une conséquence involontaire de toutes les superbes nouveautés Python dont nous avons commencé à te parler et allons bien évidemment continuer.

C'est certes génial d'avoir toutes ces nouveautés Python, mais avec moins de 18 Ko de heap / tas désormais, nous craignons a priori d'être fortement limités dans la possibilité de les exploiter, avec des scripts plutôt académiques de quelques lignes au lieu de choses sortant des sentiers battus.

Bon ben puisqu'il n'est plus envisageable de compresser le script davantage, étoffons-le un petit peu. Avec une interface bilingue français-anglais permettant de choisir :

la langue
les dimensions du rendu en pixels avec même l'indication des bornes
le type de la sphère, bille opaque bleue ou transparente
et même, lorsque supporté par la machine, la possibilité d'accélérer un petit peu le rendu en ne rafraichissant l'affichage qu'une fois par ligne ou encore à la fin plutôt qu'à chaque nouveau pixel calculé

Terminons enfin avec les performances, vu que vous avez été nombreux à nous les demander.

Nous ferons des rendus plein écran avec la bille transparente (ce qui génère un peu plus de calculs puisque déviant les rayons lancés plutôt que de les stopper).
Par équité la rafraîchissement sera effectué à chaque pixel, vu que la NumWorks ne supporte pas cette optimisation.
Aucun overclocking, ce sont donc les performances d'usines atteignables par n'imorte quel utilisateur.

Précisions bien qu'il ne s'agit pas ici d'une mesure de la puissance de calcul, mais des performances dans le cas bien particulier de ce script, avec donc mélange de calculs et de sorties sur écran.

Avec le script d'aujourd'hui qui est, rappelons-le, optimisé pour le tas / heap et la compatibilité mais absolument pas pour les performances, nous avons :

NumWorks N0110 : 2min35
NumWorks N0100 : 2min36
NumWorks N0100 : 2min43 (firmware Omega)
NumWorks N0110 : 3min22 (firmware Omega)
Casio Graph 35+E II : 2min40
Casio Graph 90+E : 10min28
TI-Nspire CX CR4+ : 14min48
TI-Nspire CX CR3- : 24min
TI-Nspire : 7min09

Mais ces écrans ont des définitions différentes, et nécessitent donc plus ou moins de calculs. Ramenons tout ceci par proportionnalité à ce que donnerait un rendu 128×64 pixels équivalent au plus petit écran, celui de la Graph 35+E II :

17,9s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
18,0s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
18,8s : NumWorks N0100 + firmware Omega (32 bits : Cortex-M4/ARMv7 @100MHz)
23,3s : NumWorks N0110 + firmware Omega (32 bits : Cortex-M7/ARMv7 @216MHz)
45,8s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz)
1min09,8s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
1min34,7s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz)
2min33,5s : TI-Nspire CX CR3- (32 bits : ARM9/ARMv5 @132MHz)
2min40,0s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz)

Quelques surprises pas toujours agréables.

Pour une raison que nous ignorons l'installation du firmware tiers Omega diminue apparemment les performances de ta NumWorks. C'est particulièrement marqué pour la NumWorks N0110 qui avec une perte d'environ 25% devient alors même moins performante que l'ancien modèle NumWorks N0100 pourtant moins puissant. Mais que se passe-t-il ?...

Téléchargement : démo raytracing + classe de compatibilité graphique polyscr (pour NumWorks, Casio Graph 90/35+E II et TI-Nspire Ndless)