Étiquette : NumWorks

NumApps

Convert en python, NumWorks

Convert est un utilitaire conçu pour votre calculatrice, son objectif est de vous fournir une interface afin d’effectuer des conversions binaires, hexadécimales, et décimales. Convert est un outil ultra rapide qui pourra vous aider à effectuer des conversions facilement et rapidement.

Fonctionnalités

  • Conversions possibles du binaire vers décimal et hexadécimal, hexadécimal vers binaire et décimal, ainsi que décimal vers binaire et hexadécimal
  • Support des nombres négatifs en complément à deux. 0 à 255 en mode Integer, et -128 à 127 en mode Two’s complement

Captures d’écran

Commandes

△ et ▽◁ et ▷OK
Augmenter / DiminuerSe déplacerChanger de mode

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.

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 ? 😱

Tutoriels

Comment publier sur le Numworks workshop?

Le Numworks workshop se trouve sur le site internet Numworks. Sur ce site on peut y trouver un émulateur de la calculatrice en ligne (gratuit), un tutoriel sur le Python et un espace où l’on peut créer des scripts (en Python bien évidemment) pour ensuite les publiés publiquement ou les garder privés. Le Numworks workshop est l’endroit où l’on peut retrouver les scripts que vous avez crées ou que les autres ont publiés.

Pour se rendre sur le site, il vous faut seulement un ordinateur qui est accès à internet ( smartphone, tablettes très déconseillé).

1. Ouvrir un navigateur internet

Il faut tout d’abord ouvrir un navigateur internet. (Google Chrome recommandé).

2. Se rendre sur le site

Une fois que vous êtes dans votre navigateur, tapez dans la barre de recherche numworks puis cliquez ensuite sur le premier lien.

3. Création d’un compte

Vous voilà sur l’accueil du site, maintenant cliquez sur mon compte.

  • Il faut maintenant vous créez un compte et pour cela il suffit juste de cliquez sur le bouton jaune s’inscrire.
  • Si vous possédez déjà un compte passez directement a la prochaine étape.
  • Rentrez votre adresse mail et vos informations personnelles puis cliquez sur S’inscrire.
  • Si vous ne possédez aucune d’adresse mail : Cliquez ici pour trouver un tutoriel vous expliquant comment faire pour en créer une.

4. Connectez vous

Une fois inscrit cliquez sur Se connecter.

  • Rentrez vos identifiants puis cliquez sur Se connecter.

5. Accéder à vos scripts

Vous voilà connectez. Maintenant nous voulons publiez sur le Numworks Workshop et pour cela il faut d’abord créer des scripts. Pour accéder a vos scripts, cliquez sur votre adresse mail puis sur mes scripts.

  • Vous vous retrouvez sur cette page. Si vous n’avez aucun script , créer en un et pour cela il vous suffit de cliquez sur nouveau script.

6. Création d’un script

  • Donnez lui un Nom. Il ne peut contenir aucune majuscule, aucun caractère spécial et il faut bien mettre .py à la fin car sinon on ne pourra pas sauvegarder le script. Faites une légère description puis rédiger votre script.
  • N’OUBLIER PAS de cocher la case Permettre aux utilisateurs d’accéder à ce script. Si vous ne la cochez pas votre script restera privé et ne sera pas publié.
  • Une fois fini, cliquez sur Sauvegarder.
  • Ici il est impossible de sauvegarder le script car dans le titre il y a une majuscule. Aucun problème on met une lettre minuscule à la place.
  • Maintenant que votre titre est aux normes, cliquez sur Sauvegarder.
  • Votre script est terminé. Si la case verte Public apparait comme ci-dessous, cela indique que votre script est bien publié et les autres utilisateurs y auront accès.

7. Rendre votre script privé

