π
<-
Chat plein-écran
[^]

News 2024
Avril (1)
Mars (1)

News 2023
Août (4)
Juin (3)
Mai (2)
Avril (4)
Mars (2)

News 2022
Août (2)
Juin (4)
Mai (7)
Avril (9)
Mars (10)

News 2021
Août (7)
Juin (2)
Mai (6)
Avril (11)
Mars (10)

News 2020
Août (4)
Juillet (11)
Juin (6)
Mai (4)
Avril (8)
Mars (3)

News 2019
Août (1)
Juin (3)
Mai (5)
Avril (1)
Mars (2)

News 2018
Août (4)
Juin (5)
Mai (9)
Avril (13)
Mars (5)

News 2017
Août (4)

NumWorks 13.1.1, retour sur le poisson d'avril 2020

Nouveau messagede Admin » 02 Avr 2020, 09:19

Suite à la sortie de la superbe version 13.2 le 31 Mars, le simulateur NumWorks en ligne est maintenant lui aussi à jour en version 13.2.

Mais l'avais-tu remarqué ? Pour le 1er avril le simulateur avait bien été mis à jour, mais bizarrement vers une version intermédiaire 13.1.1. :#roll#:

Une version où tous les 3 calculs à compter du 1er, ta NumWorks te parlait plutôt que de te répondre. Semblant en avoir perdu son latin elle te faisait part de ses états d'âme, commentait tes calculs, ou leurs résultats. :o

Un poisson d'avril parlant; à peine plus de 20 ans après, NumWorks nous réinvente donc le mythique Big Mouth Billy Bass, du moins en Amérique du Nord ! :D

12397Il te fallait insister lourdement avant de pouvoir enfin obtenir la réponse. :p

Aujourd'hui 2 avril cette version collector a certes disparu du site officiel mais pas complètement de la surface de la Terre; nous te l'avons en effet sauvegardée et même en prime recompilée pour ta calculatrice.
De quoi faire de bonnes farces à tes camarades lorsque les temps seront plus propices. ;)


Et si tu es curieux, le code du poisson est également disponible ci-dessous.


Téléchargements :
Code source : https://github.com/numworks/epsilon/pul ... ll-merging
Lien vers le sujet sur le forum: NumWorks 13.1.1, retour sur le poisson d'avril 2020 (Commentaires: 0)

NumWorks Omega 1.19.2 avec nouveautés 13.2.0

Nouveau messagede Admin » 05 Avr 2020, 11:28

Dans un article précédent nous te présentions la dernière version d'Omega, le firmware tiers ultime pour ta NumWorks développé et testé par Quentin Guidee et ses illustres collaborateurs ci-dessous :


Omega permet en effet d'améliorer grandement les possibilités de ta NumWorks et ce même en mode examen. Citons entre autres :
  • la réactivation du moteur de calcul littéral que NumWorks avait introduit dans sa version 1.2 pour le supprimer dans sa version 11
  • une application Atom avec un tableau périodique des éléments
  • une bibliothèque de constantes physiques
  • une application avec une calculatrice RPN
  • le support pour le rajout d'applications externes
9829Parmi les applications externes disponibles à ce jour, citons notamment :
  • Nofrendo, émulateur de console de jeux Nintendo NES
  • mais également KhiCAS par parisse.
    Basée sur Xcas, son logiciel intégré de mathématiques, cette application étend les capacités mathématiques de ta NumWorks au niveau d'une HP Prime, bénéficiant du moteur de calcul formel GIAC avec notamment la possibilité de construire automatiquement des tableaux d'étude de fonction avec indications d'éléments de démarche ! :bj:
    Elle est de plus programmable sous deux syntaxes au choix, Xcas ou Python. Et en prime, le langage de programmation inclut des commandes de tracé à la Scratch/Logo pour réinvestir les acquis de collège ! :D
    120221202412023

Nombre de fonctionnalités parfaitement légitimes puisque disponibles en mode examen pour les candidats ayant choisi des modèles concurrents, un nivellement par le haut pour l'égalité entre candidats ! :bj:

La dernière version 1.19.0 d'Omega intégrait les nouveautés du code de la version 13 officielle en cours de développement par NumWorks, et qui vient enfin de sortir officiellement en version 13.2.0.
Le firmware tiers Omega est donc aujourd'hui mis à jour en conséquence en version 1.19.2, avec même un petit message pour t'encourager à rester chez toi en ces belles journées de printemps. :)

1242512433Nous allons donc voir ensemble quelles sont les nouveautés d'Omega 1.19.2.
Déjà, Omega 1.19.2 intègre toutes les superbes nouveautés officielles de la version 13.2.0 que nous t'invitons à aller consulter, entre autres la bibliothèque matplotlib.pyplot en Python ! :bj:







1) Python et navigation

Go to top

A chaque fois que tu ouvres un script déjà existant dans l'éditeur Python du firmware NumWorks officiel, ce dernier te positionne systématiquement en fin de script.

