Un jeu qui remettra vos compétences mentales et déductives à l’épreuve ! Sur Mastermind, vous allez devoir trouver la bonne combinaison de couleurs. Mais attention, hâtez vous et réfléchissez bien car vous n’avez que 10 tentatives, sinon c’est perdu !
Fonctionnalités
Configuration du nombre de couleurs possibles, jusqu’à 8 couleurs possibles
Configuration de la taille de la grille, jusqu’à 6 cases
Paramétrage de la possibilité d’avoir plusieurs mêmes couleurs dans la combinaison
Possibilité d’afficher une aide (Legit) qui donne la proportion de grille aléatoires conforme.
Captures d’écran
Commandes
△ et ▽
◁ et ▷
OK
Choisir
Se déplacer / Paramétrer
Valider
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.
Vous avez enfin décidé de débarquer et d’explorer le vaste monde de la programmation ? Dans ce cas, bienvenue chez les fous ! Entre cassage d’écran, arrachage de cheveux, ou encore saut par la fenêtre, vous vous rendrez vite compte comment ce vaste univers peut vous rendre maboule de 1001 manières. Ainsi, si vous souhaitez gagner du temps et être productif en programmation, ce tutoriel est fait pour vous !
En effet, il existe heureusement depuis quelques années des outils, se perfectionnant de mois en mois (voire même de jour en jour), permettant de vous faciliter la vie et surtout de gagner énormément de temps. La chose dont une développeuse ou un développeur a le plus besoin. L’un des outils ayant fait le plus parlé de lui ces dernières semaines est #ChatGPT, une intelligence artificielle capable de dialoguer avec nous en nous apportant des connaissances dans quasiment tous les domaines (mathématiques, langues, physique, etc.). Et donc dans ce tutoriel nous nous intéresseront à l’utilisation de #ChatGPT dans le domaine de la programmation en Python.
Une IA, c’est quoi ?
L’intelligence artificielle (IA) est une technologie qui permet à des machines de simuler l’intelligence humaine. Elle est utilisée dans de nombreux domaines, allant de la reconnaissance de la parole et de l’image à la robotique en passant par la finance et la santé.
Dans le domaine de la programmation, l’IA peut être utilisée pour automatiser certaines tâches de développement, comme la génération de code, la correction de bugs et la modification de scripts existants. Elle peut également être utilisée pour analyser et optimiser des algorithmes, ainsi que pour effectuer des tâches de test et de débogage.
Avantages de l’utilisation d’une IA
L’utilisation de l’intelligence artificielle (IA) dans le domaine de la programmation peut apporter plusieurs avantages incroyables. Voici une ribambelle d’exemples :
L’automatisation de tâches fastidieuses : l’IA peut être utilisée pour automatiser certaines tâches de développement, comme la génération de code, la correction de bugs et la modification de scripts existants. Cela peut aider les développeurs à gagner du temps et à se concentrer sur des tâches plus complexes.
Amélioration de la qualité du code : l’IA peut être utilisée pour analyser et optimiser des algorithmes, ce qui peut aider à améliorer la qualité du code et à réduire les erreurs.
Test et débogage plus efficaces : l’IA peut être utilisée pour effectuer des tests et du débogage de manière plus rapide et plus précise, ce qui peut réduire le temps de développement.
Il est important de noter que l’utilisation de l’IA dans le domaine de la programmation nécessite un minimum de compétence en matière de développement. Une IA n’est pas (encore) parfaite et peut commettre des erreurs, il est donc nécessaire de toujours relire, vérifier, comprendre, et tester un code généré par une IA. Il est également important de veiller à utiliser l’IA de manière éthique et responsable. 😉
Comment accéder à l’IA
Nous utiliserons donc dans ce tutoriel ChatGPT, un chatbot qui utilise l’intelligence artificielle.
Le chat est disponible à tous gratuitement via l’URL suivante : https://chat.openai.com/auth/login. Voici la page dans laquelle vous accèderez :
Comme vous l’avez sans doute deviner, vous aurez besoin d’un compte OpenAI pour utiliser cette IA. Cliquez donc sur le bouton Sign up pour créer un compte, ou sur Log in si vous en avez déjà un.
Quand vous vous serez alors connecté avec succès, vous tomberez normalement nez à nez avec la page suivante, la page principale :
Cette page est assez simple au final, nous retrouvons en haut à gauche un bouton qui nous permet de créer d’autres chat. En effet, l’IA est capable de « retenir », réutiliser, et prendre en compte l’historique des précédents messages ! Donc si on discute avec elle sur des sujets précis, et que nous souhaitons ne pas mélanger des conversations, nous pouvons en ouvrir plusieurs qui seront indépendantes les unes des autres, il suffit donc d’appuyer sur ce bouton, intitulé New Chat.
Et puis en bas, nous retrouvons la barre où nous pourrons écrire et discuter avec l’IA. Tout ce qu’il y a de plus classique.
Utilisation de l’IA pour générer et modifier des scripts Python
L’IA peut être utilisé pour la génération, ou plutôt l’écriture de scripts Python.
Voici donc ci-dessous quelques exemples, assez époustouflants, où nous pouvons utiliser l’IA pour générer des scripts Python.
Mise en situation : Catastrophe, un DS de mathématiques demain et j’avais complètement oublié ! Il me faudrait un script Python qui puisse me calculer le discriminant ainsi que les racines d’une fonction, cela me ferait gagner beaucoup de temps…
Voyons de quoi est capable l’IA :
Aussitôt dit, aussitôt fait, l’IA nous pond une fonction python qui nous permet de calculer le discriminant et les racines d’une fonction du second degré.
Vous noterez qu’il est déjà possible d’obtenir le discriminant et les racines d’une fonction du second degré sans script python en sachant bien utiliser sa calculatrice. 😁
Essayons autre chose, un peu d’art pour voir ! J’aurai besoin d’une fonction me permettant de créer une étoile, à l’aide du module Turtle. Mais ajoutons un peu de piment à tout ça ! La fonction devra prendre en paramètre : La position x et y de l’étoile, la couleur de l’étoile, la taille de l’étoile, ainsi que le nombre de branches de l’étoile. 😈
Et maintenant, la question tant attendu : Est-ce que ça marche cette sorcellerie ? Et bien la meilleur façon de savoir, c’est de tester !
Voici donc le rendu sur Thonny :
Comme vous le voyez c’est très très impressionnant.
En expliquant clairement nos attentes, et nos contraintes. L’IA les respecte (ou en tout cas essaie) et nous offre un code documenté, et la plupart du temps optimisé.
À ce stade, la première question que nous pouvons nous poser est de savoir si le code généré par l’IA sort de ses mains, ou si elles il vient d’Internet. Pour le savoir, je vous laissez deviner, demandons lui simplement !
Ainsi, nous avons vu que l’IA était capable d’écrire du code python selon nos envies. Mais à l’évidence, elle peut aussi être utilisée pour modifier du code python. De la même manière, nous n’avons qu’à lui soumettre notre script à modifier, et lui demander ce qu’elle a à faire. Ensuite, laissez la magie opérer…
Voyons cela, voici le code suivant (qui n’a pas été écrit par l’IA) :
n = input("Choisissez un nombre.\t")
try:
n = int(n)
except ValueError:
exit("Ce n'est pas un nombre.")
is_prime = 1*(n > 1)
for i in range(2, n):
if n % i == 0:
is_prime = 0
break
print("Ce nombre est premier." if is_prime else "Ce nombre n'est pas premier.")
Grosso modo, ce script nous dit si un nombre n est premier ou non. Demandons lui de l’optimiser :
Effrayant ou époustouflant ? 🤔
Utilisation de l’IA pour corriger des scripts Python
Bon jusqu’ici, nous n’avons pas été déçu. Voyons de quoi elle vaut dans la correction de scripts python. Voici ci-dessous un exemple concret d’utilisation pour corriger un script Python.
Ci-dessous, un script Python censé afficher la table de 5 :
table = 5
print("Table de" + table + ":")
for i in range(11):
print("5x" + i + " = " + 5*i)
Malheureusement, je n’arrive à lancer le script et je ne comprends pas l’erreur : TypeError: can only concatenate str (not "int") to str
Demandons donc à l’IA. Enfin, nous allons seulement lui envoyer notre bout de code tel quel et observer ce qu’il se passe :
Vous avez bien compris, l’IA a deviné par elle même que je voulais qu’elle corrige mon code en python, en remarquant qu’il y avait des erreurs dans celui-ci.
Nonobstant, en cas d’incompréhension d’une erreur, je conseille d’abord de demander à l’IA ce que signifie l’erreur, et d’essayer de la corriger sans son aide. L’IA est capable d’expliquer très clairement un concept, avec des exemples et possiblement des formulations différentes :
Comme vous le voyez, c’est assez spectaculaire, l’IA nous explique explicitement l’erreur, et ajoute des exemples tout au long de son explication. En l’occurrence comme vous l’avez vu, c’était un problème de concaténation.
Conclusion
En conclusion, l’utilisation d’une intelligence artificielle (IA) peut être un outil très utile pour aider les développeurs Python à générer, corriger et modifier leur code. Il existe de nombreux outils et bibliothèques qui permettent d’intégrer l’IA dans le développement de logiciels, comme nous l’avons vu précédemment il y a ChatGPT, mais il existe aussi des alternatives tout aussi époustouflantes, comme GitHub Copilot.
En utilisant ces outils, les développeurs peuvent gagner du temps et de l’efficacité dans leur travail quotidien et se concentrer sur des tâches plus complexes. Cependant, il est important de noter qu’il est toujours important de comprendre et de maîtriser les principes de base du développement de logiciels, même si l’on utilise l’IA pour automatiser certaines tâches.
Vous l’aurez compris, pour ne pas finir à l’hôpital des fous, il est toujours sympa d’avoir un petit assistant sous la main !
Une horloge analogique… Qu’est-ce cela peut bien être… Eh bien, c’est tout simplement une horloge avec des aiguilles ! Ainsi, ce programme vous permettra, grâce à Turtle, d’afficher une horloge analogique…
Introduction
La spécificité de cette horloge, est que celle-ci est dynamique. C’est-à-dire que les aiguilles bougent en fonction de l’heure réel. Sinon cela serait trop facile, il suffirait seulement de dessiner un cercle pour le cadran, et des segments pour les aiguilles, et c’est fini. Heureusement, ce n’est pas le cas.
Quelques fonctions
Pour afficher l’heure réel, il faut d’abord récupérer l’heure réel… Pour cela, j’utilise la fonction time.strftime(), à partir du module time, je récupère une donnée de la date actuelle, en l’occurrence j’ai besoin de 3 données : l’heure, la minute, et la seconde. Voici donc une fonction que j’ai codé qui m’a permis de récupérer une de ces 3 données :
def get_time(u):
match u:
case "h":
return int(strftime("%I"))
case "m":
return int(strftime("%M"))
case "s":
return int(strftime("%S"))
Ici, j’ai utilisé la déclaration match, qui permet, entre autres, de comparer la valeur d’une variable, ici la variable u (pour unité). Par exemple, en appelant la fonction suivante get_time("h"), elle me renvoi la valeur de l’heure actuelle, à l’heure où j’écris cet article, il est exactement 01:44 donc en appelant la fonction maintenant, elle me renverrait la valeur 1. À savoir qu’utiliser la déclaration match n’est absolument pas obligatoire, j’aurais très bien pu utiliser une structure conditionnelle traditionnelle avec les déclarations if, elif, et else.
Désormais, j’ai besoin d’afficher le cadran de l’horloge, pour cela, rien de plus simple :
def draw_clock(x, y, rayon):
travel(x, y-rayon)
pencolor((0,)*3)
fillcolor((255,)*3)
begin_fill()
circle(rayon)
end_fill()
travel(x, y-rayon+10)
fillcolor(7, 24, 31)
begin_fill()
circle(rayon-10)
end_fill()
travel(x, y-5)
fillcolor(85, 91, 92)
begin_fill()
circle(5)
end_fill()
penup()
goto(x, y)
setheading(90)
pencolor((255,)*3)
for i in range(60):
forward(rayon-(25 if i%5 == 0 else 15))
pendown()
forward(25 if i%5 == 0 else 15)
penup()
goto(x, y)
right(6)
C’est une fonction plutôt simple, bien qu’elle soit assez lourde. On dessine des cercles, et on fait les marquages des minutes et des heures. J’ai dans cette fonction, utilisé une autre fonction qui ne vient pas des modules importés, la fonction travel() (pour voyager). J’aime beaucoup cette fonction car elle est extrêmement simple, et permet d’économiser quelques lignes :
def travel(x, y):
penup()
goto(x, y)
pendown()
En fait, c’est tout simplement l’équivalent d’un goto(), mais sans laisser les traces du pinceau ! Voici donc le cadran, il est fixe :
J’ai également voulu ajouter dans le fond un mur en briques. Pour ne pas laisser le fond vide, la fonction fait seulement 7 lignes :
def wall_brick(x, y, width_bricks, height_bricks):
for i in range(height_bricks):
for j in range(width_bricks):
if i % 2 == 0:
fill_rect(x+65*j, y+35*i, 60, 30, (161, 84, 68))
else:
fill_rect(x+30+65*j, y+35*i, 60, 30, (161, 84, 68))
Les paramètres sont simples, la position du mur (le bas à gauche du mur) via x et y, et le nombre de briques en longueurs, ainsi que le nombre de briques en hauteur. fill_rect() est une fonction maison inspiré de kandinsky.fill_rect(), elle permet de dessiner des rectangles :
def fill_rect(x, y, w, h, c=(0, 0, 0)):
travel(x, y)
pencolor(c)
fillcolor(c)
begin_fill()
for i in range(4):
forward(w if i % 2 == 0 else h)
right(90)
end_fill()
Ci-dessous donc, le mur en briques, contruit par la fonction wall_brick(-668, -330, 21, 21) :
Difficultés rencontrées
Il ne reste donc plus qu’à dessiner les aiguilles et les faire pivoter au fur et à mesure. Voici donc la fonction qui occupe cette lourde tâche, et qui m’a bien cassé la tête :
def clock_hands(colors_hands, size_hands):
s, m, h, k = get_time("s"), get_time("m"), get_time("h"), 0
update_hours(h, colors_hands[0], size_hands[0])
update_minutes(m, colors_hands[1], size_hands[1])
while True:
update_seconds(s, colors_hands[2], size_hands[2])
sleep(.6 if k < 90 else .5 if k < 180 else .3 if k < 240 else 0)
s += 1
if s == m+2:
update_minutes(m, colors_hands[1], size_hands[1])
if s+1 == (h+1)*5:
update_hours(h, colors_hands[0], size_hands[0])
if s == 60:
s, m, h = get_time("s"), get_time("m"), get_time("h")
update_minutes(m, colors_hands[1], size_hands[1])
update_hours(h, colors_hands[0], size_hands[0])
update_seconds(s, colors_hands[2], size_hands[2], 1)
k += 1
C’est sans doute la fonction la plus compliquée du programme. Les deux paramètres ne sont qu’esthétique, ils permettent de modifier la couleur de chaque aiguille, ainsi que la largeur de chaque aiguille, on ne donc y s’attarder plus que ça. L’objectif est simple, avoir l’heure la plus précise possible, mais en gardant un mouvement des aiguilles fluide. J’ai fait le choix d’appeler la fonction get_time() le moins de fois possible, car elle requiert de faire un nombre extrêmement élevé de requêtes plusieurs fois par secondes. Et faire des requêtes inutiles, ça ralentit le programme… La fonction n’est donc appelée que lors de l’initialisation (avant de rentrer dans la boucle infinie), et lorsque la trotteuse à passe à la soixantième seconde. Nous appelons donc la fonction get_time() environ une fois par minute ; et c’est suffisant. Ensuite, on met à jour la position des aiguilles toutes les secondes… Enfin, c’est un peu plus compliqué que ça. En effet, il faut que le mouvement soit fluide, et donc il faut supprimer toutes les actions inutiles. Sauf que 98% du temps, il n’y a que l’aiguille des secondes qui bouge, celle des minutes et des heures ne bougent beaucoup moins souvent. Donc cela ne sert à rien de mettre à jour ces aiguilles à chaque seconde. On le fait donc à des instants précis. Malgré toutes les optimisations pour fluidifier le rafraichissement, il n’est malheureusement pas parfait. Également, il s’avère que plus le programme tourne longtemps, plus il est lent… Il faut donc adapter la pause de la fréquence en fonction de quand le programme a démarré. Voici à quoi sert la variable k, et la fonction time.sleep(), nous perdons donc beaucoup de précisions au fil du temps. Mais en contrepartie, j’ai mis en place un système pour rerégler automatiquement les aiguilles.
L’image finale
À toi de « jouer » ?!
Tu ne pourras malheureusement pas vraiment t’amuser avec ce programme. À moins que tu veuilles fixer une horloge. Néanmoins, si tu veux savoir comment elle fonctionne exactement, et la voir bouger, n’hésite pas à télécharger le script !
Ce mini tutoriel vous propose quelques exemples de scripts python, simple à comprendre et à modifier, vous permettant de débuter sereinement la réalisation d’une image dessiné avec le module turtle de python.
Cet article a été écrit à deux mains, ainsi vous ne saurez pas qui accabler ci vous y trouvez des coquilles 😅
Tableau des méthodes Turtle en python
Ce tableau présente quelques méthodes turtle, mais il en existe d’autres, il ne faut pas hésiter à lire la documentation officielle : turtle — Turtle graphics
instructions
Explication en français
Exemples d’utilisation
forward(distance)
La tortue avance de distance dans la direction précédemment fixée
il existe de nombreuses autres fonctions dans le module turtle, lisez la documentation officielle : turtle — Turtle graphics et cherchez d’autres tutoriels !
Dessiner des triangles équilatéraux
Le script ci-dessous définit une fonction, capable de construire un triangle équilatéral aux coordonnées (x, y) et de spécifier la longueur du côté du triangle. La couleur par défaut est le noir #000000 ou (1,1,1) mais cette couleur peut-être personnalisé lors de l’appel de la fonction.
from turtle import *
from random import randint
colormode(255)
def triangle(longueur, x, y, couleur=(1, 1, 1)):
penup()
goto(x,y)
pendown()
pencolor(couleur)
for i in range(3):
forward(longueur)
left(120)
for i in range(42):
x, y = randint(-600, 400), randint(-300, 200)
long = randint(10, 200)
color = (randint(0, 255), randint(0, 255), randint(0, 255))
triangle(long, x, y, color)
Dessiner des cercles
Le script ci-dessous définit une fonction, capable de construire un cercle aux coordonnées (x, y) et de spécifier la longueur du rayon de ce cercle. La couleur par défaut est le noir #000000 ou (1,1,1) mais cette couleur peut-être personnalisé lors de l’appel de la fonction.
from turtle import *
from random import randint
colormode(255)
def cercle(rayon, x, y, couleur=(1, 1, 1)):
penup()
goto(x, y-rayon)
pendown()
pencolor(couleur)
circle(rayon)
for i in range(42):
x, y = randint(-600, 400), randint(-300, 200)
radius = randint(10, 200)
color = (randint(0, 255), randint(0, 255), randint(0, 255))
cercle(radius, x, y, color)
Dessiner des disques
Le script ci-dessous définit une fonction, capable de construire un disque aux coordonnées (x, y) et de spécifier la longueur du rayon de ce disque. La couleur par défaut est le noir #000000 ou (1,1,1) mais cette couleur peut-être personnalisé lors de l’appel de la fonction.
from turtle import *
from random import randint
colormode(255)
def disque(rayon, x, y, couleur=(1, 1, 1)):
penup()
goto(x, y-rayon)
pendown()
pencolor(couleur)
fillcolor(couleur)
begin_fill()
circle(rayon)
end_fill()
for i in range(42):
x, y = randint(-600, 400), randint(-300, 200)
radius = randint(10, 200)
color = (randint(0, 255), randint(0, 255), randint(0, 255))
disque(radius, x, y, color)
Ecrire des fonctions et les réutiliser
Une manière intelligente d’écrire un script est de coder des fonctions, des fonctions paramétrables.
Les fonctions proposées ci-dessus sont paramétrables :
coordonnées (x, y),
couleur,
rayon ou longueur
Nous aurions pu ajouter d’autres paramètres à ces fonctions, comme par exemple la largeur du trait ou une rotation initiale dans le cas des triangles…
Un exemple d’image générée avec une unique fonction, cette fonction est appelée dans une boucle.
Un champ de rose (source), un script de moins de 42 lignes, beaucoup moins !
La fonction elle même contient une boucle.
L’histoire raconte que plusieurs milliers de cercles ont été tracés.
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 / Diminuer
Se déplacer
Changer 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.
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
Naviguer
Modifier / Régler
Choisir / 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.
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é ! 😏
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 !
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.
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 !
🧐 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
avantaprès
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 (En – Fr)
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.
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 ▽
▷
◁
OK
Ans
Naviguer
Accéder / Calculer
Réinitialiser / Menu
Sauvegarder / Charger
Quitter le programme
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.
NumApps
