Étiquette : NumWorks

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. 

Auteurs :

Ce jeu a été créé par L. Girard, C. Soulage et C. Coquel.

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

Projets

Une bataille navale codée en python sur NumWorks

Jouez contre une composition aléatoire au grand classique du jeu de société : la bataille navale ! Devinez ou sont cachés les bateaux en un minimum de temps.

Introduction

Projet réalisé par A. Juge, P. Moucadeau et B. Kerneïs de la classe de première en spécialité NSI. Nous sommes également les auteurs de ce compte rendu. Pour en savoir plus : Les projets en spécialité NSI

Lien court vers ce document : https://nsi.xyz/battleship

Jouez à l’incontournable jeu de la bataille navale directement sur votre calculatrice NumWorks ou sur un émulateur compatible avec le module kandinsky (Omega – IDE) !

La bataille navale ou touché-coulé est un jeu de société commercialisé en 1831 qui se joue à deux joueurs. Le principe du jeu, si vous ne le connaissez pas, est de placer des « navires » sur une grille tenue secrète et de tenter de couler les navires adverses. La partie s’arrête lorsque l’un des deux joueur a réussi à couler tous les navires de l’autre joueur.

Dans le cadre de notre projet, le jeu codé en python a été simplifié : le joueur essaie de deviner la composition de l’ordinateur qui a été générée aléatoirement et ainsi, le jeu ne se joue que dans un seul sens. C’est à dire que le joueur ne peut que gagner ! Incroyable non ?

Vous pouvez jouer contre avec vos amis et tenter de gagner en le moins de coup possible !

Évolution

Le processus de création s’est divisé en différentes parties.

La première grille
Avec le module kandinsky, nous avons commencé par reprendre et améliorer le code de Schraf : Maths-info qui nous a permit de construire une grille de 10*10

def grille():
    '''
   Tracé de la grille
   '''
    for i in range(11):
        if i<11:fr(50,10+20*i,200,1,N)
        fr(50+20*i,10,1,200,N)

Interaction homme/machine
Ensuite, nous avons crée un « curseur » qui peut se déplacer dans cette grille en récupérant les touches pressées par le joueur grâce au module ion.

Cette portion de code sert à attendre que l’utilisateur appuie sur une touche et la récupérer.

def wait(b):
    while Partie:
        for i in b:
            if keydown(i):
                while keydown(i):True
                return i

code inspiré de Arthur Jacquin

La classe bateau
La création d’une classe bateau nous a permit de simplifier le code, notamment pour ce qui est de détecter si un bateau est touché et/ou couléuniquement avec les coordonnées du début et de la fin

bateaux1,y1x2,y2état
11,21,4touché
26,49,4safe
38,28,5coulé

Les méthodes is_touche et is_coule sont la pour repérer si un bateau est touché ou coulé lorsque le joueur décide de tirer sur une case. Elles utilisent la liste des cases composant le bateau.

def is_touch(self,x,y):
        ''''Méthode revoyant Vrai si le bateau est touché 
       et Faux si il ne l'est pas
       '''
        l = [x,y]
        for i,elt in enumerate(self.LC):
            if elt == l:
                self.etat = 1
                self.L_etats[i] = 1
                return True
      
        return False
    
    def is_coule(self):
        '''Méthode revoyant Vrai si le bateau est coulé 
       et Faux si il ne l'est pas
       '''
        if self.etat == 2:
            return True
 
        for i in self.L_etats:
            if i != 1:
                return False
 
        for j in self.LC:
            ca(j[0],j[1],N)
 
        self.L_etats = []
        for i in range(len(self.LC)):
            self.L_etats.append(2)
 
        self.etat=2
        print(self, "est coulé")
        return True

Le cerveau du programme
La fonction Main représente la boucle principale, c’est elle qui récupère les boutons pressés par les joueurs pour appeler les autres fonctions. La boucle s’arrête lorsque tous les bateaux sont dans l’état coulé.
Puisque c’est une boucle qui tourne à toutes les actions du joueur, c’est l’endroit idéal pour mettre à jour les infos du joueur, comme le nombre de coups.

def Main(n):
    '''Boucle principale'''
    global X,Y,Partie,NBcoups,NBtouches,LB
    LB = compo(n)
    grille()
    ca(X,Y,G)
    print(Partie)
    while Partie:
        t = wait([0,1,2,3,4,])
        if t == 3 and X+1<10:
            majcase(X,Y,X+1,Y)
            X+=1
        elif t == 0 and X>0:
            majcase(X,Y,X-1,Y)
            X-=1
        elif t == 1 and Y>0:
            majcase(X,Y,X,Y-1)
            Y-=1
        elif t == 2 and Y+1<10:
            majcase(X,Y,X,Y+1)
            Y+=1
        elif t == 4:
            touche(X,Y)
        ds("Coups",255,10,Bl)
        ds(str(NBcoups),255,30)
        ds("Touches",251,50,R)
        ds(str(NBtouches),255,70)

Le tirage aléatoire de la composition
Il a fallu ensuite générer aléatoirement la composition des bateaux de l’adversaire. Le module random nous a été très utile. La difficulté principale a été de faire que les bateaux ne dépassent pas de la grille. Nous avons donc décalés les bateaux étant dans cette situation en modifiant les coordonnées x1, y1 de ce dernier.

def compo(n):
    '''Générateur de composition aléatoire'''
    L= []
 
    for i in range(n):
        ori = randint(0,1)
        sens = randrange(-1,2,2)
        longueur = randint(2,4)
        x1 = randint(0,10)
        y1 = randint(0,10)
 
        if ori == 0:
            x2 = x1
            y2 = y1+(longueur*sens)
            c1 = y1
            c2 = y2
        else :
            x2 = x1+(longueur*sens)
            y2 = y1
            c1 = x1
            c2 = x2
        
        if c2 > 9:
            c1 = c1 - (c2-9)
            c2 = c1+(longueur*sens)
        elif c2 < 0:
            c1 = c1 - c2
            c2 = c1+(longueur*sens)
        
        if ori == 0:
            L.append(bateau(x1,c1,x2,c2))
        else :
            L.append(bateau(c1,y1,c2,y2))
    
    return L

Interface graphique
Puisque les conditions de jeu ne changent pas (mode de jeu, nombre de bateaux…), la présence d’un menu augmente inutilement la taille du fichier. Nous avons alors opté pour insérer une image d’accueil qui s’efface au bout de 2 secondes. Le jeu se lance lorsque les 2 secondes sont écoulées.

