Étiquette : Jeux

NumApps

Pong en Python, Numworks

Pong est un jeu que l’on n’a plus besoin de présenter. Autrefois présent sur des bornes d’arcades lors de la genèse du jeu vidéo au début des années 70, le concept a évolué mais reste toujours aussi fun ! Découvrir la programmation d’un jeu en python sur ce jeu est passionnant, et si le code de 12ko de la première version offrait de grandes possibilités, la version 2 présentée ici est à découvrir sans tarder.

Captures d’écran du jeux

Une version 2 optimisée

La première version de ce jeu, conçu en deux semaines et quelques insomnies, a plutôt bien marché mais paradoxalement c’était mon premier jeu, et donc il n’était vraiment pas optimisé. Six mois plus tard, j’ai décidé de m’y remettre. J’ai donc pris mon courage à deux mains et je l’ai entièrement réécrit. De cette manière, la nouvelle version est plus petite mais bien meilleure.

Des menus, des graphisme et un gameplay revisité

Le jeu offre tout premièrement des menus interactifs, programmés grâce à une bibliothèque personnelle, menulib. Ce dernier vous permet de tout (ou presque) paramétrer, des points maximums à la vitesse de la balle, la difficulté, mais aussi les graphismes. En effet, grosse nouveauté, le jeu supporte désormais des thèmes et des particules ont étés ajoutées quand on active les détails de la balle.

Le jeu est jouable en plusieurs modes :

  • Solo : on contrôle les deux pads et on doit faire le plus grand nombre de rebonds
  • 2 players : on a la possibilité de jouer avec un ami en duel
  • Contre l’ordinateur : on joue contre la calculatrice. Attention ! La difficulté se règle dans les paramètres de jeu.

Contrôles

Flèches haut/basBouton supprimer (backspace)Boutons multiplication/addition
Pad 1 (gauche)PausePad 2 (droite) (en mode 2 joueurs)

Téléchargement

NumApps

JetPack Bird en Python, Numworks

Sortie en 2013, Flappy Bird fut un énorme succès sur les plateforme Android et iOs. Le jeu proposé ici est une fusion de deux jeux, Flappy Bird, jeu ou l’on fait voler un oiseau en tapotant l’écran, et JetPack joyride, dans lequel le personnage Barry utilise un jetpack pour se promener à sa guise entre des rayons lazers.

Capture d’écran du jeux

La jouabilité

Pour ce jeu, j’ai voulu donner plus de jouabilité au personnage, pour qu’il soit adapté au « grand publique ». Au départ pensé comme un simple clone de Flappy Bird, je me suis tourné vers un déplacement plus fluide tel que celui d’un JetPack, fonctionnant avec une accélération et non par à-coup. Une seule touche est utile, la touche [OK].

Optimisation et graphismes

Comme je l’ai déjà dit, je voulais un jeu adapté à tout le monde. Donc, par soucis de place, j’ai opté d’enlever tout menu. Pour rendre le jeu tout de même beau, j’ai ajouté une fonction qui trace un contour autour de chaque rectangle tracé. Malheureusement, pour avoir un jeu rapide, il est plus facile de tracer un grand rectangle noir qui sert de cadre puis de tracer à l’intérieur un rectangle de la couleur désirée, mais (combiné à l’écran lui même qui a quelques défauts) cela produit des effets de rafraichissement pas très agréables… Rassurez vous tout de même, cela reste largement jouable ! Notez que le meilleur score est enregistré avec Oméga (et Os dérivées). Bon jeu !

Téléchargement

Nous vous proposons 2 liens distincts, le premier est le lien vers la source du créateur de l’application, le deuxième est un lien alternatif en cas de problème. Seul le premier lien garanti de disposer de la dernière version de l’application ainsi que la documentation écrite directement dans le workshop.

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

NumApps

Sokoban en python, NumWorks

Le Sokoban est un jeu de puzzle et de réflexion japonais du début des années 80. L’expérience acquise dans le l’organisation des caisses d’un entrepôts te permettra, on l’espère, d’être plus efficace lorsque tu devras ranger ta chambre !

Capture d’écran du jeux

Commandes

Croix directionnelleClearEXE+ / –Retour arrière
Se déplacer sur la grille du jeuAnnulerRecommencerChoisir un niveauQuitter le jeu

Un peu de technique

Si vous souhaitez en savoir plus sur les aspects techniques de ce jeu, lisez les articles de présentation :
[tiplanet.org] Un Sokoban pour la NumWorks
[nsi.xyz] Un Sokoban pour la NumWorks

Télécharger la démo (5 niveaux)

Nous vous proposons 2 liens distincts, le premier est le lien vers la source du créateur de l’application, le deuxième est un lien alternatif en cas de problème. Seul le premier lien garanti de disposer de la dernière version de l’application ainsi que la documentation écrite directement dans le workshop.

Télécharger la jeu complet

Pour avoir plus que 5 niveaux, il vous faut lire attentivement la documentation : Un Sokoban pour la NumWorks car il va falloir ajouter plusieurs scripts à votre calculatrice.

NumApps

Doodle Man en python, NumWorks

Doodle Jump eu une énorme succès sur les smartphones modernes à la fin des années 2000. Il exploitait alors l’ accéléromètre pour offrir un gameplay enfantin et addictif. Cette version qui se contrôle avec la croix directionnelle va faire un carton !

Captures d’écran du jeux

