Les jeux sur le Raspberry Pi Pico

Dans cet article, j'aimerais parler des jeux sur le Raspberry Pi Pico.

Je me souviens de mon premier dumbphone, qu'on appelait un "téléphone" à l'époque. Il pouvait jouer à des jeux simples comme Snake. C'était de l'avant-garde.

Avant cela, vous deviez transporter un ordinateur de poche séparé qui jouait à Tetris ou un système de jeu plus dynamique comme une Gameboy.

Le Raspberry Pi Pico est un microcontrôleur assez puissant par rapport à ce que les ordinateurs de poche utilisaient dans les années 90. Naturellement, il nous offre la possibilité de jouer à des jeux de cette époque.

Quelle est la puissance du Raspberry Pi Pico ?

Comparé à une console des années 80, le Raspberry Pi Pico est extrêmement puissant. 

Si vous programmez un jeu dont les exigences en matière de ressources sont similaires à celles d'un jeu des années 1980, le Raspberry Pi Pico s'en sortira probablement très bien.

C'est dans les années 90 qu'il devient un peu plus difficile d'énoncer une conclusion aussi tranchée.

D'un côté, si vous le considérez comme un appareil capable de jouer à des jeux similaires à ceux que l'on trouve sur une Gameboy ou un téléphone portable, vous serez probablement satisfait.

Cependant, les jeux de la fin des années 90 sont devenus beaucoup plus exigeants. Vous ne jouerez pas à Quake 3 (un jeu de 1999) sur le Pico, par exemple.

En fait, si le Raspberry Pi Pico peut jouer à Doom (1993), la personne qui l'a codé a mis six mois à le faire, car il était assez difficile de compresser le jeu dans les 2 Mo de mémoire du Raspberry Pi Pico.

Ainsi, bien que le Pico soit doté de deux processeurs 133MHz, il dispose d'une mémoire vive et d'un stockage limités, ce qui rend la tâche difficile.

Voyons comment elle se compare à une Gameboy :

Pourquoi jouer à des jeux sur le Pico et pas sur le Zero/Pi 4 ?

Bonne question.

Comme vous le savez, le Raspberry Pi Pico est un microcontrôleur tandis que le Raspberry Pi Zero ou Pi 4 sont des micro-ordinateurs.

Les deux peuvent jouer à des jeux, mais le Raspberry Pi Pico est beaucoup plus limité.

Cela dit, si vous voulez construire un émulateur ou un système de jeu à partir du Raspberry Pi Zero ou du Pi 4s aujourd'hui (en 2022), vous avez intérêt à en avoir déjà un, sinon votre plus gros goulot d'étranglement est le stock.

Il est très difficile d'obtenir un Pi Zero et assez difficile d'obtenir un Pi 4.

D'autre part, le Pico est abondant. De plus, il démarre presque immédiatement, alors que le micro-ordinateur Pis doit passer par un long processus de démarrage.

Le Pico dure également beaucoup plus longtemps. Si vous voulez une installation mobile qui fonctionne pendant des heures et qui est portable, vous ferez beaucoup mieux avec le Pico.

Enfin, outre le stock, le Pico est également abondant en stock.

Pour être juste envers les Pi Zero et Pi 4, vous pouvez certainement jouer à de meilleurs jeux et obtenir de meilleurs résultats d'émulation avec ces micro-ordinateurs. Comme vous le verrez dans la section suivante, le Pico a du mal à jouer à des jeux que le Zero ou le Pi 4 réussissent sans problème.

À quels jeux le Raspberry Pi Pico peut-il jouer ?

Nous allons commencer par voir ce que la communauté des bricoleurs a pu faire sur le Raspberry Pi Pico.

RP2040 Doom est la réponse à la question "Est-ce que ce sera Doom ?".

Oui ! Le Raspberry Pi Pico peut jouer à Doom.

Un certain Graham Sanderson d'Austin, au Texas, a réussi à porter Doom sur le Raspberry Pi Pico.

Sa formule magique ?

while (!convice_myself_its_probably_impossible()) {
    do_some_more();
}

Il a expliqué dans sa documentation du processus qu'il a été confronté à de multiples restrictions liées aux spécifications matérielles du Raspberry Pi Pico. Après tout, il ne s'agit pas d'un appareil destiné aux jeux.