Si vous voulez rendre votre script privé, il vous suffit juste de cliquez sur le petit stylo jaune.

  • Cliquez ensuite sur le petit stylo situé en haut a droite de l’écran.
  • Maintenant décocher la case Permettre aux utilisateurs d’accéder à ce script et sauvegarder votre script.
  • Votre script est bien passé en privé.

Et voilà, ce tutoriel est terminé ! J’espère qu’il vous a été utile !

NumApps

Le jeu 2048, sur ta NumWorks !

2048 est un jeu vidéo de type puzzle conçu en mars 2014 par le développeur indépendant italien Gabriele Cirulli et publié en ligne sous licence libre. La version présenté ici est le portage du jeu, réalisé par Eric Schrafstetter et légèrement modifiée par nos soins pour un rendu sublimé sur la NumWorks.

Portage du jeu, en python, sur NumWorks

Eric Schrafstetter est le premier a voir porté ce jeu sur la calculatrice NumWorks, ce jeu nécessite une version Epsilon 13 ou supérieur installé sur la calculatrice. En effet, la version 13 de l’OS de cette calculatrice à permis le développement de jeux car il était désormais possible de récupérer les touches du clavier saisies.

Publié le premier avril 2020, la première version de ce programme a été suivie par une version améliorée proposée le 30 juillet 2021. Nous avons découvert ce jeu fin décembre 2021, et avons décidé de l’améliorer afin de proposer une expérience joueur améliorée.

La version 2 de Eric Schrafstetter

La version modifié par nos soins

Modifications réalisées par nos soins

  1. La grille a été centrée et la bordure épaisse réduite, on conserve l’effet « ombre » sans écraser la grille.
  2. Le score a été déplacé, il est moins visible pendant la partie, l’interface présente une symétrie visuelle et la modification du score n’attire pas l’œil.
  3. Les micros-lags ont été supprimés. Dans la version d’origine, la grille était entièrement effacée puis reconstruite ce qui générait un affichage haché avec un effet de rafraichissement pas agréable. Le jeu est du coup plus fluide, plus agréable à utiliser.
  4. Une détection de la fin de partie a été implémentée, si la grille est remplie et que 4 touches sont pressées sans que rien ne se passe, on signale au joueur que la partie est terminée.

Une vidéo de présentation du codage

Si le codage de ce jeu vous intéresse, la vidéo de son auteur est incontournable. 😍

Commandes

Le jeu se joue simplement avec les touches fléchées de la calculatrice.

Télécharger

Des liens vers les version 1 et 2 du jeu, celle de Eric Schrafstetter sont au début de cet article. Nous vous proposons de tester la version modifiée par nos soins :

Projets

Le jeu Plateforme sur la NumWorks en python

Le but du jeu est simple, se déplacer de plateformes en plateformes en essayant d’atteindre la plateforme finale située a la fin du niveau.

Ce jeu est uniquement jouable sur numworks car nous avons utilisé des fonctions uniquement disponible sur numworks.

Pour réaliser notre projet sur Numworks , nous avons eu besoin de plusieurs modules . Nous avons eu en premier temps besoin du module kandinsky qui nous a permis de réaliser les graphismes du jeu. Ensuite nous avons utilisé le module random pour permettre la génération aléatoire des placements des plateformes et de leur taille . Nous avons aussi utilisé les modules ion et time pour définir les touches qui vont nous permettre de jouer et pour définir le temps d’affichage des cinématiques lors de la mort et la victoire.

Le jeu :

Lorsque l’on lance le jeu sur numworks, des plateformes se génèrent aléatoirement et il faut utiliser les flèches pour sauter de plateformes en plateformes jusqu’à atteindre la dernière plateforme d’un niveau.

L’image si dessous correspond a la fin du niveau, avant de sauter sur la plateforme verte, dernière plateforme du niveau.

Les animations :

Une fois sauté sur la plateforme verte, une rideau va descendre et afficher le texte suivant :