Or un script se lit et pense normalement de haut en bas et pas de bas en haut, tu devais donc remonter avec
jusqu'à la fonction ciblée ou même pire jusqu'au début du script, ce qui pouvait prendre un certain temps dès que tu dépasses le stade des petits amusements que l'on fait en Mathématiques. :mj:

Grâce à Omega fini cet inconvénient grâce à de nouveaux raccourcis de navigation dans l'éditeur de script Python : :bj:
  • alpha
    pour aller directement en début de script
  • alpha
    pour aller directement en fin de script
  • alpha
    pour aller en début de ligne
  • alpha
    pour aller en fin de ligne




2) Calculs et résultats supplémentaires

Go to top

La dernière version d'Omega introduisait le mode d'affichage compact, permettant de visualiser davantage de calculs précédents dans ton application Calculs en affichant lorsque possible le résultat sur la même ligne que la saisie.

NumWorks pour sa part t'introduit une formidable possibilité, les résultats complémentaires te permettant d'obtenir de véritables mini-études automatisées de certaines familles de résultats.
12432
Mais voilà, lorque l'on activait le mode d'affichage compact sous Omega, l'affichage des résultats complémentaires était entièrement corrompu. :'(

C'est maintenant corrigé avec le dernier Omega ! :bj:




3) Paramètres et mode examen

Go to top

L'option permettant de configurer la couleur de la diode examen a été retirée.
La diode examen clignote maintenant toujours en rouge, et ce peu importe le mode examen choisi.

C'est bon pour la France, pas parce qu'une couleur est imposée mais dans le sens ou une couleur différente des autres calculatrices NumWorks de la salle aurait pu inquiéter certains surveillants.

Par contre c'est extrêmement dommage pour les Pays-Bas où la couleur orange est obligatoire. Contrairement au firmware officiel et contrairement aux versions Omegaprécédentes, le dernier Omega ne peut donc plus être utilisé par les candidats aux Pays-Bas. :'(




4) Probabilités et loi de Fisher

Go to top

Dans l'application Probabilités, l'icône pour la nouvelle loi de Fisher a été corrigée pour respecter le thème d'Omega.




5) Installation Omega et KhiCAS

Go to top

Pour installer Omega rien de plus simple. De façon similaire à ce qui existait déjà pour les applications externes, un installateur en ligne est désormais également disponible pour Omega. Il te suffira tout simplement de connecter ta calculatrice, d'ouvrir la page liée en fin d'article dans ton navigateur, puis d'un seul clic ! :bj:
Tu auras besoin pour cela d'un navigateur utilisant un moteur Chromium ou compatible : Google Chrome, Microsoft Edge...


Notons qu'un tutoriel pour une installation avancée est également disponible et lié ci-après pour ceux qui souhaitent compiler Omega par eux-mêmes. Une méthode qui te donne accès à des possibilités supplémentaires, comme celle de protéger ta NumWorks contre le vol en signant l'écran A propos avec ton nom ou tout ce que tu veux, ainsi que la possibilité de te choisir un des 4 thèmes disponibles :
  • epsilon_light
  • epsilon_dark
  • omega_light (par défaut)
  • omega_dark

Les applications externes KhiCAS et autres sont pour leur part à installer séparément avec leur propre installateur en ligne dédié, également lié en fin d'article.




Liens :

Téléchargements :
Lien vers le sujet sur le forum: NumWorks Omega 1.19.2 avec nouveautés 13.2.0 (Commentaires: 12)

Raytracing Python compat NumWorks+Nspire+Casio & performance

Nouveau messagede Admin » 15 Avr 2020, 00:36

12450Casio 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 ! :bj:

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. 1,032942 Mo :
    Casio Graph 90+E
  2. 1,022145 Mo :
    HP Prime (version alpha)
  3. 100,560 Ko :
    Casio Graph 35+E II
  4. 32,339 Ko
    NumWorks (firmware Omega)
  5. 31,624 Ko
    NumWorks
  6. 20,200 Ko
    TI-83 Premium CE Edition Python
En classe :
  1. 2,049276 Mo :
    TI-Nspire (appli MicroPython)
  2. 1,032942 Mo :
    Casio Graph 90+E
    Casio fx-CG50
  3. 1,022145 Mo :
    HP Prime (version alpha)
  4. 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)
  5. 100,560 Ko :
    Casio Graph 35+E II
    Casio fx-9750/9860GIII
  6. 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)
  7. 32,339 Ko
    NumWorks (firmware Omega)
  8. 31,624 Ko
    NumWorks
  9. 22,605 Ko
    TI-83 Premium CE + TI-Python (firmware tiers)
  10. 20,200 Ko
    TI-83 Premium CE Edition Python (version 5.4)
  11. 19,924 Ko
    TI-83 Premium CE + TI-Python
  12. 17,954 Ko
    TI-83 Premium CE Edition Python (version 5.5)

12385La 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.

12453Ce 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 ! :bj:

12455Nous 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 ! :D

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

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