Néanmoins, Graham a également décidé de rendre le portage de Doom encore plus difficile. Il voulait une expérience authentique de Doom, ce qui signifiait avoir une résolution de 320×200 (couleur), un son stéréo, une musique OPL2, la sauvegarde et le chargement, le multijoueur en réseau et d'autres caractéristiques disponibles dans le nom original.

Pour mettre autant de jeux sur le Raspberry Pi Pico, il fallait relever le défi de la mémoire. La mémoire vive et l'espace de stockage étaient des questions essentielles.

Tout d'abord, le Raspberry Pi Pico ne dispose que de 2 Mo de mémoire, mais la version shareware de Doom fait deux fois cette taille. Alors que d'autres développeurs pourraient décider de supprimer certaines fonctionnalités comme les écrans d'accueil et le sous-échantillonnage des textures, Graham ne voulait pas le faire.

La RAM était également un autre problème, le code source de Chocolate Doom nécessitant environ 1 Mo de RAM alors que le Pico ne dispose que de 264 Ko. La mémoire est serrée car le rendu des graphiques occupe une grande partie de l'espace de la RAM, mais la RAM est également très importante pour le bon fonctionnement du jeu. Afin de gérer ces deux aspects, Graham a dû procéder à ce qu'il a appelé une "liposuccion".

Vous pouvez en savoir plus en vous rendant sur la documentationen regardant sa liste de lecture sur YouTube ou révision du code.

Émulateur NES

Le Raspberry Pi Pico a été transformé avec succès en émulateur NES.

Dans un fil de discussion du forum Emulator ZoneL'utilisateur ropgar a déclaré que le Raspberry Pi Pico a la puissance nécessaire pour émuler une NES et qu'il peut faire 60 images par seconde et émuler parfaitement l'APU et le PPP.

Ropgar utilise un clavier PS/2 comme contrôleur, mais vous pouvez également utiliser le contrôleur NES original.

Le son est bon et il n'y a aucun problème avec la vidéo et la musique de fond du jeu.

Le Pico dispose d'environ 1,5 Mo d'espace flash pour différents jeux, qui peuvent être choisis en appuyant sur le verrouillage des majuscules pour passer d'un jeu à l'autre. 

Les jeux que ropgar a réussi à charger sur sa démo sont Pacman, Arkanoids, DK, DK Jr, BubbleBobble, Galaga, et bien d'autres.

Le seul inconvénient est qu'il n'existe pas de code source public ou de tutoriel sur la manière de procéder.

Émulateur de Gameboy pour le Raspberry Pi Pico

Vous pouvez fabriquer votre propre boîtier de Gameboy, puis utiliser le Raspberry Pi Pico pour émuler la Gameboy.

Le problème, c'est qu'il ne s'agit pas d'une solution qui a connu un grand succès. En d'autres termes, ce que vous construisez peut fonctionner, mais pas toujours.

Jetons un coup d'œil aux options disponibles.

Émulateur de Gameboy Rust (OxidGB Pico Port)

En voyant l'image de Pokemon sur l'écran, j'ai été immédiatement excité.

Cependant, James Selby a effectivement écrit sur les défis et les lacunes de son émulateur de Gameboy, écrit en Rust, appelé OxidGB Pico Port.

"Cela a été un parcours - un parcours frustrant, mais un parcours que j'ai néanmoins beaucoup apprécié d'un point de vue éducatif", a déclaré M. Selby.

Problèmes et victoires

Voici le principal défi : L'émulateur Rust Gameboy "n'est pas exactement jouable dans son état actuel, malheureusement".

Selby a déclaré que les jeux n'obtiennent qu'environ 10 FPS parce que le code de l'émulateur est un goulot d'étranglement ainsi que l'interface SPI lente vers l'écran.

Il est possible d'accélérer les choses, mais cela demande du temps de planification et de mise en œuvre.

L'entrée n'a pas été configurée, puisque les jeux n'étaient pas jouables. 

Test du port Pico de l'OxidGB

Si vous souhaitez faire un essai, vous pouvez suivre les instructions de Selby sur son site Web. Github repo pour le port Pico d'OxidGB.

Emulateur RP2040_GB

Un autre émulateur que vous pouvez essayer est le RP2040_GBqui est basé sur le Cacahuète-GB émulateur.

Les performances du RP2040_GB sont décentes, Koshkouei affirmant que sa configuration "fonctionne à plus de 70 images par seconde sans émulation audio. Avec le saut de trame et l'entrelacement, elle peut atteindre 120 images par seconde".

