Le Sokoban est un jeu de puzzle inventé au Japon en 1982. Le principe est simple : vous êtes un gardien d’entrepôt et vous devez amener les caisses aux bons emplacement. Pour cela, vous pouvez uniquement pousser les caisses, et une seule à la fois.*
Une partie des informations de cette page sont extraites de la page Wikipédia Sokoban. Si vous souhaitez creuser le sujet, n’hésitez pas à la consulter.
L’objectif du jeu est de résoudre les niveaux en un nombre minimum de déplacements. Par ailleurs, il existe des milliers de niveaux, pour la majorité créés par la communauté. En fonction de la taille et de la complexité de la grille, ainsi que de l’exigence de l’utilisateur pour réduire son nombre de coups, tous les niveaux de difficultés sont imaginables. Ces éléments donnent une grande durabilité au jeu.
En raison de son apparition rapide dans le monde du jeu vidéo, de sa simplicité apparente et de son intérêt toujours renouvelé, le jeu a connu un grand succès et a été développé sous de nombreuses versions et plateformes. A mon tour de le porter sur la calculatrice NumWorks !
Fonctionnalités
Aide (règles, touches, signification des couleurs) affichée au lancement et accessible à tout moment.
Ajustement de l’affichage à la taille de la grille.
Possibilité d’annuler les mouvements précédents.
Déplacement rapide.
Détection de la victoire.
Ajout et choix de niveaux facile (voir la section correspondante).
Lancer le jeu
Le moteur de jeu et le contenu (les niveaux) sont stockés dans des scripts séparés :
Pour jouer, il faut télécharger ces scripts et exécuter sokoban.py. Il vous est demandé de préciser la cartouche (liste de niveaux) à utiliser ainsi que le niveau auquel vous souhaitez commencer. Il n’est pas nécessaire de remplir ces champs, le jeu commencera par défaut au niveau 1 de la cartouche soko.
Ajouter des niveaux
Si vous venez à bout des 50 niveaux inclus dans la cartouche de base, vous pouvez en télécharger une autre sur le Workshop. Ils sont nommés soko1, soko2, … Pour les utiliser, il suffit de rentrer le nom de la cartouche au lancement du jeu.
Une présentation détaillée de ce projet à été publiée sur tiplanet.org
Tout le monde sait qu’une calculatrice programmable sert à jouer à des jeux. Or quand on parle de jeux, un des premiers à nous venir en tête est Tetris, alors pourquoi pas un Tetris pour NumWorks ?
Ainsi, après un démineur, un snake, on vous propose cette fois ci le jeu mythique de la Gameboy adapté en flat design et codé en python pour la NumWorks.
Donne moi 32 ko, je te ferai un Tetris !
Jusqu’à la version 13.2 d’Epsilon, l’OS officiel de la NumWorks, faire un jeu en python sur la couche graphique de la NumWorks était impossible et les scripts commençaient à planter dès qu’ils pesaient 3-4 ko.
Avec un tas python heap de 32 ko, on peut enfin commencer à s’amuser et monter des projets dont le code source pèse près de 8ko.
Le récit de la création d’un jeu en image
Tout commença le 19 avril 2020 dans une nuit confinée.
🧐 Bon on vient de finir nos trois projets en python, on fait quoi maintenant ? 🤓 Oh on peut acheter des contrefaçon de Gameboy sur Aliexpress pour 10€ ! Et il y a 400 jeux dedans. 🧐 La nuit porte conseil, on en parle demain, enfin dans quelques heures !
Le lendemain :
🧐 Bon on fait un Tetris. Je viens de lire l’article sur Wikipédia, c’est passionnant. Par contre par un mot à Arthur, il va nous piquer notre idée sinon. Et cette fois, on ne stocke pas coordonnées des cases occupées dans des matrices, et on va utiliser la fonction get_pixel() de la NumWorks pour déterminer si une case est occupée ou non.
et c’est ainsi qu’un premier Tétrominos apparaît à l’écran.
🤓 J’ai peut être fini la collision 🧐 Hein ?! Mais j’ai pas commencé moi… 🧐 Bon je partage l’écran. Qu’est ce qu’on a dit déjà ? 120 pixels pour le menu, 120 pixels pour le score et 42 pixels pour le jeu en lui même c’est bien ça ?
🧐 Bon je viens de finir la maquette d’une ébauche de menu, reste à le coder ! 🤓 et moi je viens de finir les collisions … 🧐 Pour les couleurs ça sera délicat et subtil. On va s’écarter du code couleur original.
🧐 Et du coup on va faire un rappel dans le menu 🤓 On fixe les points d’ancrage dans les pièces, et ainsi elles peuvent tourner
Rendu final souhaité (et obtenu)
🤓 Astuce : Si tu joues sur Omega, alors l’interface du jeu n’est plus orange mais rouge, elle s’adapte au fork de Epsilon.
🧐 D’ailleurs faudra que je relance l’équipe de développement de Omega, ils m’ont promis un tas python de 120 ko et j’ai l’impression que ce projet n’avance pas ! 🧐 Bon ils sont encore sur répondeur, ils ont du bloquer mon numéro ! 🤓 On fait une pause, j’ai envie de jouer un peu :
🧐 Bon je vais spoiler Critor de tiplanet.org mais toujours aucune info à Arthur ! 🤓 Score codé, avec des fonctions polynôme et les points marqués dépendent du niveau du jeu … 🧐 Niveau max : 99, Score max : 999 999 🤓 Vitesse du jeux codé, avec une fonction logarithme népérien car un polynôme n’était pas adapté …
🧐 Bon maintenant s’agit de faire un gros score, histoire d’être certain que Critor ne nous batte pas !
Commencé un dimanche, fini le mercredi suivant, c’était presque trop facile !
🧐 Je reviens, je vais conseiller à Critor de commencer level 42, ça plantera son score !
Meilleurs scores
Team nsi.xyzTeam tiplanet.org
🧐 Il a commencé sa partie directement au niveau 42, du coup son score est à peine acceptable !🤓 En plus, il a triché ! Il a utilisé une vision prédictive triple et la grille d’aide !
Bien évidemment, il a nié avoir triché 🙄
Je ne les ai même pas utilisés, c’était pour mettre à l’écran le maximum d’éléments visuels, car j’étais parti pour l’utiliser également comme photo d’illustration d’article
Xavier Andréani, alias Critor du tiplanet.org
Mais nous ne sommes pas dupes non plus !
Epsilon 20…
31 Janvier 2023, une nouvelle version du système d’exploitation de la NumWorks est publié : Epsilon 20 ! 😍 NumWorks décide alors d’enfin implémenter le tableau périodique (qui était déjà d’ailleurs disponible sur Omega depuis un bon moment) dans son système, mais décide également de mettre à jour le fonctionnement du codage des couleurs dans l’application Python, ce qui a pour effet de mettre le Tetris, sortie 3 ans plus tôt, complètement KO et dysfonctionnel…
2,5 ans plus tard
🧐 Bon, ça fait plus de 2 ans que le Tetris est planté, il va falloir faire quelque chose… 🧐 Demande de l’aide à Kevin 🤓 Un peu sous l’eau en ce moment, ça bosse ici (il faut bien payer les impôts pour augmenter les parlementaires et les professeurs) 😎 J’aurai un peu de temps après mes partiels, je peux y jeter un œil et en profiter pour mettre à jour l’interface, j’aurai juste à reprendre le code de l’UI/UX du Mastermind, il est flexible et facilement implémentable 😎 Bon ça m’a pris toute la journée mais c’est censé être bon, j’en ai aussi profiter pour rajouter un système de pause, je me souviens qu’à l’époque c’était frustrant de perdre sa partie quand le prof passait derrière… 🧐 Tsss
Etudiant au lycée Louis Pasteur de 2017 à 2020
Actuellement en cycle préparatoire à Polytech Marseille.
Coder, c’est un peu comme créer la vie en étant bourré, on fait souvent des erreurs.
Un jeu commence souvent par un écran de paramétrage. Celui-ci doit être ergonomique, intuitif, et permettre à l’utilisateur final de personnaliser son expérience ludique. Cette article présente l’un des tout premier menu adaptable conçu en python pour la calculatrice NumWorks, ainsi que 3 exemples d’utrilisation.
Le contexte
Avec la sortie de la version 13.2.0 d’Epsilon, l’OS qui anime la calculatrice NumWorks, les capacités de la calculatrice à exécuter des scripts python a été doublée.
Le tas python « heap » est ainsi passé de 16ko à un peu plus de 31ko. Et on peut donc désormais se lancer dans des projets un peu plus ambitieux.
Après avoir développé chacun un démineur en python pour la NumWorks, nous avons décidé de mettre au point un système de menu commun, paramétrable, utilisable dans ces deux démineurs et dans le snake que Arthur Jacquin a développé.
Ce menu a été codé pour permettre un maximum de souplesse, donc n’hésitez pas à l’utiliser comme tel ou à l’adapter.
D’un écran statique à un menu dynamique
Le « menu » originel de l’un des deux démineurs n’est en fait que du texte, affiché quelques secondes, uniquement lors du premier lancement du jeu. On ne peut pas interagir, et il va falloir intuiter le fonctionner des différentes touches.
Sur une application de calcul mental, nous avions conçu un vrai menu en mode texte :
Avec un système de navigation interne au menu primitif mais fonctionnel.
L’idée était donc de créer un menu ergonomique, sur la couche graphique de la NumWorks.
Les quelques croquis conceptuels ci-dessous illustrent parfaitement le cheminement fait d’essais/erreurs pour concevoir un menu simple, intuitif, ergonomique. La démarche est évidemment ponctuée de tests de positionnement.
Croquis
Test
Vertical ou horizontal ? Hybride ? Finalement, c’est l’affichage vertical qui est retenu, avec une coloration de l’objet actif pour une navigation claire, simple, en flat design.
Menu final – action
Menu final – paramètre
Fonctionnalités
S’accorde avec la couleur de l’OS (Epsilon est orange, Omega rouge),
Permet le paramétrage de 1 à 5 paramètres, comportant autant d’options que souhaité,
Permet une option par défaut pour les paramètres,
Design épuré, minimaliste,
Possibilité d’afficher des informations sur plusieurs lignes.
Brancher le menu sur votre programme
Il suffit ensuite d’appeler la fonction menu() avec votre application. Elle retourne une liste des paramètres validés.
Il est souhaitable de faire cet appel proprement, et de prévoir le cas ou le menu n’est pas disponible, ainsi si le menu n’est pas présent sur la calculatrice, alors le jeu fonctionnera quand même avec des paramètres par défaut.
Pour les utilisateurs avancés de ce menu, il est également possible de modifier les paramètres d’affichage avec une version souple (les versions du menu seront déclinées en fin d’article), permettant ainsi d’afficher plus de 5 paramètres, des chaînes de caractères plus longues, ou d’ajuster selon vos goûts.
Un branchement plus détaillé est présenté à la fin de cet article.
Paramètres de la fonction()
Le deuxième paramètre est le nom de l’action correspondant à la validation des paramètres, ici « Lancer la partie ».
Les paramètres suivants sont stockés dans des listes, il peut y en avoir jusqu’à 4 ou 5 et le dernier gère l’affichage sur deux lignes de manière optionnelle. Chaque paramètre comporte, dans l’ordre :
1 nom (chaîne de caractère)
1 ou plusieurs options
Affichage d’information
Les paramètres, comme leur nom l’indique, sont destinés à paramétrer l’expérience qui suivra ce menu. Cependant, vous pouvez également les utiliser pour afficher des informations, telles que les crédits ou les commandes. C’est notamment pour cela qu’est prévu l’affichage sur plusieurs lignes (qui est optionnel).
L’affichage multiligne n’est utilisable uniquement sur le dernier paramètre, et réduit évidemment le nombre de paramètres possibles. Pour l’activer, il suffit de séparer le contenu de la première ligne et celui de la deuxième par un dollar ($), par exemple :
« Auteur$Vincent Robert »
« Site web$nsi.xyz/snake »
« Navigation$Flèches »
Le dollar ($) est un caractère ACSII standard mais il faudra le saisir depuis le workshop, il n’est pas disponible de le saisir directement sur la calculatrice.
Epsilon ou Omega ?
L’essai d’une fonction exclusive à Omega suffit, et permet un accord visuel de l’objet actif avec la barre de titre de l’écran :
Les différents projets, et notamment les jeux, nécessitent très souvent un système de détection des touches pressées. La fonction wait() est destinée à cet usage, et s’importe en même temps que le menu. Pratique !
def wait(buttons = range(53)): # Attends qu'une des touches précisées soit pressée
while True:
for i in buttons:
if keydown(i):
while keydown(i): True # Fonction anti-rebond
return i
La fonction, par défaut, attendra qu’une des 46 touches soit pressée. Cependant, pour plus d’efficacité et pour n’avoir à traiter uniquement les signaux qui vous intéressent, vous pouvez passer en paramètre la liste des touches à interroger.
La table des codes clavier de la NumWorks est accessible sur cet article de Ti-Planet.
Table des codes clavier
Tester le menu
Le menu est disponible ici :
Menu
Version A
Version B
Variations
Le titre est en noir, quelques variations dans le code mais le rendu final est identique
Le titre est en bleue, quelques variations dans le code mais le rendu final est identique
app.py est l’application qui intègre une copie du code du menu, app_se.py désigne une édition spéciale, allégée de menu qui est appelé depuis un autre script. Ainsi, le code du menu est mutualisé, ce code occupe donc moins de place car l’espace de stockage des scripts sur la calculatrice est limité.
Les applications app_se.py peuvent se lancer à priori sans le menu, mais dans ce cas là, il n’est pas possible de paramétrer l’application. On a encore quelques bug à résoudre, un try import semble ne pas fonctionner … On travaille sur ce sujet. Les applications sans _se sont par contre fonctionnelles.
Si l’équipe de Numworks nous lit, on aimerait bien
profiter un peu des 8 Mo de la ROM de la N0110, et donc avoir plus de 32ko pour stocker nos scripts
Que les touches les touches manquantes soient mappés sur le workshop, c’est à dire qu’il faut mapper toutes les touches en fait et non pas seulement 7…
Brancher proprement le menu sur une application
Un branchement propre est un branchement qui se comporte ainsi :
Si au lancement du script, la fonction menu() n’est pas détectée alors le jeux ou l’application se lance avec les paramètres par défaut, c’est un fonctionnement dégradé mais l’application marche. (On a encore quelques bug à résoudre)
Si au lancement du script, la fonction menu() est détectée, le menu se lance.
Exemple de branchement qui intègre le mode de fonctionnement dégradé :
Pour que tout ceci marche, il faut que la calculatrice importe le script menu.py et le script qui utilise le menu lors de la bascule vers la console d’éxécution. Ce fonctionnement ne peut malheureusement pas être simulé sur le workshop, mais sur calculatrice cela fonctionne.
Depuis le gestionnaire de script python, il suffit d’activer les options : « Importation auto dans la console » des deux scripts.
Enseignant de mathématiques et de spécialité NSI, Lycée Louis Pasteur d’Avignon.
Aime compter jusqu’à 666 mais s’arrête souvent à 42.
Auteur du livre Découvrir la calculatrice NumWorks.
Le snake est un jeu très ancien, apparu en 1976 dans Blockade. Le principe est simple : le joueur dirige un serpent qui grandit, et doit éviter le plus longtemps possible de se mordre la queue ou les bordures. Il existe cependant de très nombreuses variantes. Nous vous proposons ici un snake codé en python pour la NumWorks.
Un classique des portables Nokia sous Symbian OS
Sa simplicité apparente et son caractère addictif l’ont mené à être porté sur de très nombreuses plateformes, provoquant un succès planétaire. Nokia y a grandement participé en l’intégrant sur ses téléphones dès 1998, y compris l’iconique 3310.
Cet article présente donc une énième version de ce jeu, cette fois pour la calculatrice NumWorks.
Evolution et défis
La première version ne propose pas d’option et stocke le corps du serpent dans une liste constituée des coordonnées, en divisant l’écran en une grille de 32 par 20 carreaux :
snake = [[3, 3], [4, 3], [5, 3], [6, 3]] # Corps du serpent, de la queue à la tête
Fonctionnel, très pratique pour le faire avancer, par les méthodes pop()et append(), et pour savoir comment dessiner les bordures. Cependant un problème apparaît rapidement : l’occupation de la mémoire. En effet, les listes, et tout particulièrement les listes de listes, sont très coûteuses.
La première évolution a donc consisté à changer le système de stockage du serpent : désormais, seules les coordonnées de la queue et la tête sont enregistrées, diminuant considérablement la place occupée en mémoire, et ce quelle que soit la longueur du serpent.
snake = [3, 3, 6, 3] # Coordonnées de la queue et de la tête
Cela demande en revanche de modifier l’ensemble des procédures graphiques, et d’utiliser une méthode de détection de couleur de pixel, kandinsky.get_pixel(). Les fonctions get_pixel() et set_pixel()n’étant pas bijectives, il a fallu s’assurer de la bijectivité des couleurs utilisées. (Ceci fera l’objet prochainement d’un article dédié)
Pour éviter des conversions fréquentes entre les coordonnées de la grille et celles des pixels, l’ensemble des coordonnées est ensuite modifié pour ne présenter uniquement des coordonnées en pixels.
snake = [30, 52, 60, 52] # Coordonnées de la queue et de la tête
La gestion de la direction a également suscité réflexion, car il faut pouvoir saisir à tout moment les instructions de changement de direction, et il faut également éviter au joueur de mourir lors des demi-tours. Après quelques améliorations, on arrive à ce code :
# Gestion du temps et de la direction
direction = di
while monotonic() < time + speed: # Attente du prochain rafraîchissement du serpent
for k in range(4): # Changement de direction
if keydown(k) and direction+k != 3: di = k
if keydown(6): start() # Retour au menu
time = monotonic()
A la demande de Robert Vincent, j’adapte le code pour pouvoir implémenter un mode où la téléportation d’un bord à l’autre de l’écran est possible, par un jeu de modulos. Le script perd en optimisation, mais gagne en polyvalence.
Les étapes suivantes sont moins lourdes de conséquences :
ajout de différents niveaux de difficulté, modifiant la vitesse du serpent et l’intensité de son agrandissement à chaque pomme mangée.
ajout du mode « Dingue », où le serpent grandi et accélère tout seul, progressivement, au lieu de manger des pommes.
Les dernières étapes ont été de brancher le jeu sur un menu polyvalent graphique en python codé en parallèle, et de finaliser les options d’accessibilité :
Le démineur, jeu de réflexion dont le but est de localiser des mines cachées dans une grille représentant un champ de mines virtuel, avec pour seule indication le nombre de mines dans les zones adjacentes est désormais porté en python sur ta NumWorks !
Souvenir de jeunesse
J’ai découvert la programmation sur une désormais antique Casio 9960GT, propulsé par son CPU 8 bits à 4,3 MHz. Lycéen et autodidacte, j’ai alors entrepris de créer un démineur sur ma calculatrice et cela fut pour moi une découverte de différents concepts en algorithmique.
Le processeur de cette génération de calculatrice était tellement lent et l’accès à la mémoire encore plus lent que chaque test logique prenait un temps considérable. Le démineur codé et parfaitement fonctionnel se montrait ainsi d’une lenteur remarquable au premier lancement lors de l’affichage de la couche graphique, il fallait près de 42 secondes pour initialiser la couche graphique.
Quelques caractéristiques de ce démineur :
5 niveau de difficulté
un plateau de jeu de 14 cases par 7, soit 98 cases en tout.
L’initialisation de la couche graphique prenait à elle seule plus de 30 secondes
La navigation était fluide, mais la fonction découverte pouvait prendre une bonne dizaine de seconde.
Sur une NumWorks, en Python
20 ans plus tard, l’idée est donc de coder un nouveau démineur, en python, et de le faire tourner sur la calculatrice à la mode du moment : une NumWorks, propulsé par un CPU ARMv7 à 100 / 200 mhz, donc probablement plus de 50 fois plus rapide que celui de mon antique Casio.
Mes élèves de seconde étant tous équipés de cette calculatrice, ils pourront s’amuser en silence quand les cours sont trop ennuyeux, et cela montrera aux futurs élèves de la spécialité NSI les possibilités de la calculatrice et la souplesse du langage python.
L’objectif est de sortir ce démineur pour la sortie officielle de la version 13 de Epsilon, le logiciel sous licence CC BY-NC-SA de la calculatrice NumWorks. La version 13 de Epsilon introduit beaucoup d’améliorations et de nouveautés à l’application Python, celle qui nous intéresse particulièrement et le getkey, la capacité de la calculatrice dans un script python à détecter si une touche est pressée.
Le site tiplanet.org ayant déjà bien documenté cette fonctionnalité, on dispose donc déjà des codes associés aux touches :
Créer une interface graphique
Pour faire un démineur, on a besoin d’un tableau de n lignes et p colonnes dans lequel on va afficher une mine, un drapeau ou un chiffre.
Il faut donc s’adapter à la résolution de l’écran, et la principale contrainte à prendre en compte est la taille d’affichage des chiffres.
def terrain(): #Affiche la grille
fill_rect(8,21,300,200,c[9])
for y in range(21,243,20):
for x in range(8,309):
set_pixel(x,y,c[10])
for x in range(8,320,20):
for y in range(21,222):
set_pixel(x,y,c[10])
def cl(x,y):
fill_rect(9+20*x,22+20*y,19,19,c[0])
def drapeau(x,y):
fill_rect(17+20*x,26+20*y,3,9,c[12])
fill_rect(17+20*x,36+20*y,3,3,c[12])
def mine(x,y): # Ce code ne sera pas retenu pour la version finale.
cl(x,y);
fill_rect(12+20*x,36+20*y,13,4,c[9])
fill_rect(14+20*x,34+20*y,9,2,c[11])
fill_rect(17+20*x,32+20*y,3,2,c[5])
Une matrice pour stocker les mines
Le plus simple est de stocker les mines dans une matrice 10×15. Pour cela on défini une matrice en python et on la rempli de 0.
m = [[0 for y in range(10)] for x in range(15)]
puis un script génère des bombes, codées 999 dans la matrice.
def gvt(): #fonction renommée depuis ...
b = 20
while b>0:
x, y = randint(0,14),randint(0,9)
if m[x][y]!=999:
m[x][y]=999
b-=1
for p in range(max(0,x-1),min(15,x+2)):
for q in range(max(0,y-1),min(10,y+2)):
if m[p][q]!=999:m[p][q]+=100
Le script ci-dessus a deux fonctions, il place les 20 mines puis « calcule » pour chaque case le nombre de bombes dans les 8 cases autour.
Ainsi, la matrice contient à ce stade uniquement des entiers : soit des 0 (0 bombes dans les 8 cases environnantes), soit des multiples de 100, soit des 999.
Pourquoi 100 et pas 1 pour indiquer qu’il y a une bombe ?
Car on va utiliser cette matrice pour y stocker une information importante, à savoir si la case a été découverte ou pas.
m[i][j]
La case (i,j) contient
Dans les 8 cases autour de la case (i,j) il y a
case découverte
999
1 mine
on ne sait pas
non sinon (…)
342
0 mine
3 mines
oui
300
0 mine
3 mines
non
42
0 mine
0 mine
oui
1
0 mine
0 mine
en cours de découverte
0
0 mine
0 mine
non
Calcul du nombre de mines de chaque case
En parcourant l’article Wikipédia sur le démineur lors de la rédaction de ce compte rendu, j’y ai découvert que j’ai construit intuitivement l’un des deux algorithmes classiques pour le calcul des nombres des différentes cases du démineur.
Sur mon antique Casio 9960GT, j’utilisais l’algorithme par case :
explorer tableau par case si case est vide nombre := compter_mines(case.voisinage) case.valeur = nombre<
et sur la NumWorks, j’ai construit une version légèrement adapté de l’algorithme par mine :
// Placement de la mine explorer mine.voisinage par case si case est vide incrémenter case.valeur
Dans une première version en python, j’utilisais la partie décimale pour y stocker le 42 ou le 0.01, ainsi cela donnait 1,42 si il y a une mine dans le voisinage et que la case est déjà découverte, mais ceci posa un problème, le test :
if 1.42-round(1.42)==42
ne marchait pas, car python ne dispose pas d’un moteur de calcul exact sur les réels. Le résultat du calcul 1.42-1 en python est 0.419999999999999
Par ailleurs, stocker en réel et non un entier est susceptible de consommer plus de mémoire, donc le stockage de l’information sous la forme d’entier est préférable pour les tests conditionnels.
Une fonction pour les découvrir toutes !
A partir de la matrice, on peut exécuter un script qui révèle les positions et vérifie que tout fonctionne correctement :
def verif():
for x in range(15):
for y in range(10):
if m[x][y]==666:
mine(x,y)
elif m[x][y]>0:
chiffre(x,y)
La fonction chiffre elle a pour objectif d’afficher le nombre de bombes autour :
def chiffre(x,y):
cl(x,y)
nb[1]+=(m[x][y]%100!=42)
i=m[x][y]-m[x][y]%100
m[x][y]=i+42
if i>=100:v=int(i/100);draw_string(str(v),13+20*(x),23+20*(y),c[v],c[0])
deminage()
pas à pas de la fonction chiffre :
cl(x,y) éclairci la case
nb[1] s’incrémente de 1 si la case n’a pas déjà été découverte, c’est le compteur de la victoire
Si la valeur m[x][y] contenait Z00 elle sera désormais de Z42, Z étant un entier entre 0 et 8.
On affiche la valeur de Z, avec une couleur adaptée.
On exécute le script deminage(), qui calcule le score et vérifie si l’on a gagné.
Le plus difficile à coder est la fonction de découverte de proche en proche, si on dévoile une case ne contenant aucune mine, et pas de mine non plus dans les 8 cases alentours, il faut faire un « script récursif » de traitement et de découverte de ces cases.
La fonction decouvre() est la suivante :
def decouvre(x,y):
i=1
while i>0:
chiffre(x,y)
for p in range(max(0,x-1),min(15,x+2)):
for q in range(max(0,y-1),min(10,y+2)):
if m[p][q]>=100:chiffre(p,q)
elif m[p][q]==0:m[p][q]+=1
i=0
for p in range(15):
for q in range(10):
if m[p][q]%100==1:i=1;x=p;y=q;p=14;q=9
Elle est appelée par la fonction marche() :
def marche(x,y):
if m[x][y]>=999:explose()
elif m[x][y]>=100:chiffre(x,y)
else:decouvre(x,y)
Ainsi la fonction découverte n’est appelée que si on « marche » sur une case sans mine, et que les 8 cases aux alentours ne contiennent également aucune mine.
Elle teste les 8 cases du voisinage, affiche le chiffre de celles qui doivent afficher un chiffre. Si les cases contiennent un 0, il devient 1 et devra être traité par le script ultérieurement.
Ce fonctionnement n’est pas optimal en temps de calcul, mais il ne crée aucun nouvel objet en mémoire. Il n’est pas vraiment non plus récursif au sens python pour éviter là encore de consommer trop de mémoire.
Une précédente version ajoutait les coordonnées des cases à traiter dans une liste, mais cette liste grossissait et pouvait saturer la mémoire.
Piloter un drone sur un terrain miné
Il ne reste plus qu’à coder la navigation dans l’écran, c’est à dire l’interaction entre l’affichage et le clavier de la calculatrice.
a,r,t,l,k,s=set_pixel,fill_rect,draw_string,range,keydown,sleep
p=[[6,5],[7,5]]
def survol():
x, y = p[1][0], p[1][1]
v = m[x][y]
gps(x,y)
# t(str(int(v/100)),20,2)
x, y = p[0][0], p[0][1]
v = m[x][y]
if p[1][0]!=x or p[1][1]!=y:
if (v-42)%100==0:gps(x,y,0)
else:gps(x,y,9)
del p[0]
def gps(x,y,i=6):
r(9+20*x,22+20*y,19,2,c[i])
r(26+20*x,22+20*y,2,19,c[i])
r(9+20*x,22+20*y,2,19,c[i])
r(9+20*x,39+20*y,19,2,c[i])
def drone():
while not k(6):
if k(0):p.append([max(p[0][0]-1,0),p[0][1]])
if k(3):p.append([min(p[0][0]+1,14),p[0][1]])
if k(1):p.append([p[0][0],max(p[0][1]-1,0)])
if k(2):p.append([p[0][0],min(p[0][1]+1,9)])
if k(4):marche(p[0][0],p[0][1])
if k(17) or k(16):drapeau(p[0][0],p[0][1])
if k(52):nb[2]=0;nb[0]=22;minage(nb[0]);s(1)
if k(45):nb[0]=min(nb[0]+5,90);minage(nb[0]);s(1)
if k(46):nb[0]=max(nb[0]-5,10);minage(nb[0]);s(1)
if len(p)>1:survol();s(0.120)
La fonction survol() déplace le curseur, en rétablissant l’affichage de la case précédemment survolée à l’aide de la fonction gps().
la fonction drone() attend que l’utilisateur appuie sur une touche du clavier.
Touche
Code touche
Action
Flèche haut
1
se déplacer
Flèche bas
2
se déplacer
Flèche gauche
0
se déplacer
Flèche droite
3
se déplacer
OK
4
marcher sur la case
Clear ou Tolbox
17
Afficher un drapeau
Maison
6
quitter la boucle
+
45
ajouter 3 mines et recommencer la partie
–
46
enlever 3 mines et recommencer la partie
EXE
52
recommencer la partie avec les paramètres par défaut
Le nombre de mine par défaut est fixé à 19 pour un plateau de 150 cases, soit un ratio de 12.7%.
Le démineur de Microsoft sur Windows 10, appelé Minesweeper propose des ratios de 11,1%, 15%, et 20% respectivement pour les modes faciles, moyen et difficile.
Le nombre de mine qu’il est possible de placer est un nombre dans la liste : 13, 16, 19, 22, 25, …, 40 mais une petite astuce mathématiques permet de choisir n’importe quel entier entre 11 et 42 pour désigner le nombre de mine.
Oui n’importe quel nombre entier entre 11 et 42 alors que l’interface et l’utilisation des touches [+] et [-] ne permet que d’ajouter ou d’enlever 3 mines…
Epsilon version 13.2
La sortie de la version 13.2.0 d’Espilon, le logiciel qui anime la NumWorks permet de faire tourner sans problème ce démineur. Si dans la version 13.0.0 et 13.1.0 le démineur ne fonctionnait pas à cause d’une affectation insuffisante de mémoire pour l’exécution des scripts python, la version 13.2.0 résout ce problème qui n’est plus qu’un mauvais souvenir. Ainsi, la NumWorks est l’une des calculatrice la plus rapide lors de l’exécution des scripts Python, et que pour un prix d’achat de 79€ elle n’a clairement aucune concurrence dans cette gamme de prix.
Omega, un firmware alternatif pour votre NumWorks
Le logiciel de la NumWorks est libre et ouvert, ce qui est très appréciable et on peut même dire admirable dans l’univers très fermé des calculatrices.
Ainsi, tout le monde peut accéder au code source, le lire, le modifier et le redistribuer en respectant les conditions imposées par la licence CC BY-NC-SA.
Une équipe de passionné a donc décidé de développer un firmware alternatif, et il l’ont appelé Omega. Ils intègrent différentes amélioration, et poussent les developpeur du firmware stock à s’améliorer sans cesse.
Pour tester ce démineur, tu dois :
Soit mettre à jour ta calculatrice en version 13.2.0 au minimum.
Une nouvelle version de ce démineur est sortie le 18 avril 2020, elle intègre un menu graphique python développé en interne pour cette occasion.
Le script du démineur pèse désormais 8.42ko, et le démineur peut désormais être paramétré par un menu graphique, interactif et intuitif.
De nouvelles options ont été ajoutées :
Le choix du graphisme : Flat vs Classique
Un mode triche à tester avec la touche MAJ de l’ordinateur ou Shift sur la calculatrice.
Quelques dernières remarques
Si tu souhaites réagir à cet article, tu es invité à le faire sur ce forum : [tiplanet.org] Un démineur en python pour la NumWorks, tu y trouvera des discussions pointues sur l’utilisation de la mémoire lors de l’éxécution d’un script Python.
Entre le script initial et le script proposé en ligne à cet instant, de nombreuses réécritures portions du code ont été réécrites, mais les explications de cet article restent valables.
Enseignant de mathématiques et de spécialité NSI, Lycée Louis Pasteur d’Avignon.
Aime compter jusqu’à 666 mais s’arrête souvent à 42.
Auteur du livre Découvrir la calculatrice NumWorks.
Si les exercices répétitifs d’entrainement étaient tombés en disgrâce dans les précédents programmes scolaires, les nouveaux programmes de mathématiques les réintroduit, tout du moins en ce qui concerne les rituels de calcul mental en classe de seconde.
L’acquisition de ces réflexes est favorisée par la mise en place d’activités rituelles, notamment de calcul (mental ou réfléchi, numérique ou littéral). Elle est menée conjointement avec la résolution de problèmes motivants et substantiels, afin de stabiliser connaissances, méthodes et stratégies.
Extrait du programme de mathématiques, classe de seconde, 2019
Le script que nous avons conçu permet de pratiquer du calcul mental numérique, directement sur sa calculatrice, sans que les élèves n’aient la possibilité de tricher sur leur voisin et tout en proposant une correction personnalisée à chaque élève !
Un précédent script réalisé en mode texte
Un précédent script avait été codé en mode console, et il gérait un menu, lui aussi codé avec des print() et des input().
Fonctionnel, il manquait toutefois d’ergonomie, et le décalage du texte en temps réel dans le console pouvait perturber l’apprentissage.
Réécriture pour profiter de la couche graphique
Avec la sortie de la version 13.2.0 d’Espilon, le logiciel qui anime la NumWorks permet de disposer d’un tas python (heap) de 31ko et de fonctions natives tel que keydown() qui permet de récupérer le code de la touche pressée.
Une conception graphique minimaliste et intuitive a donc été pensée et codée pour sublimer ce générateur aléatoire de calculs.
Le mode classique interrompt le script et le chronomètre pour afficher si il y a une erreur, et indiquer quelle était la bonne réponse.
Le mode rapide est un mode d’entrainement intensif sans perturbation, que vous fassiez juste ou faux les calculs s’enchaînent et vous ne pourrez pas analyser vos erreurs.
Dans tous les cas, une fois la série de calcul terminée, un écran de synthèse résume le travail réalisé.
Pour pouvoir être lu par notre script, la difficulté doit être représentée par un nombre. Ainsi, on crée un code qui récupère un nombre en fonction de l’index de la première lettre dans un tableau.
kandinsky ne dispose pas d’une fonction permettant de tracer des lignes. Or elle dispose d’une fonction qui allume un pixel d’une certaine couleur. Voici donc notre fonction pour tracer une ligne.
def draw_line(x, y, clr, *ts):
for t in ts:
d = list(map(lambda n: n // abs(n) if n != 0 else 0, t[0]))
for i in range(t[1]):
set_pixel(x + i * d[0], y + i * d[1], clr)
x += i * d[0]
y += i * d[1]
Quelques explications : La fonction prend un couple (x,y) de départ, un couleur et des trajectoires (ts)
Ces trajectoires sont de la forme ([dx,dy],l)
d = list(map(lambda n: n // abs(n) if n != 0 else 0, t[0]))
Cette ligne permet d’obtenir une liste contenant uniquement des -1, 0, 1.
Améliorations possibles
Un mode d’apprentissage automatique si on dispose d’une mémoire de stockage permanente utilisable par python.
Un mode examen (Nécessite de « crypter » qq portions du code) : Le professeur génère un code unique, l’élève saisit ce code et fait une série aléatoire mais paramétré par le professeur. Un bon élève doué en programmation pourra toutefois bypasser le code et avoir tout juste sans rien faire !
Télécharger cette application
En l’état actuel, vous ne pouvez pas tester ce script directement depuis le workshop, car l’équipe de développement de la NumWorks n’a pas encore mappé les touches du clavier de l’ordinateur sur leur simulateur en ligne.
Quelques touches seulement sont actives sur le workshop, les 4 flèches, la touche Entrée et les touches Retour Arrière, Majuscule.
Ceci vous permet donc uniquement de tester le menu de cette application mais pour tester le générateur de calcul, il faudra charger le script sur la calculatrice.
Enseignant de mathématiques et de spécialité NSI, Lycée Louis Pasteur d’Avignon.
Aime compter jusqu’à 666 mais s’arrête souvent à 42.
Auteur du livre Découvrir la calculatrice NumWorks.
Projets