1246112460Le 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 (24=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 :
  1. 17,9s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
  2. 18,0s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
  3. 18,8s : NumWorks N0100 + firmware Omega (32 bits : Cortex-M4/ARMv7 @100MHz)
  4. 23,3s : NumWorks N0110 + firmware Omega (32 bits : Cortex-M7/ARMv7 @216MHz)
  5. 45,8s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz)
  6. 1min09,8s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
  7. 1min34,7s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz)
  8. 2min33,5s : TI-Nspire CX CR3- (32 bits : ARM9/ARMv5 @132MHz)
  9. 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 ?... :#roll#:



Téléchargement : démo raytracing + classe de compatibilité graphique polyscr (pour NumWorks, Casio Graph 90/35+E II et TI-Nspire Ndless)
Lien vers le sujet sur le forum: Raytracing Python compat NumWorks+Nspire+Casio & performance (Commentaires: 7)

Snake, calcul mental, et interface lancement jeux Python

Nouveau messagede Admin » 19 Avr 2020, 00:10

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

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. :bj:

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 ! :bj:

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

12472Comme 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 ! :D

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 ! :bj:
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 ! :D
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"])

12473Enfantin, 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 ? :troll:




Liens :

Téléchargements :
Lien vers le sujet sur le forum: Snake, calcul mental, et interface lancement jeux Python (Commentaires: 23)

Démineur, Snake, et interface lancement jeux Python

Nouveau messagede Admin » 19 Avr 2020, 11:27

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

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 ! :bj:

12385D'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. :bj:

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 ! :bj:

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

12378Aujourd'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 :
Lien vers le sujet sur le forum: Démineur, Snake, et interface lancement jeux Python (Commentaires: 0)

Le simulateur NumWorks porté sur Nintendo 3DS !

Nouveau messagede 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 ! :D




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
Lien vers le sujet sur le forum: Le simulateur NumWorks porté sur Nintendo 3DS ! (Commentaires: 12)

Fire FR-27, le jeu Nintendo Game & Watch adapté sur NumWorks

Nouveau messagede Admin » 26 Avr 2020, 12:49

6594Avant 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 ! :bj:

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. :p

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.

12485En 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(). :bj:

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 :
Lien vers le sujet sur le forum: Fire FR-27, le jeu Nintendo Game & Watch adapté sur NumWorks (Commentaires: 3)

Carré magique de Merlin adapté pour ta NumWorks en Python

Nouveau messagede Admin » 30 Avr 2020, 13:08

Le jeu électronique Merlin sorti en 1978 chez Parker Brothers (Miro Meccano en France), peut être considéré mine de rien comme l'une des premières consoles de jeux portables. Il dispose en effet :
  • de 11 pixels, dont 9 pixels organisés en un écran 3×3 pixels
  • un écran qui de plus est tactile près de 30 ans avant la démocratisation de cette technologie, avec une zone tactile pour chacun des pixels ainsi numérotés en conséquence de 0 à 10
  • d'une sortie sonore
  • de pas moins de 6 jeux différents intégrés :
    1. Morpion / Tic-tac-toe
    2. Composition musicale
    3. L'écho
    4. Black jack
    5. Carré magique
    6. Jeu de code

Aujourd'hui, Schraf te sort un nouveau tuto-vidéo d'adaptation pas à pas de jeu pour ta NumWorks, exploitant à nouveau les formidables possibilités écran et clavier maintenant offertes en Python par les modules respectifs kandinsky et ion combinés.

Et c'est justement le Carré magique de Merlin qu'il t'a choisi :
A partir d'un motif de départ aléatoire ton but est de dessiner un carré, c'est-à-dire d'allumer 8 pixels et pas un de plus (n° 1, 2, 3, 4, 6, 7, 8 et 9). Chaque touche te permet d'inverser les états de certains pixels c'est-à-dire selon le cas de les allumer ou les éteindre, toujours les mêmes pour chaque touche. À toi de retrouver la combinaison magique qui te permettra d'allumer le carré.


12490Sauf que Schraf en a profité pour t'étendre un petit peu le jeu :
  • L'appel par défaut go(1) te permettra bien de jouer au jeu original, avec donc un carré à dessiner. :)
  • go(0) quant à lui choisira le motif à dessiner aléatoirement parmi les 29=512 combinaisons différentes que permettent les 9 pixels centraux, le motif exigé étant indiqué en haut à droite de l'écran. ;)


Installation : https://workshop.numworks.com/python/sc ... re_magique

Crédits images :
Lien vers le sujet sur le forum: Carré magique de Merlin adapté pour ta NumWorks en Python (Commentaires: 0)

-
Rechercher
-
Social TI-Planet
-
Sujets à la une
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Aidez la communauté à documenter les révisions matérielles en listant vos calculatrices graphiques !
Phi NumWorks jailbreak
123
-
Faire un don / Premium
Pour plus de concours, de lots, de tests, nous aider à payer le serveur et les domaines...
Faire un don
Découvrez les avantages d'un compte donateur !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partenaires et pub
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
1255 utilisateurs:
>1220 invités
>30 membres
>5 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Autres sites intéressants
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)