Comme vous pouvez le voir, la RP2040_GB joue à Pokemon. Les étapes pour obtenir une ROM sur le RP2040 sont les suivantes :

• Vous devez avoir le Pico SDK
• Convertir .gb ou .gbc ROM à un fichier d'en-tête C en utilisant l'option xxd programme
• Modifiez le fichier converti en ajoutant deux lignes de code (dans le readme de Github)
• Copier la ROM sur le src et compiler.

Cet émulateur présente certaines limites :

• "Cet émulateur est imprécis et constitue un travail en cours... certains jeux peuvent ne pas fonctionner correctement ou ne pas fonctionner du tout." 
• Les jeux Gameboy Color affichent une erreur
• Non optimisé pour le microcontrôleur : Koshkouei a suggéré que "l'utilisation d'un APU optimisé pour l'espace et la vitesse" peut aider.

Voir le repo Github de la RP2040_GB ici.

Compilation de méga jeux avec Raspberry Pi Pico

La meilleure partie de ce projet est qu'il est simple et que les instructions sont adéquates pour que vous puissiez vous lancer rapidement dans la construction d'une console de jeu Raspberry Pi Pico.

Roger Bühler propose des pièces, des instructions et des démonstrations sur son Github.

La compilation de méga jeux comprend les jeux suivants :

1. Tiny Gilbert
2. Une petite astuce
3. Tiny Invaders v3.1
4. Tiny Pinball v2
5. Tiny Pacman v1.2
6. Tiny Bomber v1.3
7. Tiny Bike v1.2
8. Tiny Bert 1.1
9. Tiny Arkanoid v2
10. Tiny Tris v2.1e
11. Petite plaque
12. Tiny DDug
13. Tiny Missile v1.1
14. Tiny Lander v1.0 ( by Roger Buehler )
15. Petit Morpion
16. Tiny Pipe

Les pièces dont vous aurez besoin sont les suivantes :

