Author: Ilyas R.

NumApps

Colors en python, NumWorks

Colors est un utilitaire conçu pour votre calculatrice, dont l’objectif est de vous fournir une interface simple, ergonomique, et complète, permettant d’afficher des rendus de couleur via le format RGB de cette couleur ! Vous avez besoin de violet pour effectuer votre plus belle rosace avec Turtle ? Vous ne connaissez pas le format RGB du violet ? Parfait ! Lancez Colors !

Fonctionnalités

  • Affichage du format hexadécimal et RGB de la couleur définie
  • Choix de teintes adaptées proposées automatiquement
  • Support du pavé numérique
  • Système d’impulsion intelligent, pour des déplacements rapides et précis

Captures d’écran

Commandes

△ et ▽◁ et ▷Chiffres
NaviguerModifier / RéglerChoisir / Se déplacer

Pour aller plus loin

Si vous souhaitez en savoir davantage sur le fonctionnement et le développement de cet utilitaire, vous pouvez lire l’article de présentation : Le projet Colors en python sur NumWorks

Télécharger

Nous vous proposons 2 liens distincts, le premier est le lien vers la source du créateur de l’application, le deuxième est un lien alternatif en cas de problème. Seul le premier lien garanti de disposer de la dernière version de l’application.

Projets

Le projet Colors en python sur NumWorks

Colors est un utilitaire développé en python pour la NumWorks. Il permet d’obtenir facilement les formats de couleur RGB et hexadécimal d’une couleur via les valeurs Red, Green, et Blue, qui sont à configurer.

Développement

Étant en train de réfléchir au fonctionnment d’un futur projet (paint.py 🤔🤫). J’avais besoin de fournir un utilitaire facultatif en complément de ce projet pour ne pas l’alourdir. Voici comment est né Colors.

Je commence donc le développement tranquillement, et en un petit week-end, le projet Colors est terminé.

Colors v1

De multiples problèmes m’ont fait perdre beaucoup de temps. Je voulais, à l’origine, afficher une large palette de couleurs, puis grâce à un curseur et des flèches, déplacer le curseur sur un pixel de la palette et nous renvoyer les informations sur la couleur selectionné, c’était palette.py. Problème : j’avais besoin au minimum de 255 pixels en hauteur, et 255 pixels en largeur. Mais l’écran de la NumWorks fait 222 pixels en hauteur. Il m’étais donc impossible d’effectuer la palette précise que je pensais avec une telle taille d’écran.

Parallèlement, en me balandant sur le net afin de comprendre le fonctionnement du format RGB et hexadécimal par rapport aux couleurs, je fus tombé sur un système de sélection de couleur grâce à des barres coulissantes, et j’ai adoré !

Je me suis dit que ce serait parfait pour Palette (qui deviendra Colors). J’ai donc commencé à développer un système reproduisant le fonctionnement d’une barre coulissante. Et comme je suis sympa, je vous mets à disposition la fonction documentée si vous voulez en intégrer vous même dans vos programmes ! 😎

Ayant fini, je demande ce qu’en pense cent20. Grave erreur…

Bon bah mon projet attendra, l’écriture du cahier des charges de Colors v2 est en cours.

La nouvelle fonctionnalité majeure (il n’y en a de nombreuses autres pas forcément visibles) de cette seconde version est l’ajout des teintes :

Colors v2

La v2 plus ou moins terminée, une v3 est en réflexion…

Colors, qui devait être à la base un petit projet abouti en 2 jours, deviendra un gros projet de 2 semaines (pas à temps plein🙄).

Cette troisième et dernière version améliore grandement le rafraichissement des données (en limitant le clignotement), l’interface graphique est également légèrement revu. Cette version supporte également le pavé numérique. Et oui, on fait pas les choses à moitié ! 😏

Colors !

À toi de colorer !

Cet utilitaire est disponible sur https://nsi.xyz/colors

Tutoriels

Développer une application pour la NumWorks sur un vrai…

Vous avez décidé de créer un script python et de porter ce script sur la couche graphique de la calculatrice NumWorks, vous serez vite limité par my.numworks.com qui ne propose qu’une interface très limité de développement.

Si vous codez un script python qui n’exploite que la console, vous pouvez le développer sur n’importe quel outil puis simplement copier / coller votre script dans votre espace de stockage en ligne proposé par NumWorks sur my.numworks.com/python/

Si vous souhaitez d’exploiter des modules propriétaires de la calculatrice NumWorks, tels que ion (gestion du clavier) ou kandinsky (pour gérer l’écran pixel par pixel) alors tout est plus compliqué, enfin tout était plus compliqué !

Il était une fois le workshop …