def play():
    fill_rect(0,0,320,222,(255,255,255))
    texte_center("Battleship", 160, 20, col_os())
    texte_center("nsi.xyz/battleship ", 160, 50, N)
    texte_center("par", 160, 80, (101,101,101))
    texte_center("Alexandre Juge", 160, 100, (42,42,42))
    texte_center("Pierre Moucadeau", 160, 120, (42,42,42))    
    texte_center("Baptiste Kerneis ", 160, 140, (42,42,42))
    sleep(2)
    fill_rect(0,0,320,222,(255,255,255))
    Main(5)
Résultat des crédits

Par la suite nous avons rajouté 2 compteurs, un comptant le nombre de coup et l’autre le nombre de bateau touché.

Lorsque le nombre de bateau touché est égale au nombre de bateau il lance un menu de fin.

def end():
    global NBcoups
    fill_rect(0,0,320,222,B)
    texte_center("Battleship", 160, 20, col_os())
    texte_center("Vous avez fait un score de :", 160, 50, N)
    texte_center(str(NBcoups), 160, 80, col_os())
    texte_center("Vous pouvez faire mieux !", 160, 100, (42,42,42))

Mention spéciale

Mention spéciale à la toute petite fonction ca qui malgré ses 2 lignes est la fonction la plus utile puisque elle permet de remplir un case. Et oui, tout simplement

Ce n’est pas la taille qui compte , « Un grand sage »

def ca(x,y,c=G):
    ''' Remplis la case x,y avec la couleur c '''
    fr(51+20*x,11+20*y,19,19,c)

Problèmes rencontrés

A la fin du processus de création nous nous sommes heurtés à de nombreux problèmes le premier étant la taille du fichier, supérieur à 8ko donc inutilisable sur la calculatrice, ont a alors dut supprimer le mode multijoueur car prenant trop de place.

Deuxièmement les bateaux généré étaient magnifique mais complètement en dehors de la grille.

Certains bateaux étaient générés en dehors de la grille

Pour régler ce problème nous avons rajouter une condition à la formation des bateaux qui fait ,que lorsqu’ils se trouvent en dehors de l’intervalle de la grille ,ils sont décalés à l’intérieur de la grille .

Anecdote

Pour l’anecdote, il faut savoir que nous voulions originellement créer un jeu uno ! Mais suite à de nombreuses difficultés, notamment la gestion de la pioche pour deux joueurs, nous nous sommes réorientés vers la bataille navale et rabattu sur une parti en solo.

Conclusion 

Pour pouvoir jouer à cette version du jeu bataille navale, téléchargez le code par l’intermédiaire du lien ci-dessous. Les commandes sont assez intuitives : les flèches pour se déplacer, et le bouton OK pour interagir.
Amusez-vous bien !

Crédits / Remerciements 

Tout d’abord un grand merci aux fragments de codes de Arthur Jacquin, notamment son menu (réalisé avec @cent20). 
Ainsi que M.Schraf pour ses tutos très utiles sur la couche graphique de Python

Téléchargement

Projets

Un donjon textuel en Python sur la NumWorks

Mini jeux sous forme de jeux de rôle. Nommé dungeon, ce jeu consiste à remplir des mini quêtes en interagissant avec des personnage fictif.

L’histoire du jeu textuel

En 1972, William Crowther programme la première fiction interactive, nommée Adventure. Nécessitant 300 Ko de stockage, il était programmé sur un PDP 10, un ordinateur créé à la fin des années 1960 .
Cependant ce style de jeu a aussi existé sous forme de livres, les livres dont vous êtes le héros. Ce sont donc ces livres, qui ont bercé notre enfance, qui nous ont donné l’idée de ce jeu, Dungeon !

De l’idée à la conception

Après un long débat, nous étions parvenus à la conclusion que notre jeu proposerait toujours 2 choix, et qu’il n’existerait qu’une seule fin valable. Mais l’imagination débordante de notre professeur nous a permis de revoir l’idée de notre jeu. Ainsi nous vous proposons de naviguer dans un donjon, en interagissant avec différents personnages fantastiques.
Nous avons choisi différents personnages, ainsi que leurs interactions. Pour les plus cruels des joueurs, nous offrons la possibilité de tuer certains personnages, à leurs risques et périls. Tout au long de cette aventure, il sera possible de récolter des objets différents permettant de sortir du donjon.

Le début du codage

Il nous a fallu définir une variable pour chaque personnage ou objet contenant l’état de ce personnage ou objet :

  • True : le personnage est en vie ou l’objet est en votre possession
  • False : le personnage est mort ou vous ne possédez pas l’objet.

Ceci fait, on a cherché le moyen de coder chaque interaction. Ainsi, on demande au joueur de choisir entre plusieurs possibilités, et la réponse entrée est testée pour effectuer l’action correspondante. Le code pris cette forme (\n indiquant un saut de ligne) :