1. Raspberry Pi Pico
2. Écran OLED SSD1309 128x64px SPI (écran 2,42" au rapport 2:1)
3. Buzzer piézoélectrique
4. Cinq boutons
5. Planche à pain
6. Câbles de démarrage
7. Facultatif : résistances de 10 ohms, condensateur électrolytique évalué à au moins 10V et 220uF

Vous aurez également besoin de Bibliothèque SSD1306 d'Adafruit.

Voici comment connecter l'écran :

• GND -> GND de l'écran 
• 3V3(OUT) -> Affichage VCC 
• GP16 -> Affichage DC (Data Command) 
• GP17 -> Affichage CS (Channel Select) 
• GP18 -> Affichage SCL (horloge) 
• GP19 -> Affichage SDA (MOSI) 
• GP20 -> Affichage RES (Reset)

Et pour connecter les boutons :

• GP15 -> bouton UP 
• GP14 -> bouton DOWN 
• GP13 -> bouton GAUCHE 
• GP12 -> bouton DROIT 
• GP11 -> bouton FIRE (tous les boutons vers GND)

Et pour connecter le buzzer piezo :

• GP10 -> Buzzer(+) 
• GND -> Buzzer(-)

Installation du logiciel :

Afin d'installer le logiciel, vous devez utiliser l'IDE Arduino.

Jeu de Tamagotchi-like sur le Raspberry Pi Pico (Pico-Tamachibi)

Pourquoi l'appelle-t-on Pico-Tamachibi ?

Selon Kevin McAleer, le créateur de ce dispositif, "tama" signifie "œuf" et "chibi" fait référence aux graphiques où le personnage a une grosse tête. 

La création du Tamachibi est facile car Kevin explique chaque étape dans son tutoriel de 90 minutes.

Construisez votre propre machine de jeu

Si vous souhaitez fabriquer votre propre machine de jeu Raspberry Pi Pico, il existe deux méthodes générales : acheter un kit prêt à l'emploi ou le construire vous-même.

Kit prêt à l'emploi ou matériel de jeu bricolé Raspberry Pi Pico ?

S'il est possible de partir de zéro, il est préférable de ne pas s'embêter à construire son propre système et de se contenter d'acheter une formule toute prête.

Il existe quelques kits basés sur la RP2040 qui vous permettent de vous lancer directement dans le jeu ou le développement de vos propres jeux.

Examinons le picosystème Pimoroni et comparons-le au processus de construction de quelque chose de similaire à l'aide de pièces individuelles.

Pimoroni Picosystem

Jetons un coup d'œil au Picosystem Pimoroni.

Comme vous pouvez le constater, il est beaucoup plus grand que le Raspberry Pi Pico W, mais c'est aussi parce qu'il dispose d'un pavé numérique à quatre directions, de quatre boutons, d'un écran LCD, d'une batterie lithium-ion, d'un haut-parleur piézoélectrique et d'un port USB-C, entre autres ajouts.

Il possède le même processeur et la même mémoire vive, car le Picosystem et le Pico utilisent tous deux la puce RP2040. Voici les spécifications complètes :

• Alimenté par RP2040 (Dual Arm Cortex M0+ avec 264kB de SRAM)
• 16MB de flash QSPI supportant XiP
• Écran LCD IPS SPI couleur 1,54″ (modes 240×240 et 120×120)
• D-pad et boutons
• Batterie LiPo 525mAh (6hrs+)
• Buzzer/ haut-parleur piézoélectrique
• Bouton d'alimentation marche/arrêt
• LED RGB
• Programmable et rechargeable via USB-C (câble non inclus)

Modes graphiques

Le PicoSystem prend en charge deux modes graphiques.

• 240×240 : la résolution native du LCD
• 120×120 : mode pixel doublé (économise la RAM)

À quoi ressemble un jeu sur le Picosystem ?

Jouer sur le Picosystem est facile. Il suffit d'appuyer sur le bouton d'alimentation pour accéder au jeu préchargé, Super Square Bros.

Le jeu est un simple jeu de plates-formes, à l'instar de Mario.

Pimoroni a également inclus d'autres jeux :

• Super Square Bros. par Scorpion Games - Un jeu de plateforme quadrilatéral plein de rebondissements. (jeu préchargé)
• Points - Un casse-tête avec des points. Créez des chaînes de deux ou plus et faites la course pour obtenir le meilleur score.
• Roches et diamants - Jeu classique consistant à esquiver les rochers et à attraper des diamants.
• Géométrie - Écrasez des rochers de l'espace avec des lasers pour créer de plus petits rochers de l'espace !
• L'ascension de l'arc-en-ciel - Le Dark Souls des puzzles à saut vertical générés de manière procédurale. Bonne chance.
• Super Blit Kart par Daft_Freak - Un jeu de course basé sur "Mode7".

Pour installer ces jeux, procédez comme suit :

• Téléchargez le fichier.
• Branchez votre Picosystem sur le PC
• Appuyez sur le bouton X et maintenez-le enfoncé, puis appuyez sur le bouton d'alimentation.
• Le Picosystem doit être monté comme un lecteur appelé RPI-RP2.
• Copiez le fichier .uf2 téléchargé sur le lecteur. Il se chargera automatiquement.

Pour une raison quelconque, mon câble USB-C vers USB-C n'a pas fonctionné, mais le câble USB-A vers USB-C a fonctionné avec le Picosystem. Si vous ne voyez pas le voyant rouge s'allumer, essayez un autre câble.

Programmez vos propres jeux

La meilleure partie du Picosystem est qu'il fournit un système qui vous permet de créer vos propres jeux.

Plutôt que de coder à partir de zéro, PicoSystem est livré avec une API spéciale qui peut vous aider à créer vos jeux.

Il élimine également une grande partie du travail fastidieux nécessaire à l'achat de pièces individuelles telles qu'un écran LCD, des boutons, des fils de liaison, une plaque d'essai, puis à la recherche des bibliothèques et des paquets nécessaires au fonctionnement de tous ces éléments.

L'API du PicoSystem comporte des fonctions permettant de dessiner des éléments à l'écran, d'émettre des sons, des fonctions matérielles et d'autres fonctions utilitaires. Cela vous permet de construire votre jeu plus facilement.

Tout comme le Raspberry Pi Pico, le PicoSystem peut être codé en C++ ou MicroPython. 

Est-il facile de programmer un jeu avec le Picosystem ?

Je vous recommande d'avoir un peu de temps et de patience pour construire votre propre jeu avec le Picosystem.

La documentation offre les éléments de base pour vous permettre de démarrer, mais il serait préférable que vous ayez des connaissances préalables en programmation de jeux.

Le plus grand défi pour les débutants est qu'il n'existe pas beaucoup de ressources pour vous apprendre à coder des exemples de projets. Cependant, voici une liste de références qui pourront vous aider :

Guide Picosystem MicroPython (dans readme)

Exemples de Picosystem MicroPython

Picosystem C++ Github

Exemples de Picosystem C++

Aide-mémoire de l'API Picosystem, plus convertisseur d'images et de polices de caractères (sur la barre latérale)

Système de bricolage : Créer le matériel

Le guide de YouMakeTech explique au lecteur comment fabriquer une console de jeu complète avec un boîtier, un système de son et des soudures permanentes.

Pour notre comparaison, voyons combien il en coûterait pour construire une unité de bricolage par rapport au Picosystem, qui est un kit complet.

Voyons donc les coûts finaux pour les différents niveaux d'installations de bricolage :

Juste une mise en garde - YouMakeTech dit que vous pouvez le construire pour moins de $20. Cependant, d'après mes recherches, les coûts d'une installation DIY correspondant au Picosystem ne diffèrent pas vraiment beaucoup, surtout si l'on tient compte du logiciel et de la commodité.

Cela dit, la voie du bricolage est une excellente occasion d'apprendre. Une chose qui m'a mis au défi était l'écran. Alors que l'exemple de YouMakeTech utilise une connexion I2C, l'écran que j'avais utilisait une interface SPI à 4 broches. Cela nécessite soit un changement dans le codage, soit une modification du matériel pour pouvoir continuer. Si vous aimez les défis, la voie du bricolage est faite pour vous.

Alors, quels sont les avantages du bricolage par rapport au Picosystem ?

Création du jeu Pong-like sur le système Picosystem vs DIY

Une de mes expériences les plus curieuses consiste à déterminer le degré d'effort nécessaire pour développer un jeu à l'aide du Picosystem par rapport à un jeu créé de toutes pièces.

Afin de comparer les deux systèmes, je vais construire un jeu de type Pong à un joueur sur le système DIY de YouMakeTech et sur le Picosystem.

Le principe du jeu est simple. Il s'agit d'un jeu de type Pong à un joueur qui vous donne 10 points chaque fois que votre balle rebondit sur la raquette. Si elle tombe en bas de l'écran, vous recevez un message "Game Over".

La création du jeu sur les deux systèmes suit un flux de travail simple qui aboutit à Thonny.

Vous devrez flasher MicroPython sur le Pico, puis vous utiliserez Thonny pour coder votre programme. 

Le MicroPython que vous flashez sur le Picosystem est différent du fichier officiel MicroPython UF2, donc assurez-vous que vous flashez le bon parce que le Picosystem fonctionnera avec la version officielle de MicroPython. Il ne fonctionnera simplement pas comme prévu.

Examinons maintenant quelques différences fondamentales entre les deux. J'exclue ici la logique de jeu et je compare uniquement les différences dans l'interaction matériel-logiciel et les modèles de programmation.

Vous pouvez voir le code de YouMakeTech ici.

Première différence : le code matériel

Les choses sont très "brutes" avec la voie du bricolage. Voici un peu de code pour initialiser l'affichage, le GPIO et les boutons que vous n'aurez pas besoin de faire avec le Picosystem :

from machine import Pin, PWM, I2C,
from ssd1306 import SSD1306_I2C
…
# Buttons
up = Pin(2, Pin.IN, Pin.PULL_UP)
down = Pin(3, Pin.IN, Pin.PULL_UP)
left = Pin(4, Pin.IN, Pin.PULL_UP)
right = Pin(5, Pin.IN, Pin.PULL_UP)
button1 = Pin(6, Pin.IN, Pin.PULL_UP)
button2 = Pin(7, Pin.IN, Pin.PULL_UP)

# Buzzer connected to GP18
buzzer = PWM(Pin(18))

# OLED Screen connected to GP14 (SDA) and GP15 (SCL)
i2c = machine.I2C(1, sda = Pin(14), scl = Pin(15), freq = 400000)
oled = SSD1306_I2C(SCREEN_WIDTH, SCREEN_HEIGHT, i2c)

Deuxième différence : L'API de Picosystem

Si vous écrivez du code sur le Picosystem, vous devez écrire dans son système.

Dans l'exemple de YouMakeTech, toute la logique du jeu est encapsulée dans un fichier de type alors que True boucle. Cela inclut l'interaction avec les boutons, la détection des collisions et le dessin à l'écran.

Dans le Picosystem, vous êtes tenu d'écrire dans le cadre de trois fonctions : - les fonctions de gestion de l'information, - les fonctions de gestion de l'information. init(), update() et dessiner().

Dans mon code, toute la logique du jeu est écrite en actualiser() y compris la gestion des collisions et l'interaction avec le D-pad.

Dans un simple jeu de Pong, j'ai utilisé quelques fonctions de l'API qui ont rendu les choses un peu plus faciles :

intersects(x1, y1, w1, h1, x2, y2, w2, h2)  est probablement la plus grande aide ici. Vous lui passez les coordonnées et la taille des deux carrés et elle renvoie vrai s'il y a une intersection. Dans ce cas, les deux rectangles sont la balle et la barre (alias la raquette). Le défaut de la fonction intersects() est qu'elle ne détecte pas de quel côté la collision s'est produite. J'ai donc dû écrire du code supplémentaire pour traiter les collisions du côté de la barre.

L'API du Picosystem s'avérera très utile lorsque vous développerez des jeux plus complexes, étant donné qu'il dispose déjà d'une méthode pour les framebuffers, la sortie audio, le blending, etc. 

Code pour Pimoroni Picosystem Jeu de type pongiste

#bar_pos_x = pixels from left, e.g. 0 from left
bar_pos_x = 50
#bar_pos_y = pixels from top, e.g. 100px from top
bar_pos_y = 100
BAR_WIDTH = 30

LENGTH_CONSTANT = 5

ball_speed = 1
ball_pos_x = 10
ball_pos_y = 10
ball_dx = 2
ball_dy = 2

score = 0
game_over = False

def update(tick):
    
    global bar_pos_x
    global bar_pos_y
    global ball_pos_x
    global ball_pos_y
    global ball_dx
    global ball_dy
    global ball_speed
    global score
    global game_over
    
    def reverse_ball_dx():
        global ball_dx
        ball_dx = ball_dx * -1
        
    def reverse_ball_dy():
        global ball_dy
        ball_dy = ball_dy * -1
    
    ball_pos_x += ball_dx
    ball_pos_y += ball_dy
    
    if button(LEFT) and bar_pos_x > 0:
        bar_pos_x -= 1
    
    if button(RIGHT) and bar_pos_x < 120 - BAR_WIDTH :
        bar_pos_x += 1
        
    if ball_pos_x <= 0 :
        ball_pos_x = 0
        reverse_ball_dx()
        
    if ball_pos_x >= 120 - LENGTH_CONSTANT :
        ball_pos_x = 120 - LENGTH_CONSTANT
        reverse_ball_dx()
        
    if ball_pos_y >= 120 - LENGTH_CONSTANT :
        game_over = True
        
    if ball_pos_y <= 0:
        ball_pos_y = 0
        reverse_ball_dy()
        
    if intersects(bar_pos_x,bar_pos_y,BAR_WIDTH,LENGTH_CONSTANT, ball_pos_x, ball_pos_y, LENGTH_CONSTANT,LENGTH_CONSTANT):
        
        reverse_ball_dy()
        score += 10
        
        #main intersection of ball and bar. if they intersect, check if they are intersecting on the sides.
        #if not on sides (i.e. on top) reverse Y direction. Or else, reverse X direction.
        if intersects(bar_pos_x,bar_pos_y,1,LENGTH_CONSTANT, ball_pos_x, ball_pos_y, LENGTH_CONSTANT,LENGTH_CONSTANT):
            
            #intersecting on left
            
            reverse_ball_dx()
            ball_pos_x -= 2
            
        if intersects(bar_pos_x + BAR_WIDTH,bar_pos_y,1,LENGTH_CONSTANT, ball_pos_x, ball_pos_y, LENGTH_CONSTANT,LENGTH_CONSTANT):
            
            #intersecting on right
            
            reverse_ball_dx()
            ball_pos_x += 2

        
def draw(tick):
    
    if game_over:
        pen(0,0,0)
        clear()
        pen(15,15,15)
        text("Game Over", 35, 60)
        
        
    else:
        pen(0, 0, 0)
        clear()
        pen(15,15,15)
    
        #draw bar (paddle)
        frect(bar_pos_x,bar_pos_y,BAR_WIDTH,LENGTH_CONSTANT)
    
        #draw the ball
        frect(ball_pos_x, ball_pos_y, LENGTH_CONSTANT,LENGTH_CONSTANT)
        text(str(score), 80, 20)
    
start()

Vous avez un jeu à recommander ?

Si vous avez un jeu pour le Raspberry Pi Pico, laissez un commentaire ci-dessous avec une URL.

Et si vous souhaitez consulter notre série de projets Paragon, rendez-vous sur le site suivant ici.