Le site officiel de NumWorks qui héberge les script s’appelle désormais my.numworks.com mais au départ, il y a fort longtemps, on parlait du workshop, il était accessible en ligne depuis cette adresse workshop.numworks.com et proposait une interface de programmation primitive, qui n’a malheureusement que peu évolué depuis 2017.

Si vous aimez les ascenseurs vous allez adorer cette interface de programmation !

Pas pratique, pas collaborative, bogué, bref on y a codé des jeux et ce fut épique.

La révolution Omega et son IDE en ligne

Le développement de petits jeux sur la NumWorks a été rendu possible par la sortie de la version 13 officielle, et lorsque nous avons commencé à faire des jeux, comme le démineur nous avons très vite suggéré l’idée de rendre possible de développement des projets avec Kandinsky sur PC sans passer par l’interface officielle de NumWorks.

En septembre 2020, l’équipe de Omega (un fork de Epsilon, l’Os de la calculatrice) lançait un IDE en ligne. Il est toujours utilisable à l’adresse https://getomega.dev/ide mais il nécessite un compte GitHub, car les fichiers .py qui y seront crées seront enregistrés sur GitHub.

Pour l’avoir utilisé et exploité avec les élèves en octobre / novembre 2020 pour leurs projets de spécialités NSI, nous pouvons certifier que c’est un superbe outil et une belle amélioration du workshop officiel.

Notre jeu Tetris a été développé sans cet IDE, tout aurait été tellement plus simple avec !

Le talent n’attend pas le nombre des années

Un développeur du nom de ZetaMap , lycéen en terminale STI2D option SIN au lycée Vauban de Brest a codé deux modules pour nous faciliter la vie :

Il est désormais possible d’utiliser un IDE classique (testé uniquement sous Windows) pour développer sur la NumWorks :

Ici le jeu Factors,, il tourne sur un PC alors qu’il exploite des modules spécifiques de la NumWorks.

Comment installer les modules de la NumWorks sur Thonny

Thonny est un IDE léger, simple et excellent pour débuter en python.

Nous allons voir ici comment installer des modules simplement sur Thonny, c’est-à-dire en se passant des traditionnels pip install dans un terminal.

Tout d’abord, il vous faut ouvrir Thonny, cela va de soit, ensuite accéder à l’onglet « Tools » ou « Outils » (selon votre langue), puis à la section « Manage packages… » ou « Gérer les paquets… ». Enfin, il suffit plus que de rechercher les modules « kandinsky » et « ion-Numworks » et de les installer !

Comment installer les modules de la NumWorks sur PyCharm

PyCharm est un IDE un peu lourd, mais très complet. Il peut-être notamment utile si vous gérez des projets avec Git.

Nous allons donc voir ici comment installer des modules encore une fois simplement sur PyCharm, c’est-à-dire en se passant des traditionnels pip install dans un terminal.

Tout d’abord, il vous faut évidemment ouvrir PyCharm, ensuite accéder à l’onglet « File », puis aux options « Settings ». À présent, rendez-vous dans la catégorie « Python Interpreter » dans votre Projet « Project: <project_name> ». Désormais, pour installer un module, appuyez sur le bouton « + » :

il suffit plus que de rechercher les modules « kandinsky » et « ion-Numworks » et de les installer !

Comment exploiter les modules ainsi installés

Pour exploiter les modules, rien de plus simple, il faut seulement les importer dans votre code :

from kandinsky import *
from ion import *

Votre code sera donc compatible avec votre IDE et la calculatrice, sans aucune modification requise.

Bugs et limite du portage

Évidemment, cette technique n’est pas sans limite. Notamment, si vous utilisez Turtle en plus de kandinsky. En installant ces deux modules et en les utilisant, deux émulateurs graphiques s’ouvriront, un exploitant kandinsky, et l’autre Turtle. C’est pour ça qu’il est déconseillé d’utiliser les deux en même temps, utiliser soit l’un soit l’autre.

De plus, est à éviter de changer de fenêtre pendant l’exécution du programme, cela risque de freeze l’émulateur :

Si vous souhaitez discuter de cet émulateur, faire remonter des bugs ou juste dire merci à son concepteur, tiplanet.org à bien voulu nous créer un salon dédié sur le serveur discord.

Lien direct vers ce salon : https://discord.gg/bBM7mgucjF

Projets

Factors Game en python sur NumWorks

Factors Game est à l’origine un jeu indépendant jouable en ligne, donc directement depuis un site web. Ceci dit, les Numworks ne peuvent pas encore se connecter à internet… Mais pas de panique, nous nous sommes occupés de l’adaptation du jeu sur calculatrice ! On est sacrément sympa nous…
Arriveras tu à atteindre le niveau 404 ?

Développement