Le code ci dessous correspond a l’animation de la victoire. Un rideau vert va s’abaisser. Nous avons créé un rectangle d’un pixel de hauteur et de 32O pixels de large (largeur de l’écran de la calculatrice). Ce rectangle va se répéter 222 fois (hauteur de l’écran de la calculatrice) avec un écart de 0,01 seconde entre chaque rectangle pour faire un effet d’animation.

Mais attention ! Si vous tombez avant la plateformes verte, dans les piques situés en bas de l’écran, un rideau gris apparaitra et une animation aura lieu a :

Le code ci dessous correspond a l’animation lorsque l’on meurt. C’est le même principe que pour l’animation de la victoire mais ici on a codé la tête de mort en plus. Elle se créée avec le module kandinsky en créant des carrés et rectangles. Nous avons également placé une pause de 0,3 seconde entre chaque carré ou rectangle pour accentuer l’animation.

Pour se deplacer de plateformes en plateformes nous avons décidé de créer un personnage. Cette création s’est faite en plusieurs étapes

Les personnages :

personnage statique :

Ce dessin est celui qui a été fait avant de réaliser le personnage sur kandinsky . Nous avons mis en évidence un des rectangles composant le dessin , je l’ai mis en coordonnées 1 et 3 sur le tableau présent sur le croquis pour déterminer les coordonnées à mettre dans le script . Sur la feuille , un carreau représente un carré de 1 par 1 . Le rectangle dessiné à gauche est fait de 2 carrés côte à côte donc le rectangle aura une longueur de 2 pour une hauteur de 1 . Donc si je veux que ce rectangle soit noir , en kandinsky cela donnera :

personnage en mouvement :

Ainsi de même pour le personnage qui cours nous avons mis un autre rectangle en évidence qui sera formé à partir de :

personnage qui saute :

Enfin pour le personnage qui saute , la même règle s’applique et le premier rectangle composant le personnage est fait grâce à : 

Les bases du jeu :

Maintenant la question que vous vous posez surement est: « Comment le niveau se génère aléatoirement ? ».

D’abord, voici le code permettant de réaliser une telle action :

Dans ce code, on peut d’abord remarquer que nous avons décidé de nommer la fonction de génération « randomlevel ». Cette fonction prend en compte 3 listes : « x », « y » et « l ». A titre d’exemple, la première plateforme du jeu aura comme coordonné en x la première variable de la liste « x », aura comme coordonné en y la première variable de la liste « y » et aura comme longueur la première variable de la liste « l ». La première boucle « for » permet de faire répéter la génération aléatoire 15 fois pour obtenir 15 plateformes vu que levell = 15. La première ligne dans cette boucle permet d’insérer la longueur aléatoire se comprenant entre 10 et 80 pixels dans « l ». Ensuite, on a fait en sorte que la première plateforme apparait toujours à une hauteur comprise entre limitup (31) et limitdown (191) et qu’elle apparaisse à une distance de 100 pixels du bord. Pour ne pas rentrer trop dans les détails, on peut dire que le reste du code permet de générer les plateformes a des distances raisonnables les unes des autres pour que les sauts ne soient pas trop long donc impossibles.

Enfin vous vous demandez peut être comment le jeu fonctionne en général ? Ce passage montre bien comment il fonctionne:

Ici on remarque d’abord le « while game == 0: » . Cela permet de faire répéter le programme ci dessus indéfiniment tant que le joueur n’a pas gagné ou n’est pas mort. En effet « break » nous permet de sortir de cette boucle quand le joueur gagne ou perd. Les mouvements pour avancer et reculer sont coder grâce à la logique « if » qui permet à la troisième ligne et à la huitième ligne de réaliser une action quand une touche spécifique de cette dernière est pressée. Dans notre jeu le personnage n’avance pas vraiment. En fait ce sont les plateformes qui bougent mais on a l’impression que c’est le personnage. Cette illusion est utilisée dans presque tout les jeux de plateforme en 2D connus. Ensuite nous avons créer un système de gravité qui fait que le personnage tombe et retombe après un saut. Ce système a été nommé gravityleft et gravityright. Ces deux lignes récupèrent la couleur au pied du personnage. Si la couleur est la couleur d’une plateforme, le personnage ne tombe pas. Si la couleur est la couleur du vide, le personnage tombe. Si la couleur est couleur des piques, le personnage meurt. Si la couleur est la couleur de l’arrivée, le joueur gagne.

