Le jeu Plateforme sur la NumWorks en python

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

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

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

Le jeu :

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

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

Les animations :

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

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

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

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

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

Les personnages :

personnage statique :

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

personnage en mouvement :

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

personnage qui saute :

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

Les bases du jeu :

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

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

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

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

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

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

Conclusion :

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

Liens vers le jeu :

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

1ère spé NSI 2021- 2022

Cet article a été écrit par des élèves du lycée Louis Pasteur.
Ils étudiaient alors la spécialité NSI, en classe de 1ère.
Promotion 2021 – 2021

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

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)

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.

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

1ère spé NSI 2020 - 2021

Cet article a été écrit par des élèves du lycée Louis Pasteur.
Ils étudiaient alors la spécialité NSI, en classe de 1ère.
Promotion 2020 – 2021

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

1ère spé NSI 2020 - 2021

Cet article a été écrit par des élèves du lycée Louis Pasteur.
Ils étudiaient alors la spécialité NSI, en classe de 1ère.
Promotion 2020 – 2021

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 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 !

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 !!!

Gabin P.

Elève étudiant la spécialité NSI en classe de terminale en 2021.
Certainement en train de trifouiller sur son ordi ou une machine virtuelle