02/04
🧐 Bon, maintenant que t’as fini ton nyan_cat, résolu deux de mes énigmes, corrigé les bugs sur laboHelp, aidé au développement de pixChoice. Ça te dit de faire un jeu sur la calculatrice ?
🤓 Pourquoi pas !

Voici le jeu qui était demandé : Factors Game – The 🐐 of Fun Math Games (mnito.github.io)

🧐 On va afficher les nombres dans des tuiles de 42 pixels par 42 pixels

(2 jours plus tard)

🤓 J’ai fini le système de mouvement, et le système de génération aléatoire de la grille. Il y a juste le front qui est à revoir…


🧐 Bon, pas très UX les déplacements du haut vers le bas comme sur le jeu original avec la résolution de l’écran des calculatrices. On va les faire de gauche à droite du coup, tu dois réadapter le système de mouvement.
🤓 … D’accord

Parallèlement le codage des nombres a été intégré, il est d’Eric Schrafstetter, il est explicité sur cette vidéo.

Ce codage, celui du jeu 2048, dont nous avons amélioré le rendu a été réutilisé pour écrire F A C T O R S en haut à gauche de l’écran !

Petit récap’, mouvements OK, grille OK, maintenant il faut faire le système de calcul entre le curseur et les cases de la grille (vous savez, les divisons, les additions, tout ça tout ça. Ça se fait pas par magie malheureusement).

Aussitôt commencé, aussitôt terminé ! Moi qui redoutait cette phase du développement, ça avait été plus facile que prévu. Plus qu’à faire le système de détection de fin du niveau. Fastoche ! Si le curseur est égal à 1, ou que le curseur est positionné dans la dernière colonne, niveau terminé ! Et on relance la génération de la grille sans oublier d’incrémenter le niveau et calculer la moyenne.

Voilà. En quelques jours, le jeu est théoriquement jouable.

🤓 Plus que le menu, et le système de sauvegarde. Mais le jeu est jouable !
🧐 Ok, pour le menu, on va faire ça, ça, mais il faut ça s’il y a ça, ça ça doit donc s’activer et du coup réactiver ça si ça a été désactivé seulement si ça avait été activé et puis…
🤓 Et si on faisait un cahier des charges ? 😅
🧐 Je m’en occupe.

🤓 Le menu est terminé, il faut sauvegarder le score de chaque niveau ?
🧐 Oui, on va utiliser un dictionnaire.
🤓 Larousse ou Le Petit Robert ?

Menu

🧐Le dictionnaire sert à rien, on aurait pu faire ça avec un tableau, mais laissons le dictionnaire ! 😂

🤓 Bon, je taffe sur une transition entre les niveaux, car les coups de sleep(3), ça va 2 secondes… (3 !)

🧐 Parfait !

Et voilà, en une bonne semaine, le jeu est terminé, il manque plus que le système de sauvegarde, enfin c’est ce que je pensais…

🧐 Bon, ton code est illisible on ne comprend rien. Tu me redéveloppes toute la fonction principale en respectant ces contraintes :

  • Le moins de if imbriqués possibles
  • Chaque if doit donner lieu à 2,3 traitements maximum
  • 61 lignes pour une fonction c’est trop
  • Tout abus de booléen est à éviter

🤓 Mais ça nécessite de redévelopper quasiment toutes les fonctions. Donc tout le jeu…
🧐 Oui mais sinon on comprend rien.
🤓 Oui mais le jeu marche.
🧐 Oui mais on comprend rien.
🤓 J’ai compris…

Vous vous comprenez hein rassurez moi. À moins que j’ai un problème.