Nous pensons que vous avez compris l’idée globale du code maintenant et qu’il est très peu utile de s’intéresser à tous les petits détails. C’est pour cela que c’est à vous de teste le jeux maintenant. Bonne cession !

Conclusion :

Nous espérons que ce jeu vous aura plus et qu’il vous aura donné du fil à retordre !! Nous avons cependant un bug qui ne peut se résoudre car le bug vient de numwork. 

Liens vers le jeu :

https://my.numworks.com/python/charlie18-coquel/jeu_de_platforme

Tutoriels

Débuter et découvrir python 3

Python est un langage de programmation simple d’usage qui sera utilisé en mathématiques ainsi qu’en spécialité NSI ( Numérique et Sciences Informatiques ) lors d’activités algorithmiques. Présentation d’un document exploité en classe de seconde.

Un triptyque à imprimer en couleur

Le dépliant 3 volets a été conçu pour être imprimé en couleur puis plié. Un trait de pliage discret mais présent permet de réussir le pliage roulé, c’est à dire que le document se replie sur lui même et ce dans un même sens.

Document au format natif Google Document.

Si vous avez un compte Google, vous pouvez créer une copie rapidement de ce document pour le modifier.
Fichier > Créer une copie

Pour l’impression, il est conseillé de réaliser un PDF au préalable :
Fichier > Télécharger > Document PDF (.pdf)
puis d’ouvrir ce document dans Adobe Acrobat Reader et de l’imprimer avec les paramètres suivants :
Page 1-2 | Taille réelle | Recto verso : Retourner sur les bords courts | Paysage

Scénario d’utilisation du document.

Ce document sera testé une première fois à la rentrée 2021 en classe de seconde. Autant rien ne va marcher 😅
Pour avoir un retour, il vous suffira de consulter ce compte twitter à la rentrée 2021.

Ce document parait incomplet, il y a des trous et l’un des scripts ne semble pas produire le résultat attendu.
Ce document sera accompagné de consignes, il s’inscrira dans le cadre d’un travail de groupe.
Le travail de groupe permet aux élèves de s’entraider, au lieu de gérer 38 élèves qui ont chacun un problème différent, il y a « juste » 10 groupes à superviser.

Travail préalable :
Les élèves doivent télécharger les scripts start.py et sapin.py sur leur calculatrice NumWorks.
Les élèves doivent saisir manuellement le script ce2.py dans leur calculatrice NumWorks.

Travail de groupe :
En cours de création. Ne sera pas rendu accessible via un lien public. Contactez moi si ce document vous intéresse.

  • Leur demander de tester les opérateurs mathématiques, d’affectation et de comparaison dans la console python de leur calculatrice puis compléter les tableaux proposés.
  • Tester les différentes fonctions proposées dans start.py, les exécuter avec différents paramètres.
  • Modifier le script sapin pour obtenir le rendu proposé.
  • Créer un premier script

Contributeurs

Ce document sous licence cc by sa intègre des contributions d’élèves et / ou d’enseignants.

Le script turtle est l’œuvre de Cyril D, élève de seconde en 2020 – 2021, il a été réalisé dans le cadre d’un devoir maison intitulé « Les mathématiques sont belles« . Ce script est présenté ici : Dessine moi un Open Badge

from turtle import *
liste = ["pink", "red", "orange", "yellow", "green", "blue", "purple"]
for i in range(3*42) :
  color(liste[i%7])
  pensize(10+2)
  forward(i)
  left(59)