x=int(input("Que voulez vous faire entre :\n1 : manger un steak \n2 : ne pas manger de steak ?\n\nChoix : ")
if x==1 :
    print("vous mangez un steak")
elif x==2 :
    print("Vous ne mangez pas de steak")

Coder jusqu’à la fin !

Il nous a fallu coder chacune des pièces dans lesquelles le joueur peut se rendre dans une fonction def, permettant de tester et débuguer plus facilement nos lignes de code. Nous avons gardé cette écriture pour plus de lisibilité.
Une fois les salles et les interactions avec les personnages codées, un long travail de saut de ligne (\n) s’est mis en place pour rendre lisible le jeu. De cette manière, nous avons essayé d’optimiser la lecture à l’écran.

def room1():
    print("Vous entrez dans la salle du\nFourneau.\nParler : ")
    if etat[2]==True :
        print("\n1 : au", objet[2])
    if etat[6]==True :
        print("2 : a l'", objet[6])
    f=int(input("\n\n\n\n\nChoix : "))
    if f==1 and etat[2]==True :
        fo=int(input("Bonjour, je peux vous forger\nce que vous voulez, mais\navec des materiaux.\n\n1 : Avez-vous ... ?\n2 : Tuer le forgeron\n3 : Donner un objet\n\n\n\n\nChoix : "))
        if fo==1 :
            print("Oh vous etes le livreur,\ntenez, c'est la pioche du\nmineur. Allez lui donner,\nil a deja tout paye.\n\n\n")
            etat[10]=True
        elif fo==2 :
            print("Argh je me meurs !\n\n\n\n\n")
            etat[2]=False
            etat[19]=etat[19]+1
        elif fo==3 :
            if etat[9]==True :
                print("Un instant, je vous forge\nune epee avec ceci !\n\n\n\n")
                etat[11]=True
            else :
                print("Je ne peux rien faire\npour vous, desole\n\n\n\n\n")
    elif f==2 and etat[6]==True :
        al=int(input("Bienvenue, je suis\nl'alchimiste Gandalf,\nspecialiste de\nl'immortalite.\n\n1 : Gandalf ?\n2 : Tuer Gandalf\n3 : Prendre une potion\n\n\n\nChoix : "))
        if al==1 :
            print("Je suis Gandalf, un\nimmortel de 70 ans.\n\n\n\n")
        elif al==2 :
            print("Ainsi je meurs.\n\n\n\n\n")
            etat[6]=False
            etat[19]=etat[19]+1
        elif al==3 :
            print("Je vous echange ma potion\ncontre un STEAK.")
            if etat[12]==True :
                print("Tenez. Bonne journee.\n\n\n\n")
                etat[15]=True
            else :
                print("PAS TOUCHE A MES POTIONS!\n\n\n\n") 

Les difficultés encontrées…

Notre idée première était d’établir chacune des variables désignant un personnage ou un objet en début de code, sous la forme suivante (avec comme exemple un nain et sa hache) :

nain=True
hache=False

Seulement, ce style de définition de variables est « local », il ne peut être utilisé que dans le code en lui-même et non pas dans les fonctions defdes salles, dans lesquelles nous utilisions ces variables. Notre professeur, M. Robert, nous a expliqué que certaines définitions de variables étaient donc « globales », comme les tableaux. Ainsi nous avons codé toutes nos variables dans deux tableaux, l’un contenant le nom de la variable et l’autre la valeur de la variable. Nous obtenions donc ceci :

nom=["nain", "hache"]
etat=[True, False]

Par la suite, il nous a fallu remplacer chaque variable par le nom du tableau et le nombre correspondant au tableau. Selon les exemples précédents, « nain » devait être changé en « nom[0] » ou « etat[0] ». Nos vingt-et-une variable échangées dans le code pour le nom des tableurs, il nous fut plus complexe de coder mais cela était encore faisable.
Enfin, il nous a fallu définir la manière dont le programme afficherait chaque interactions. Nous disposions de 11 lignes sur l’écran, et pour que le jeu soit le plus clair possible il fallait que chaque interface occupe 11 lignes ( de temps en temps 10 ou 9 si vous vous comportez mal dans notre jeu, c’est le karma). nous avons donc opté pour une version lisible et ordonnée.

A vous de jouer !

Notre jeu étant composé de nombreuses interactions avec des personnages, et ne voulant pas spoiler notre jeu, nous ne voulons pas vous montrer trop d’images de ce jeu.
Mais vous pouvez télécharger Dungeon sur votre calculatrice via le bouton rouge ci-dessous ou en cliquant ici.

Télécharger et tester

Serveur Workshop de NumWorks tiplanet.org nsi.xyz 
RemarquesPermet un téléchargement rapide sur la calculatriceTéléchargement .pyTéléchargement .zip
Liens hypertexteslienNumWorks > Jeux > Lien

Tutoriels

Découverte de la programmation en Python sur la NumWorks

A partir de la rentrée 2019, le langage imposé pour les algorithmes en lycée est le Python. Les programmes des diverses matières scientifiques incluent des algorithme à étudier avec les élèves, il y en a bien évidemment dans le programme de spécialité NSI mais aussi dans le programme de mathématiques ou celui de physique.

Les calculatrices et leurs langages de programmation non standard

Jusqu’à présent le marché des calculatrices graphique était partagé entre deux marques commerciales : Casio et Texas Instrument. Chacune de ces marques a utilisé pendant près de 30 ans des langages de programmation semi propriétaire, dérivé du Basic mais pas compatibles entre eux, ce qui a durablement ralenti l’enseignement de l’algorithmique en lycée.

A partir de la rentrée 2019, le langage imposé pour les algorithmes en lycée est le Python.

Un langage de programmation simple d’usage est nécessaire pour l’écriture des programmes informatiques. Le langage choisi est Python, langage interprété, concis, largement répandu et pouvant fonctionner dans une diversité d’environnements. Les élèves sont entraînés à passer du langage naturel à Python et inversement.

Programme de mathématiques de seconde générale et technologique, 2019

Les calculatrices vont donc devoir se mettre à jour ou plus précisément les vieilles calculatrices utilisées par les aînés ne seront plus utilisables…

Les calculatrices compatibles Python

Cet article a pour objectif de vous présenter la programmation en Python sur la calculatrice Numworks.

Premier pas avec Python sur la NumWorks

Le site officiel de NumWorks propose un petit tutoriel, plutôt très bien fait intitulé Premiers pas avec Python.

Il propose surtout gratuitement 3 émulateurs, un émulateur sur le web vidéo-projetable en classe devant les élèves, une application android et une application IOS ce qui est remarquable, appréciable et devrait-être le cas de tous ces concurrents…

On peut même télécharger sur son ordinateur personnel cet émulateur !
Et comme tout ces logiciels sont sous licence CC-BY-NC-SA, vous pouvez les télécharger, les modifier, les redistribuer.

On peut toutefois regretter que l’algorithme proposé pour faire ces premiers pas en Python avec NumWorks soit une fonction Python récursive, cela n’est ni intuitif, ni adapté à un un public débutant.

Le code du script python proposé (la fonction récursive) est ci-dessous, vous pouvez copier / coller et tester ce script dans un autre environnement de développement Python. Ce programme très simple calcule la factorielle d’un nombre entier naturel.

from math import *
def factorial(n):
    if n==0:
        return 1
    else:
        return n*factorial(n-1)

Sur la calculatrice cela donne ceci en mode édition :

Et en exécution en mode console :

Aléas de la programmation fonctionnelle

Le paradigme programmation fonctionnelle a été créé explicitement afin de prendre en charge une approche fonctionnelle pure de la résolution des problèmes. Mais ce qui est déstabilisant avec la programmation fonctionnelle, c’est que quand on exécute un algorithme, il ne se passe rien à priori à l’écran.

Une fois le script précédent saisi dans la calculatrice,

Il faut l’exécuter

et on obtient ceci :

On arrive donc dans la console d’exécution de Python, mais le script ne semble avoir produit aucun effet, du moins on ne voit rien à l’écran.

L’utilisateur doit donc saisir  factorial(10) pour calculer 10 ! c’est à dire 10 x 9 x 8 x 7 x 6 x 5 x 4 x 3 x 2 x 1.

Il est alors tentant de réécrire le srcipt ainsi :

def factorial(n):
    if n==0:
        return 1
    else:
        return n*factorial(n-1)
 
print("Calcule la factorielle d un entier n")
m = int(input("n="))
print(factorial(m))

Mais cette pratique est a éviter avec les élèves, l’abus de print() et de input() peut perturber l’apprentissage de la programmation fonctionnelle.

Formation python sur la NumWorks en vidéo

La société NumWorks réalise régulièrement des vidéos très simple présentant la programmation python sur sa calculatrice. Voici la vidéo de la formation du 25 mars 2020.

Tutoriels

Programmer en Python et porter son code sur la…

Ce tutoriel s’adresse à toute personne qui souhaite développer en python, et adapter ce code aux contraintes de la calculatrice NumWorks.

En octobre 2020, dans le cadre des projets de 1ère spécialité NSI, nos élèves doivent réaliser le projet suivant :

Proposer un utilitaire en python, il doit fonctionner sur la NumWorks.Retour ligne automatique
Aucune idée ? Regardez les utilitaires existants sur TI 83Retour ligne automatique
Les plus ambitieux peuvent tenter de faire un jeu.

Exploiter uniquement la console python

Si vous comptez coder un projet en python, et que vous ne prévoyez de n’exploiter que la console python pour y exécuter des scripts, appeler des fonctions, afficher du texte, vous pouvez utiliser n’importe quel IDE pour développer votre projet :

  • Thonny, Python IDE for beginners (win, mac, linux)
  • Spyder, complet et donc un peu lourd
  • PyCharm, Community Edition

Si vous choisissez un nouvel IDE, consulter un tutoriel peut vous permettre de bien démarrer et de gagner du temps ultérieurement.

Bien évidemment, il faut tenir compte de l’écran qui ne peut afficher simultanément 
que 29 caractères en largeur sur 11 lignes. test_affichage.py

Mais en exploitant au mieux ces valeurs, on peut néanmoins se débrouiller pour placer ce que l’on veut à l’écran, comme dans cet exemple polynome.py :

Coder en exploitant la couche graphique de la calculatrice

Si vous décidez d’exploiter la couche graphique de la calculatrice, vous pourrez donner libre cours à votre créativité, mais à ce jour malheureusement vous ne pourrez pas développer votre script sur l’IDE de votre choix.

L’interface de développement officielle de la calculatrice NumWorks 

Vous pouvez utiliser le workshop officiel de la NumWorks, qui est resté figé en 2018 et qui ne propose clairement pas, en octobre 2020, une interface efficace pour développer un vrai projet.

Une interface de développement alternative pour la calculatrice NumWorks 

Vous pouvez aussi utiliser l’IDE de Omega, l’OS alternatif de la NumWorks.
Il présente plusieurs avantages, comme une coloration syntaxique plus agréable, une complétion automatique des scripts, une sauvegarde en ligne sur github…

1. Se créer un compte Github
2. Se connecter sur l’IDE python Omega avec ses identifiants python
3. Se familiariser avec l’interface. Signaler les bugs sur le serveur discordde l’équipe de développement de cet OS alternatif.

C’est d’ailleurs cette dernière interface que nous utiliserons en spé NSI pour porter nos projets sur la NumWorks. Comme elle est en version alpha, elle risque d’avoir quelques bugs, cela pourrait être assez drôle …

Avis aux lecteurs : enseignant, ou développeur indépendant : 
Si vous vous sentez de porter les bibliothèques propriétaires de la NumWorks (le module kandinsky, le module ion) sur PC, cela serait avec grand plaisir que nous les diffuserions et en ferions la promotion.

L’idée serait qu’un script écrit pour la NumWorks puissent fonctionner sur PC, à l’identique.

Quelques exemples de script exploitant la couche graphique de la calculatrice NumWorks :

Une roue Chromatique : chromac.py (ne marche pas sur le workshop, fonctionne sur la calculatrice et sur Omega IDE)

Roue chromatique

Un petit jeu inspiré de Bombrun sur Casio : planeur_bombe.py

Capture d’écran de Bombrun

Un tetris, pour passer le temps en cours de maths : tetris.py

Capture d’écran de Tetris

Si les codes de ces scripts ne sont pas faciles à comprendre, des ressources proposées à la fin de cet article peuvent t’éclairer utilement.

Quelques tests graphiques très simples

test_draw.py pour comprendre comment afficher du texte, un peu n’importe où sur l’écran.

cercle.py, pour tracer un cercle, image obtenue avec un appel de la fonction cercle(120,120,42)

Les capacités de la calculatrice

Qui a volé la mémoire de la calculatrice ? 

Avant d’attaquer le cœur du sujet à savoir le développement du projet python sur la calculatrice, il convient de lister les forces et faiblesses de cette calculatrice.

Si son ergonomie est admirable, son écran IPS lumineux et bien contrasté, son design moderne et convivial, l’application python est fort limitée.

32 Ko, c’est la taille totale et maximale de la somme des poids des scripts que vous pourrez stocker sur cette calculatrice. Il est impossible d’exploiter, pleinement la puce de 8 Mo soudée sur sa carte mère, la mémoire de stockage est gérée de manière non optimale. Espérons que cela changera.

32 ko, c’est la taille du tas python disponible pour exécuter les scripts. Si la calculatrice est dotée d’un CPU parfaitement dimensionné en terme de puissance, malheureusement seulement 32 Ko des 256 Ko de RAM de la puce ARM seront exploitables par votre script python. Là encore, le problème est lié à la jeunesse de cette calculatrice, et à la gestion de sa mémoire.

Pour que cela change plus vite, tu peux toi aussi contacter la société NumWorks.

Conséquences immédiates : 

  • Il va falloir coder intelligemment, et si votre script dépasse les 8 Ko il y a de fortes chances qu’il refuse de s’exécuter.
  • Il ne va pas falloir oublier que tout objet créé par le programme va occuper bien plus de place en mémoire que la sommes des poids en octets de ses caractères ACSII…

Des ressources et des exemples à exploiter

La documentation officielle de la calculatrice

Les tutoriels vidéos de Eric SCHRAFSTETTER

Plus de 63 tutoriels vidéos sur la NumWorks et l’utilisation des couches graphiques. Très didactiques, ces vidéos peuvent mettre vous aider dans la compréhension du langage python et des bonnes pratiques.

Quelques vidéos incontournables 

  • Exercice « Machine à sous »
  • Jeu pour apprendre les drapeaux
  • Plateau et pièces d’un jeu d’échecs
  • Le jeu Mastermind en Python
  • Programmons le jeu Snake en Python sur la Numworks !
  • Programmons le jeu 2048 en Python sur la Numworks !
  • Jeu du Pendu sur Numworks et Ti 83 Edition Python
  • Transformez votre Numworks en panneau LED défilant
  • Jeu de réflexion « Carré magique » pour la NUMWORKS
  • Programmons un jeu Démineur en Python sur la Numworks !

Les bibliothèques de scripts python

Voici quelques bibliothèques de scripts python optimisés pour la NumWorks.
La plupart des scripts fonctionneront sur le Workshop de NumWorks, pour certains scripts il faudra les tester sur la calculatrice.

La page d’accueil référençant certains scripts : https://workshop.numworks.com/python

Quelques dossiers à parcourir :

Nom du dossier Lien Auteurs 
numworkshttps://workshop.numworks.com/python/numworksDépôt officiel
schrafhttps://workshop.numworks.com/python/schrafEric Schrafstetter, enseignant & youtubeur
andreanxhttps://workshop.numworks.com/python/andreanxXavier Andréani, , enseignant & tiplanet.org
florian-allardhttps://workshop.numworks.com/python/florian-allardFlorian Allard, enseignant
ph-moutouhttps://workshop.numworks.com/python/ph-moutouPhilippe Moutou, enseignant, site web
telpe51https://workshop.numworks.com/python/telpe51 ?, Outils graphiques
nicolas-patroishttps://workshop.numworks.com/python/telpe51Enseignant, site web

Vous pouvez aussi retrouver quelques scripts publiés conçu pour NumWorks et parfois publié sur nsi.xyz sur les espaces workshop de Vincent ROBERTKévin Fedyna et Arthur Jacquin.

Le site https://tiplanet.org/, qui contient plus grosse bibliothèques de scripts toutes calculatrices confondues, il y a une section dédié à la NumWorks et des idées ou concepts dont on peut s’inspirer dans les dossiers TI 83 PCE ou TI 82+/83+/4

Si vous ne trouverez pas beaucoup de script pour la NumWorks sur le site https://tiplanet.org/, vous y trouverez par contre une source d’inspiration sur ce qui a déjà été fait, et ce qu’il est possible de faire…

Tester, tester, tester

Il convient lors du développement d’un projet de le tester régulièrement sur l’appareil sur lequel il doit finalement tourner.

Pour cela il faudra transférer le script sur la calculatrice.

Ce tutoriel vous guidera pour faire ceci depuis le workshop. Il est également possible de le faire depuis l’IDE Omega. Dans les deux cas, il faudra le faire depuis le navigateur Google Chrome.

Quelques petits scripts bien utiles

Lorsqu’une flèche est pressée, déclencher une action

from ion import keydown
 
def move():
    while not keydown(5):
        if keydown(0):
            pass #appeler ici une fonction
        elif keydown(3):
            pass #appeler ici une fonction
        elif  keydown(1):
            pass #appeler ici une fonction
        elif keydown(2):
            pass #appeler ici une fonction
        sleep(0.120)

Une coloration qui respecte l’OS

Ce code vérifie si votre calculatrice NumWorks utilise Epsilon, l’OS officiel de la NumWorks ou Omega, l’OS amélioré.

try:
    get_keys()
    os = (192,53,53)
except:
    os = (255,183,52)

La variable os contiendra désormais la couleur par défaut l’OS.
Ceci permet de colorer l’interface de l’application python en respectant le code couleur de la calculatrice. Nous utilisons cet astuce sur le Tetris.

Un menu simple à adapter

# Script Menu simple sans appel à une fonction
 
choix = 0 # Il est toujours utile d'initialiser une variable
 
# Le menu à afficher
print("Vous aimez la spé NSI ?")
print("1. Non (deconseille)")
print("2. Oui")
print("9. Quitter le programme")
 
# Le choix a faire
while choix > 2 or choix < 1 or choix != 9:
    choix = int(input("\n=>"))
 
# Le test conditionnel pour le menu
if choix == 0:
    print("Mauvaise reponse")
elif choix == 1:
    print("Bonne reponse")
else:
    print("Au revoir")


Un menu qui appelle des fonctions python

#version 2020
def fonction1(): # def définie une fonction.
    print("="*20)
    print("Vous avez fait le choix 1, excellent choix")
    print("="*20)
    return True
 
def fonction2(): 
    print("="*20)
    print("Vous avez fait le choix 2, vous allez rater votre vie")
    print("="*20)
    return True
 
def menu():
    choix = 0
    while choix!=9:
        print("Vous aimez la spé NSI ?")
        print("1. Oui")
        print("2. Non")  # ** Si vous ajoutez un choix au menu 
        print("9. Quitter le programme")    
        choix=int(input())
        if choix==1:
            fonction1()
        elif choix==2: # ** Vous devrez ajouter un elif comparable à celui-ci
            fonction2()
        elif choix==9:
            print("="*20)
            print("Au revoir !")

Projets

Cubito’s Adventures, un jeu en Python pour la NumWorks

Le jeu est très simple, il faut ramasser le plus de pièces possible, et pour se déplacer, il suffit d’appuyer sur les flèches de la calculatrice. Mais attention ! Si il n’y a pas de pièce en dessous de Cubito (le personnage que vous incarnez), vous tombez ! Il est impossible de remonter si on en oublie une. Heureusement, il y a des échelles pour vous aider !
Bon courage et amusez vous bien !!

Ce projet a été réalisé par des élèves en spécialité NSI du Lycée Louis Pasteur. Ils sont également les auteurs de ce compte rendu. Pour en savoir plus : Les projets en spécialité NSI

Lien court vers ce document : https://nsi.xyz/cubito

On a tous espéré un jour pouvoir jouer sur sa calculatrice !
C’est pourquoi nous vous présentons le jeu « Cubito’s Adventures » !

Recherche d’idées et présentation du projet

Lorsque nos profs nous ont dit qu’il fallait faire un programme en Python qui tourne sur la NumWorks, on a tout de suite pensé à un petit jeu avec la surcouche graphique de la NumWorks, Kandinsky.
On voulait partir sur un jeu, oui, mais lequel ? Après être passés par une reprise du jeu Rogue sorti en 1980, ou par un Space Invaders comme en 1978, nous sommes finalement partis sur une tout autre idée, et Cubito est né !
Nous nous sommes lancés dans ce projet avec empressement.
Il consiste en un jeu sur la NumWorks avec différents niveaux.
Chaque niveau s’articule particulièrement autour de 4 paramètres que vous pouvez voir dans la capture d’écran ci-contre :

Le jeu Cubito’s Adventures sur NumWorks
  • Le personnage principal, Cubito (carré jaune),
  • L’arrivée (carré bleu),
  • Les pièces (points blancs),
  • L’échelle (rectangle blanc)

Pour gérer chaque niveau, des variables sont actualisées à chaque fois dans la barre du bas, il s’agit du score, ainsi que du niveau.
L’objectif du jeu est d’atteindre l’arrivée en ayant le plus gros score. 
Le choix des couleurs devrait certainement vous rappeler le jeu Pac-Man sorti en 1980 et dont nous nous sommes quelque peu inspiré.

Outils à notre disposition et problèmes rencontrés

On avait hâte oui, mais on n’avait pas de moyens pour tester notre programme autrement que de l’envoyer sur la NumWorks à chaque fois, ce qui est très long !!
Deux possibilités s’ouvraient alors à nous :
Nous pouvions utiliser le Workshop NumWorks, le site officiel de NumWorks qui nous permettait de tester notre programme plus simplement et en ligne mais, le site n’était pas très intuitif et nos professeurs nous ont conseillé d’utiliser Omega IDE, pour avancer plus facilement.
On s’est donc servi de l’IDE en ligne Omega IDE, issu de l’OS alternatif pour la calculatrice du même nom. (Un IDE, de l’anglais « integrated development environment  », est un logiciel en ligne ou non qui intègre toutes les fonctionnalités utiles pour pouvoir développer sur un langage et un produit (ici en l’occurrence Python et sur la NumWorks).)
Omega IDE nous permet un aperçu du rendu sur calculatrice ainsi que l’enregistrement automatique de notre code sur GitHub (plateforme de partage de codes et programmes).
Mais tout ne pouvait pas être parfait. En effet, ce site étant en version alpha (pas vraiment sorti) certains bugs pouvaient être présents dont certains particulièrement embêtant auxquels nous avons eu affaire. 
En effet, si l’on testait notre programme une fois puis qu’on le re testait une seconde fois (même 10 min plus tard) les deux programmes se mélangeaient ce qui rendait le test quasi impossible et nous obligeait à rafraîchir à chaque fois la page web. Nous avons donc dû faire avec !

Un programme bien « carré »

Quand nous avons commencé notre programme, nous avons utilisé le code de l’agent 42, pour les déplacements.

Nous avions déjà réalisé un programme qui permettait les déplacements mais nous ne maîtrisions pas tout le savoir nécessaire sur le module Kandinksy au départ pour pouvoir réaliser ces déplacements.
Grâce à l’abandon de cette partie du programme, nous connaissions déjà les bases du module graphique ce qui nous a permis de mieux avancer dans notre travail par la suite.

Ce qui nous a bien aidé, c’est que dès le début, nous avons tout écrit et définit par des fonctions. Des fonctions pour chaque détails du code. Par exemple une fonction pour se déplacer, une pour la fin des niveaux etc…
Notre jeu était alors beaucoup plus facile à mettre en place, par de simples boucles comme vous pouvez ici le voir grâce à un extrait de notre fonction jeu.

def jeu():
    global niveau
    while niveau!=6:
        fill_rect(0,0,320,222,no)
        sleep(2)
        partie()
#[...]

Avec la boucle while qui teste la valeur de la variable niveau, on peut après une incrémentation (un ajout) de 1 à la variable niveau, appeler à chaque fois la fonction partie qui va à son tour appeler les déplacements, et l’initialisation de l’écran pour le niveau en question.

Évidemment, comme une bonne nouvelle n’arrive jamais seule, on a eu une petite complication car il fallait appeler chaque fonction, oui, mais par ordre d’appel très précis sinon cela ne fonctionne pas !

Notre programme a été centré sur la position des différents objets dans chaque niveau et l’interaction de Cubito avec les autres « objets ».

Un de nos plus grands problèmes dès le début était de faire en sorte que Cubito ne puisse pas sortir de l’écran de la calculatrice ! Il fallait définir le point le plus en haut à gauche et le point le plus en bas à droite, dans lequel le personnage pouvait se déplacer. Au bout de quelques heures (et beaucoup d’échecs), il fallait juste définir la « bordure » qui avait déjà été mise en place (pas avec les mêmes valeurs) par notre agent :

bordure = [0,0,190,310] #x min, y min, y max, x max

Le premier 0 est donc l’abscisse minimale de Cubito, 310 l’abscisse maximale, le deuxième 0 l’ordonnée minimale et 190l’ordonnée maximale.

Voyons maintenant un point central du jeu, la génération des pièces.

#[...]
def initiation(): #Génère les pièces
    fill_rect(0,0,320,222,no)
    for j in range(5,222,10):
        for i in range(5,320,10):
            set_pixel(i,j,bl)
#[...]

Cette fonction va donc au fur et à mesure créer une variable j, correspondant à l’ordonnée ainsi qu’une variable i, correspondant à l’abscisse, en partant de 5 à chaque fois. Puis au fur et à mesure, à chaque avancée, elle va allumer un pixel en blanc (le set_pixel). Pour le for j et i in range, le premier nombre correspond à la valeur de départ, 5 pour qu’à chaque déplacement, la pièce soit au centre de Cubito. Le deuxième nombre est la valeur maximale, car l’écran de la calculatrice est en 320 par 222. Enfin la troisième valeur correspond au « pas », c’est à dire l’avancée à chaque fois.

Pour les déplacements, voici un extrait de la fonction move :

#[...]
def move():
     if keydown(0): #gauche
            mvt[0] = max(position[0]-10, bordure[0])
            is_key_pressed = True
#[...]

Dans cette portion de code (pour aller à gauche), on dit à Cubito de se déplacer de -10 sur l’axe des abscisses. Mais comme notre personnage est un bloc de 10×10, alors il se déplace de 10 pixels par 10 pixels ; en fait il se décale d’une case ! Sans oublier qu’il laisse derrière lui une case noire pour effacer sa dernière position. Comme le fond est noir aussi, on a l’impression qu’il a disparu de son ancienne positon. C’est là toute l’illusion des déplacements !!

Un menu pour notre jeu

Nous avons voulu mettre en place un menu pour notre jeu.
Pour ne pas prendre trop de place dans le poids total du jeu, il n’est que partiellement interactif comme vous pouvez le voir dans la capture d’écran ci-dessous.

def menu():
    #[...]
    while not keydown(5):
        if keydown(4) or keydown(17):
            jeu()
#[...]

Pour afficher ce menu, nous avons juste affiché le texte à l’aide de draw_string.
Pour tout ce qui est interaction avec le joueur, c’est à dire commencer la partie, voici un extrait de code de la fonction menu :

Un problème coloré mais heureusement résolu !

Nous avons néanmoins rencontré durant ce projet, un problème épineux.
En effet, nous avions besoin d’utiliser la fonction get_pixel issue de Kandinsky qui permet de vérifier la couleur d’un pixel donné.
Ainsi, dans l’exemple ci-dessous :

Nous avons néanmoins rencontré durant ce projet, un problème épineux.
En effet, nous avions besoin d’utiliser la fonction get_pixel issue de Kandinsky qui permet de vérifier la couleur d’un pixel donné.
Ainsi, dans l’exemple ci-dessous :

Le programme trace un carré de 10 par 10 aux coordonnées (120 ; 120) et de couleur noire, soit (0,0,0) en RGB (rouge, vert, bleu), la méthode utilisée par la NumWorks pour les couleurs.

La ligne de code :

couleur_carre=get_pixel(120,120)

retournait comme valeur de la variable couleur_carre : (0,0,0).

Néanmoins, si on inversait les couleurs et que le cube était blanc sur un fond noir, le get_pixel ne retournait pas la couleur RGB du blanc : (255,255,255) mais une autre valeur incompréhensible pour nous, (248,252,248).
Après avoir demandé de l’aide à notre agent ainsi qu’aux développeurs d’Omega OS, car nous craignions que ce soit une erreur de notre part, nous avons appris que la calculatrice arrondissait le rouge tous les 8, le vert tous les 4 et le bleu tous les 8. Ce qui veut dire que les couleurs RGB rendues par le get_pixel avançaient de 8 en 8 pour le rouge, de 4 en 4 pour le vert et de 8 en 8 pour le bleu. Cette organisation complexe, nous a semblé plus claire grâce au programme fourni par notre professeur et montrant pour chaque couleur, ce qui ressortait au get_pixel.

Une fois ce souci réglé, nous pouvions enfin mettre en place les chutes et l’échelle !

Le fonctionnement des chutes peut paraître contre-intuitif au premier abord même s’il est tout à fait fonctionnel.
En effet, Cubito chute si en dessous de lui, il n’y a pas une pièce (par exemple s’il l’a déjà ramassée). 
Voici une portion de notre fonction vide qui réalise ceci :

def vide():
    global position, mvt, score, niveau
    while get_pixel(position[0]+5,position[1]+15)!=(248,252,248) and position[1]!=190:
        personnage(0)
        position[0]=position[0]
        position[1]+=10
        mvt[1]=position[1]
        score-=1
        personnage(1)
        sleep(1)
#[...]

Pour vérifier si il y a une pièce en dessous, on utilise le get_pixel que nous avons vu précédemment à la différence qu’on connait la valeur qu’il doit retourner : (248,252,248). 
Nous avons choisi d’utiliser une boucle, ce qui permet de vérifier que tant que la case au dessous n’a pas de pièce, le personnage continue de tomber, ce qui est permis par l’opérateur != (lire : « différent de »). La chute peut continuer jusqu’à arriver à la position maximale de Cubito en ordonnée : 190, sans quoi il irait sur les variables se trouvant dans la barre du bas.
On n’a donc plus qu’à ajouter 10 à l’ordonnée du personnage, à effacer son ancienne position et à créer la nouvelle à chaque tour de boucle.
Petite difficulté supplémentaire : les coordonnées de Cubito sont calculées à partir de son point le plus en haut à gauche, et les pièces sont placées de 10 en 10 mais en partant de 5.
Il faut donc pour savoir si une pièce en dessous de Cubito est présente ou non, faire le get_pixel aux coordonnées de l’abscisse de Cubito + 5 et de l’ordonnée de Cubito + 15 !

Ce get_pixel nous a aussi servi pour l’échelle comme vous pouvez le voir dans le code suivant :

#[...]
if get_pixel(position[0]+4,position[1]-39)==(248,252,248):
        personnage(0)
        position[1]-=longueur_scale+10
        position[0]=position[0]
        mvt[1]=position[1]
        personnage(1)
#[...]

En effet, au début nous avons voulu que l’échelle puisse faire monter le joueur de 40 (-40 car le point 0 est en haut), peut importe où nous étions sur l’échelle.
Mais quand l’échelle était trop proche du haut, Cubito sortait des limites du jeu.
Nous avons donc décidé que l’échelle ne pourrait être prise que du bas et ferait monter jusqu’en haut de cette dernière.
Ainsi pour vérifier que Cubito est bien tout en bas de l’échelle, qui a une longueur définie de 40, nous regardons le 39ème pixel au dessus de Cubito pour voir s’il est blanc. Si c’est le cas, le personnage se retrouve en haut de l’échelle.
Mais pourquoi le 39ème pixel et pas le 40ème, si l’échelle fait 40 de longueur ?
Tout simplement pour éviter de confondre avec une pièce, car pièce et échelle ont la même couleur !

Conclusion

Pour conclure, ce projet était ambitieux, c’était pas toujours facile, on a connu quelques tracas. 
Mais avec de la persévérance et l’aide de nos professeurs, nous avons réussi à créer un jeu qui nous satisfait réellement ! Ce challenge fut très enrichissant pour nous ! Le fait de se dire qu’en Première on a créé de toute pièce un jeu vidéo graphique alors qu’en troisième on n’avait jamais entendu parler de Python nous rend très fiers !

Et pour finir il y a pas un truc à se mettre sous la dent ?
Et bien si, un easter egg, et plus précisément un niveau unique est présent dans le jeu !!!
#[…]
Essayez de le trouver !

COMMENT TÉLÉCHARGER CE JEU POUR Y JOUER SUR MA CALCULATRICE ?

Vous trouverez dans le tableau ci-dessous les différents liens, mis à jour en fonction des évolutions du jeu, pour vous permettre de le télécharger !

ServeurWorkshop NumWorksTi-Planetnsi.xyz
Comment utiliser le codeBrancher sa calculatrice en USB et envoyer le codeTélécharger le code puis l’envoyer sur la NumWorks en passant par Omega IDE (si vous avez Omega OS)Idem
Lien URLCubito’s Adventures WorkshopCubito’s Adventures Ti-PlanetCubito’s Adventures (zip)

PS : Si la programmation sur calculatrice vous intéresse ou que vous voulez voir comment ça marche sur NumWorks, n’hésitez pas à lire : « Programmer en python et porter son code sur la NumWorks » qui vous donnera de précieux conseils pour y arriver !
Vous verrez c’est très plaisant de voir son programme avancer au fur et à mesure !!!

Projets

Douglas’s story

Nous vous présentons nos premier projet de nsi. Ce jeu basé sur l’interaction vous fera vivre des moment tordant. Vous pourrez incarner Douglas qui est aussi attachant qu’extravagant. Grâce à nous, vous allez passer les plus belles heures de jeux votre vie !!

Tout d’abord, notre projet consisté à créer un jeu qui mélange humour, stresse et action, nous l’avons nommé : DOUGLA’S STORY.

L’histoire de douglas se passe à notre époque, vous incarnerais donc le rôle de ce personnage très attachant qui mêle singularité et maladresse. Il a 16 ans et est passionné par les jeux vidéos et la musique. Votre mission dans ce jeu si vous l’acceptez sera d’aider Douglas a sortir avec la fille de ses rêves, car il a beau la voir tous les jours dans la cour de récrée, il na jamais réussit à franchir le pas et ne lui a donc jamais adresser la parole, vous devez donc grâce à votre génie l’aider à se rapprocher d’elle et plus si affinité.

Quel est le but du jeu et à quoi sert-il ?

Après multiple brain storming nous avons décidé de créé une histoire à choix multiples, suivant vos choix vous gagnerez ou perdrez des points, vous vous en douter ; plus vous avez de point plus votre objectif se réalisera. Ce principe de choix multiples est fait pour donner envie au joueur de découvrir toutes les fins et toutes les conséquences possibles de leur actes, ce qui est très intéressant pour nous développeur.

Problème rencontré

Le principal problème dans ce code a été le stockage. En effet, nous avons commencé à coder ce jeu uniquement à base de if, elif, else donc la place prise allé être assez importante.
On a donc trouvé un moyen avec l’aide de notre professeur pour réduire la taille du code.
Nous avons compressé les boucles if, elif, else en une seul boucle :

for i in range(7): # 7 phase, 0,1,2,3,4,5,6,7
    if score > 0 :
        clear(15)
        print(annonce1[i])
        input()
        print(annonce2[i])
        print(question[i])
        choixJoueur = int(input("Choix ="))
        choix = choixJoueur + move
        print(concequence[(choix-1)])
        score = score + points[i][(choixJoueur-1)]
        move += 3
        print("score = ", score)
        input()

Le deuxième problème a été d’insérer la conséquence à la suite des questions. Une fois le programme terminé, les conséquences s’appliquent pour tous les choix. C’est à dire que peu importe le choix de réponse, les conséquences étaient toutes les trois visibles. Or nous voulions que chaque réponse est sa conséquence. Nous avons donc réussis à faire cela en utilisant les balises :

concequence = ["1 = tres bon choix \nca commence bien ",
            "2 = c est pas le meilleur \nchoix mais en vrai \nca passe",
            "3 = alors entre nous patoche \nc est le meilleur mais douglas \nne l aime pas du tout",

Et en plus :

choixJoueur = int(input("Choix ="))
        choix = choixJoueur + move
        print(concequence[(choix-1)])
        score = score + points[i][(choixJoueur-1)]
        move += 3

Le troisième problème a été d’aérer le programme pour le rendre plus lisible et facile à décrypter. Il fallait utiliser des balises permettant d’espacer les différents codes :

def clear(saut=1):
    print("\n"*saut)

Conclusion

En conclusion, ce jeu nous a été utile dans notre progression vers un meilleur niveau en python. Nous avons rencontré pas mal de difficulté mais elles ont toutes été résolu évidemment. Nous avons fait de notre mieux et nous sommes donc fiers de notre projet.
Peut-être y aura-t-il une deuxième partie ? A voir par la suite.

Le code pour télécharger le jeu sur votre Numworks et jouer dès maintenant :

Projets

Un compte bancaire à contrôle de solde

Tu as envie de calculer tes recettes, ton solde dans plusieurs monnaies différentes alors ce script Python est fait pour toi. Tu auras accès à tes comptes sécurisés pour faire des crédits, convertir et débiter ton compte. Avec ce compte bancaire à contrôle de solde, tu n’as aucune limite.} }