def factors(): # Ceci est l'ancien code incompréhensible !
    global cursor, pos, level_current, retry
    gui()
    menu()
    level_in_progress, in_menu, re_menu, last_key, end, go, input_await = False, False, False, None, False, False, False
    while not keydown(5):
        if not level_in_progress:
            if not in_menu:
                menu(0)
                start_level(1)
                cursor, pos, end, input_await = level_current, [51 + 44 * 1, 13 + 44 * 1], False, False
                aff(level_current, pos[0] + 44 // 2 + center(level_current)[0],
                    pos[1] + 44 // 2 + center(level_current)[1], black_color)
                level_in_progress = True
            if not re_menu and in_menu:
                menu(1)
                start_level(0)
                re_menu = True
        if keydown(1) and pos[1] >= 51 and last_key != 1:
            if not in_menu:
                move(0, -1)
            if in_menu and level_current != level_max:
                level_current += 1
                re_menu = False
            last_key = 1
        if keydown(2) and pos[1] <= 51 + 44 * 2 and last_key != 2:
            if not in_menu:
                move(0, 1)
            if in_menu and level_current != 1:
                level_current -= 1
                re_menu = False
            last_key = 2
        if keydown(3) and last_key != 3:
            if not in_menu:
                move(1, 0)
            if in_menu:
                level_in_progress, in_menu, re_menu = False, False, False
            if input_await:
                go = True
                fill_rect(pos[0] + 42, pos[1] + 42, 0 - 220, 0 - 176, (255, 255, 255))
            last_key = 3
        if keydown(0) and last_key != 0:
            if pos[0] != 51 + 44 or input_await:
                level_in_progress = False
                retry = True
                if input_await:
                    fill_rect(pos[0] + 42, pos[1] + 42, 0 - 176, 0 - 176, (255, 255, 255))
            if not in_menu and pos[0] == 51 + 44:
                level_in_progress, in_menu = False, True
            last_key = 0
        if not (keydown(0) or keydown(1) or keydown(2) or keydown(3)):
            last_key = None
        if not (pos[0] != 51 + 44 * 5 and (cursor != 1 or pos[0] == 51 + 44)):
            end = True
        if end:
            if not input_await:
                level_transition(cursor)
                input_await = True
            if go:
                next_level()
                level_in_progress, retry, input_await, go = False, False, False, False

Finalement, presque tout le jeu a donc été redéveloppé pour améliorer la lisibilité des fonctions python.
Vous pouvez donc désormais comprendre le code ! Sauf le système de sauvegarde, ça vous vous débrouillez ! 🤫

🧐 Oui enfin le système de sauvegarde est codé pour être incompréhensible, c’est une fonctionnalité pour éviter qu’un joueur lambda ne génère trop facilement une clé de sauvegarde.

🤓 À noter, le code a été compressé pour passer de 10.2 ko à 8.42 ko, et désormais il ne respecte plus PEP 8 – Style Guide for Python Code (EnFr)

Fonctionnement

La plupart des différents événements sont lancés grâce à la liste pos[x, y]. Cette liste correspond aux coordonnées x, et y du curseur :

La position par défaut du curseur est donc [0, 1] ! Oui, l’axe vertical est inversé. 🙄

Ainsi, si pos vaut [-1, y], on lance le menu, si pos[4, 0], on termine le niveau, etc. L’affichage sur l’écran est géré par la fonction d_p(), qui va convertir pos en coordonnées réelles (celles de l’écran), car évidemment, les coordonnées de pos sont virtuelles ! Le (0 ; 0) de l’écran lui se situe tout en haut à gauche !

Fonctionnalités délaissées

Beaucoup de fonctionnalités ont été retirés pour réduire au plus la taille du fichier ainsi que la mémoire utilisée ou pour d’autres raisons.
Un histogramme dynamique avec le score des 20 derniers niveaux a été par exemple testé mais abandonné, le système de chargement d’une sauvegarde sur la couche graphique est lui aussi retiré, remplacé par une fonctionnalité équivalente mais exploitant le console python.

À toi de jouer !

Ce jeu est disponible sur https://nsi.xyz/factors

Nous te mettons au défi d’atteindre le niveau 404. Mais y arriveras tu ? 😱

NumApps

Factors en python, NumWorks

Un jeu qui mettra vos méninges au défi ! Sur Factors, vous ne devez pas réfléchir à comment vous allez pouvoir faire pour augmenter cette foutue moyenne générale, mais au contraire comment la baisser !

Règles du jeu

Avec une variante des règles de base de la division, Factors est un jeu de mathématiques amusant conçu pour être facile à comprendre, mais qui met de plus en plus à l’épreuve vos compétences mentales en mathématiques à mesure que vous progressez dans les niveaux.
Déplacez votre numéro vers la droite à travers la grille des numéros pour vous rapprocher le plus possible de 1. Mais attention, si la division de vos nombres ne forment pas un nombre entier, ils s’additionnent !
Votre objectif est de maintenir votre moyenne globale aussi basse que possible !

Ce jeu est une adaptation du jeu original Factors Game.

Fonctionnalités

  • Support des couleurs des systèmes d’exploitations Epsilon et Omega
  • Réinitialisation des mouvements pendant un niveau
  • Menu de sélection du niveau
  • Stockage du meilleur score de chaque niveau
  • Sauvegarde de sa progression
  • Et bien plus…

Captures d’écran du jeu

Commandes

△ et ▽Ans
NaviguerAccéder / CalculerRéinitialiser / MenuSauvegarder / Charger

Pour aller plus loin

Si vous souhaitez en savoir davantage sur le fonctionnement du jeu, vous pouvez lire l’article de présentation : Factors Game en python sur NumWorks

Télécharger

Nous vous proposons 2 liens distincts, le premier est le lien vers la source du créateur de l’application, le deuxième est un lien alternatif en cas de problème. Seul le premier lien garanti de disposer de la dernière version de l’application.