Le sapin est un grand classique du genre, un dessin en Art ASCII, proposé initialement ainsi :

# sapin.py
ligne = 1
max = 6
while ligne < max:
    n = max - ligne
    s = 2 * ligne - 1
    print(" " * n + "#" * s)
    ligne +=1
print(" " * (max - 1) + "#")

il a été amélioré par un enseignant sur twitter, et la fusion des deux script a donné ceci :

# sapin.py
hauteur = 6
diese = 1
espace = hauteur - diese
 
while espace > 0:
    print(" " * espace + "#" * diese )
    espace -= 1
    diese += 2
 
print(" " * (hauteur - 1) + "#")

Les fonctions hypotenuse() et reponse() ont été imaginée et construite par Kevin Fedyna.

from math import sqrt

def hypothenuse(a, b):
    # Théorème de Pythagore
    c = sqrt(a ** 2 + b ** 2)
    # La fonction renvoie le résultat
    return c
 
def reponse(n):
    return n == 42 

Débogage

Merci pour les erreurs que vous m’avez signalés, elle ne peuvent pas être corrigées sur l’image diffusée ici mais elles sont prise en compte presque en temps réel dans le document final. N’hésitez pas à répondre à ce message twitter si vous constatez d’autres erreurs.

NumApps

Des simulateurs web pour la NumWorks

Le logiciel de la NumWorks est sous licence Creative Commons, ce qui autorise la modification du code de la calculatrice et sa redistribution en respectant quelques règles.

Le simulateur officiel de la NumWorks

Un simulateur web construit sur du HTML, CSS et Javascript est proposé en ligne, gratuitement sur le site officiel de la calculatrice, il est présenté comme un outil idéal pour les démonstrations en classe et c’est une réalité.

  • Il est gratuit,
  • Il est accessible en ligne et hors ligne (téléchargeable gratuitement),
  • Il gère le mode plein écran pour un usage au vidéoprojecteur,
  • il est responsive et s’adapte à la taille de votre écran,
  • il gère l’enregistrement de la session et le partage de celle-ci par lien
    (cette dernière fonctionnalités n’est pas encore parfaitement stable à la date du 27 avril 2021)

En ligne : https://www.numworks.com/fr/simulateur/

Les simulateurs modifiés de la NumWorks

Nous vous proposons 3 simulateurs web légèrement modifiés de la NumWorks.

Pour un usage en ligne, nous les avons hébergé sur des sous domaines de ce site web.

Epsilon simulateurOmega simulateurPsi simulateur
epsilon.nsi.xyzomega.nsi.xyzpsi.nsi.xyz
Image modifiée par nos soins
Patché par Joachim Le Fournis
Simulateur officiel de Omega
https://getomega.dev/releases
Dérivé du projet NSIos
Gabin P. et Raphaël C.

Et parce que vous souhaitez peut-être changer d’ambiance un menu de navigation vous permet de passer de l’un des simulateurs à l’autre.

Patchs sur le simulateur epsilon

Quelques modifications ont été apportées au simulateur epsilon.nsi.xyz par rapport au simulateur officiel du constructeur de la calculatrice.

  1. L’image de la calculatrice a été modifiée pour avoir un rendu plus flat, pas parfait mais suffisant pour nous permettre de faire les captures d’écran que nous utilisons pour notre sélection NumApps.
  2. Le fond d’écran à été modifié pour la même raison.
  3. Les scripts natifs ont été effacés, il ne doivent donc pas être désactivés ou supprimés manuellement à chaque fois
  4. La taille des copiés / collés de scripts python externe à été porté à 16 ko contre environ 8 ko pour la version officielle.

Ces modifications codées par Jaochim Le Fournis nous permettent d’importer via un simple CTRL + V un script python rapidement et facilement, et ce sans se soucier des scripts python déjà présents, ni de la taille du script.

Design non flat / Design flat