Présentation du projet

Le projet que nous avons réalisé est un compte bancaire à contrôle de solde. Il permet d’entrer son nom et son mot de passe pour accéder au compte bancaire. Un mot de passe autre que celui enregistré renverra vers une erreur :

Plusieurs menus sont à disposition permettant de déterminer le sexe de l’utilisateur et de choisir parmi plusieurs propositions :

(Cet exemple sera démontré avec 1000 euros de solde)

Choix 1 : Nous choisissons de combien nous voulons créditer : 168 euros

Notre compte se trouve maintenant à 1168 euros

r = int(input("Combien voulez vous créditer? \n"))
        sf = sd + r
        print("Votre solde est de", sf,"euros.")

Grâce à l’addition et aux variables créées précédemment nous pouvons voir le calcul fait :

r = La valeur voulant être créditée

sd = Le solde du compte

sf = Le compte en banque une fois le crédit effectué

sf = sd + r

Choix 2 : Nous choisissons de combien nous voulons débiter : 272 euros

Notre compte se trouve maintenant à 728 euros

Si le compte en banque viendrait à être négatif, il afficherait “Compte à découvert »

dep = int(input("Combien voulez-vous débiter? \n"))
        sf = sd - dep
        if sf < 0:
            print("Votre solde est de", sf,"euros.")
            print("Compte à découvert.")

dep = La valeur voulant être débitée

sd = Le solde du compte avant toute action

sf = Le compte en banque après le débit

sf = sd – dep

Choix 3 : Nous choisissons de convertir notre solde de 1000 euros

Cela nous donne la valeur de notre solde en plusieurs monnaies : en Dollar, en Yen, en Livre sterling et bien sûr en euro.

sf = sd
        print("Votre solde est de", sf*1.18,"$.")
        print("Votre solde est de", sf*124.4,"JPY.")
        print("Votre solde est de", sf*1.10,"GBP.")
        print("Votre solde est de", sf,"euros.")

sf = La monnaie après avoir été convertie

sd = Le solde du compte avant toute action

En conclusion grâce à ce compte en banque vous pourrez créditer, débiter, convertir en toute sécurité. Avec un contrôle de solde n’ayez aucune crainte d’être à découvert.

Lien pour télécharger le script :

https://workshop.numworks.com/python/thomas-vignal01/compte_en_banque