Un peu de technique

Un gameplay simplifié pour tenir sur 8ko

Après avoir programmé un jeu pas très ambitieux avec Cyclope Snake, j’ai voulu recréer un classique des jeux mobile : Doodle Jump … avec les contraintes de la machine !

Les contraintes en question, et bien, ces sont principalement le manque de mémoire. Pour éviter de surcharger le stockage, j’ai été obligé de faire des concessions : le cube rouge aux yeux luisants (un mélange entre Super Meat Boy et Herobrine ?!) n’a pas d’ennemis à esquiver ou éliminer. Par conséquent, il ne tire pas de balles vers le haut.

Les plateformes sont de plusieurs types : mouvante, fantôme, éphémère, trampoline, etc …

Seul objectif : battre son meilleur score

Sans ennemis, la seul chose à faire est de grimper le plus haut possible ! Les plateformes et le personnage diminuent de taille au fur et à mesure. Par contre, les commande restent volontairement assez « amples » ! Le jeu est donc pensé pour être challengeant. Dernière chose : avec l’Os Omega, le jeu enregistré le meilleur score dans un fichier de sorte à le recharger d’une partie à l’autre !

Télécharger

Nous vous proposons 2 liens distincts, le premier est le lien vers la source du créateur de l’application, le deuxième est un lien alternatif en cas de problème. Seul le premier lien garanti de disposer de la dernière version de l’application ainsi que la documentation écrite directement dans le workshop.

NumApps

Cyclope Snake en python, NumWorks.

Parfois il suffit de rajouter un chrono dans un jeu et un comportement aléatoire pour tout changer. Ce Snake réinvente le gameplay, et reprend les codes graphiques des premiers jeux sur console. Un succès garanti !

Un Snake avec des graphismes évolués

Ce qui fait de cyclope Snake un jeu (un peu) différent, c’est que l’expérience de jeu a été améliorée avec des petits éléments de gameplay ou de graphisme comme par exemple l’interface style arcade, avec des contours et un tableau de score.

Commandes

Croix directionnelleOK
Se déplacerValider

Un peu de technique

Sur gameplay, le meilleur score est enregistré et rechargé à chaque lancement si vous utilisez Omega Os.
Par ailleurs, le serpent a une jauge de faim qui se réinitialise à chaque fois qu’il mange un fruit. Si cette jauge est remplie, il devient affamé et va aller dans le direction opposée de celle désirée, jusqu’à ce qu’il remange un fruit.

Les éléments du jeu possèdent une ombre (ça m’a été plutôt difficile à intégrer, je reviendrai là dessus dans un article futur, peut être), et le serpent a plusieurs détails.

Vous trouverez sur la page de téléchargement du jeu des instructions de personnalisation du jeu (couleurs, taille, difficulté, etc…)

Télécharger

Nous vous proposons 2 liens distincts, le premier est le lien vers la source du créateur de l’application, le deuxième est un lien alternatif en cas de problème. Seul le premier lien garanti de disposer de la dernière version de l’application, ainsi que la documentation écrite directement dans le workshop.

NumApps

Pac-Man en python, NumWorks

Au début des années 80 il y avait sur la console ATARI en jeu de labyrinthe qui connu en grand succès : Pac-Man. Manger des pac-gommes sans se faire manger soit même, tout un programme !

Capture d’écran du jeux

Commandes

FlèchesRetour arrière
Se déplacer sur la grille du jeuInterrompt le jeu,
sans possibilité de le reprendre

Un peu de technique

Si vous souhaitez en savoir plus sur les aspects techniques de ce jeu, lisez l’article de présentation :
Un Pac-Man sur ta Numworks, en python

Télécharger

Nous vous proposons 2 liens distincts, le premier est le lien vers la source du créateur de l’application, le deuxième est un lien alternatif en cas de problème. Seul le premier lien garanti de disposer de la dernière version de l’application.

A noter : Le jeu ne fonctionne correctement sur la calculatrice mais pas sur le workshop 😕

NumApps

Treasure en python, NumWorks

Un trésor a été caché. Déplace-toi et pars à sa recherche. Évite les rochers et les trous. Il te suffit d’appuyer sur OK pour creuser un trou. Un sonar peut t’aider, enfin uniquement si tu sais l’utiliser !

Captures d’écran du jeux

Commandes

FlèchesOK
Se déplacer sur la grille du jeuCreuser un trou pour trouver le trésor

Télécharger

Nous vous proposons 2 liens distincts, le premier est le lien vers la source du créateur de l’application, le deuxième est un lien alternatif en cas de problème. Seul le premier lien garanti de disposer de la dernière version de l’application.

NumApps

Tetris en python, NumWorks

Un incontournable de la Gameboy des années 90. Un jeu de puzzle dans lequel la patience fini par payer ou couter cher. Dans cette version, on peut commencer directement au niveau 42 !

Captures d’écran du jeux

Commandes

FlèchesClearOK
Déplacer les TetrominosRetournerLancer la partie

Un peu de technique

Si vous souhaitez en savoir plus sur les aspects techniques de ce jeu, lisez l’article de présentation :
Un Tetris en python pour la NumWorks

Télécharger

Nous vous proposons 2 liens distincts, le premier est le lien vers la source du créateur de l’application, le deuxième est un lien alternatif en cas de problème. Seul le premier lien garanti de disposer de la dernière version de l’application.