Gamen op de Raspberry Pi Pico

In deze post wil ik het hebben over gamen op de Raspberry Pi Pico.

Ik herinner me mijn eerste dumbphone, die toen een "telefoon" werd genoemd. Het kon eenvoudige spelletjes spelen zoals Snake. Dat was het neusje van de zalm.

Daarvoor moest je een aparte handheld meenemen die Tetris speelde of een dynamischer spelsysteem zoals een Gameboy.

De Raspberry Pi Pico is een behoorlijk krachtige microcontroller vergeleken met waar handhelds in de jaren '90 op draaiden. Uiteraard biedt het ons de mogelijkheid om spellen uit die tijd te spelen.

Hoe krachtig is de Raspberry Pi Pico?

Vergeleken met een console uit de jaren '80 is de Raspberry Pi Pico extreem krachtig. 

Als je een spel programmeert dat vergelijkbaar is met de vereisten van een spel uit de jaren tachtig, zal de Raspberry Pi Pico er waarschijnlijk doorheen komen.

In de jaren '90 wordt het wat moeilijker om zo'n duidelijke conclusie te trekken.

Aan de ene kant, als je het ziet als een apparaat waarmee je spelletjes kunt spelen die vergelijkbaar zijn met wat je zou vinden op een Gameboy of een mobiele telefoon, zul je waarschijnlijk tevreden zijn.

Eind jaren '90 werden spellen echter veel zwaarder. Je zult bijvoorbeeld geen Quake 3 (een spel uit 1999) spelen op de Pico.

De Raspberry Pi Pico kan weliswaar Doom (1993) spelen, maar de persoon die het codeerde deed er zes maanden over omdat het een hele klus was om het spel te comprimeren in de 2MB opslagruimte die de Raspberry Pi Pico heeft.

Dus, hoewel de Pico twee 133MHz processoren heeft, heeft hij beperkt RAM en opslag, wat het moeilijk maakt.

Eens kijken hoe het zich verhoudt tot een Gameboy:

Waarom spelletjes spelen op de Pico en niet op de Zero/Pi 4?

Goede vraag.

Zoals je weet is de Raspberry Pi Pico een microcontroller, terwijl de Raspberry Pi Zero of Pi 4 microcomputers zijn.

Beide kunnen spelletjes spelen, maar de Raspberry Pi Pico is veel beperkter.

Dat gezegd hebbende, als je vandaag (in 2022) een emulator of spelsysteem wilt bouwen van de Raspberry Pi Zero of Pi 4s, kun je er maar beter al een hebben, anders is je grootste bottleneck voorraad.

Het is erg moeilijk om een Pi Zero te krijgen en een hele uitdaging om een Pi 4 te krijgen.

Aan de andere kant is de Pico overvloedig. Hij start ook vrijwel onmiddellijk op, terwijl de microcomputer Pis een langdurig opstartproces moet doorlopen.

De Pico gaat ook veel langer mee. Als je een mobiele opstelling wilt die urenlang meegaat en draagbaar is, zit je met de Pico een stuk beter.

Ten slotte is de Pico, naast de voorraad, ook ruim voorradig.

Om eerlijk te zijn tegenover de Pi Zero en Pi 4, kun je met die microcomputers zeker betere spellen spelen en betere emulatieresultaten behalen. Zoals je in de volgende sectie zult zien, heeft de Pico moeite met het spelen van spellen waar de Zero of Pi 4 zich doorheen slaan.

Welke spelletjes kan de Raspberry Pi Pico spelen?

We beginnen met te kijken wat de knutselgemeenschap heeft kunnen spelen op de Raspberry Pi Pico.

RP2040 Doom is het antwoord op "wordt het Doom?".

Ja! De Raspberry Pi Pico kan Doom spelen.

Iemand genaamd Graham Sanderson uit Austin, Texas, is erin geslaagd Doom te porten naar de Raspberry Pi Pico.

Zijn magische formule?

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

Hij legde in zijn documentatie van het proces uit dat hij meerdere beperkingen ondervond van de hardwarespecificaties die de Raspberry Pi Pico had. Het is immers geen apparaat dat bedoeld is voor gaming.

Toch besloot Graham ook om de porting van Doom nog moeilijker te maken. Hij wilde de authentieke ervaring van Doom, wat betekende dat hij een resolutie van 320×200 (kleur), stereogeluid, OPL2-muziek, opslaan en laden, netwerkmultiplayer en andere functies die in het origineel beschikbaar zijn.

Zoveel spel in de Raspberry Pi Pico stoppen betekende uitdagingen met het geheugen. Zowel RAM als opslag waren belangrijke kwesties.

Ten eerste heeft de Raspberry Pi Pico slechts 2MB opslagruimte, maar de shareware versie van Doom is twee keer zo groot. Terwijl andere ontwikkelaars zouden kunnen besluiten om bepaalde functies zoals splash screens en downsampling van texturen te schrappen, wilde Graham dat niet doen.

RAM was ook een probleem: de Chocolate Doom broncode vereist ongeveer 1MB RAM terwijl de Pico slechts ongeveer 264KB heeft. Het geheugen is krap omdat het renderen van de graphics een groot deel van de RAM-ruimte in beslag neemt, maar RAM is ook erg belangrijk voor de soepele werking van het spel. Om beide aspecten te beheren, moest Graham iets doen wat hij "liposuctie" noemde.

U kunt meer lezen door te gaan naar de documentatiekijken zijn YouTube afspeellijst of herziening van de code.

NES emulator

Van de Raspberry Pi Pico is met succes een NES-emulator gemaakt.

In een Emulator Zone Forum thread, gebruiker ropgar zei dat de Raspberry Pi Pico de kracht heeft om een NES te emuleren en het kan 60 frames per seconde en kan APU en PPP perfect emuleren.

Ropgar gebruikt een PS/2-toetsenbord als controller, maar je kunt ook de originele NES-controller gebruiken.

Het geluid is goed en er zijn geen storingen in de video en de achtergrondmuziek.

De Pico heeft ongeveer 1,5MB flash-ruimte over voor verschillende spelletjes, die kunnen worden gekozen door op Caps Lock te drukken om tussen de spelletjes te wisselen. 

De spellen die ropgar op zijn demo kon laden zijn Pacman, Arkanoids, DK, DK Jr, BubbleBobble, Galaga, en vele andere.

Het enige nadeel is dat er geen openbare broncode of handleiding is over hoe dit moet.

Gameboy-emulator voor de Raspberry Pi Pico

Je kunt je eigen Gameboy behuizing maken en dan de Raspberry Pi Pico gebruiken om de Gameboy te emuleren.

Het lastige hier is dat het eigenlijk niet iets is dat veel succes heeft gekend. Met andere woorden, wat je bouwt kan werken, maar niet altijd.

Laten we eens kijken naar de opties die er zijn.

Roest Gameboy emulator (OxidGB Pico Port)

Toen ik de Pokemon afbeelding op het scherm zag, was ik meteen enthousiast.

James Selby schreef echter over de uitdagingen en tekortkomingen van zijn Gameboy-emulator, geschreven in Rust, genaamd OxidGB Pico Port.

"Dit was een rit - een frustrerende rit, maar een rit waarvan ik niettemin grondig heb genoten vanuit educatief oogpunt," zei Selby.

Problemen en overwinningen

Dit is de grootste uitdaging: De Rust Gameboy emulator "is in zijn huidige staat helaas niet echt speelbaar."

Selby zei dat spellen slechts ongeveer 10 FPS halen omdat de code van de emulator een knelpunt is, evenals de trage SPI-interface naar het scherm.

Het is mogelijk de zaken te versnellen, maar dat vergt tijd om te plannen en uit te voeren.

Input is niet geconfigureerd, omdat de spellen niet speelbaar waren. 

Testen van de OxidGB Pico-poort

Als je het wilt proberen, kun je Selby's instructies volgen op zijn Github repo voor de OxidGB Pico Port.

RP2040_GB emulator

Een andere emulator die u kunt proberen is de RP2040_GBdie gebaseerd is op de Pinda-GB emulator.

De prestaties van de RP2040_GB zijn behoorlijk, waarbij Koshkouei zegt dat zijn opstelling "draait met meer dan 70 fps zonder audio-emulatie. Met frame skip en interlacing kan hij tot 120 fps halen."

Zoals je kunt zien, speelt de RP2040_GB Pokemon. De stappen om een ROM op de RP2040 te krijgen zijn als volgt:

• U moet de Pico SDK hebben
• Converteer .gb of .gbc ROM naar een C header bestand met behulp van de xxd programma
• Wijzig het geconverteerde bestand door twee regels code toe te voegen (in de Github readme)
• Kopieer ROM naar de src map en compileren.

Er zijn enkele beperkingen van deze emulator:

• "Deze emulator is onnauwkeurig en is een werk in uitvoering ... sommige spellen kunnen verkeerd of helemaal niet draaien." 
• Gameboy Color spellen geven een foutmelding
• Niet geoptimaliseerd voor microcontroller: Koshkouei suggereerde dat "het gebruik van een APU die geoptimaliseerd is voor ruimte en snelheid" kan helpen.

Zie de Github repo van de RP2040_GB hier.

Mega Spelletjes Compilatie met Raspberry Pi Pico

Het beste aan dit project is dat het eenvoudig is en dat de instructies voldoende zijn om snel met een Raspberry Pi Pico spelcomputer aan de slag te gaan.

Roger Bühler heeft onderdelen, instructies en demo's opgenomen op zijn Github.

De Mega Games Compilation komt met de volgende spellen:

1. Tiny Gilbert
2. Kleine truc
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. Kleine Bert 1.1
9. Kleine Arkanoid v2
10. Kleine Tris v2.1e
11. Kleine plaquette
12. Tiny DDug
13. Tiny Missile v1.1
14. Tiny Lander v1.0 ( door Roger Buehler )
15. Kleine Morpion
16. Kleine pijp

Je hebt de volgende onderdelen nodig:

1. Raspberry Pi Pico
2. SSD1309 128x64px SPI OLED display (2,42" display in 2:1 verhouding)
3. Piëzo zoemer
4. Vijf knoppen
5. Breadboard
6. Startkabels
7. Optioneel: 10 ohm weerstanden, elektrolytische condensator van minstens 10V en 220uF.

Je hebt ook nodig Adafruit's SSD1306 bibliotheek.

Zo sluit je het scherm aan:

• GND -> Display GND 
• 3V3(OUT) -> Display VCC 
• GP16 -> Display DC (Data Command) 
• GP17 -> Weergave CS (Kanaalkeuze) 
• GP18 -> Display SCL (Klok) 
• GP19 -> Display SDA (MOSI) 
• GP20 -> Display RES (Reset)

En om de knoppen aan te sluiten:

• GP15 -> knop UP 
• GP14 -> knop DOWN 
• GP13 -> knop LINKS 
• GP12 -> knop RECHTS 
• GP11 -> knop BRAND (alle knoppen naar GND)

En om de piëzo zoemer aan te sluiten:

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

Software installatie:

Om de software te installeren moet je de Arduino IDE gebruiken.

Tamagotchi-achtig spel op de Raspberry Pi Pico (Pico-Tamachibi)

Waarom heet het Pico-Tamachibi?

Volgens Kevin McAleer, de maker van dit apparaat, betekent "tama" "ei" en verwijst "chibi" naar afbeeldingen waarbij het personage een groot hoofd heeft. 

Het maken van de Tamachibi is eenvoudig omdat Kevin in zijn 90 minuten durende handleiding elke stap doorneemt.

Bouw je eigen spelcomputer

Als je je eigen Raspberry Pi Pico spelcomputer wilt maken, zijn er twee algemene manieren waarop je dat kunt doen: een kant-en-klaar bouwpakket kopen of er zelf een bouwen.

Kant-en-klare kit vs DIY Raspberry Pi Pico gaming hardware

Hoewel het mogelijk is om vanaf nul te beginnen, wilt u misschien het gedoe van het opbouwen van uw eigen systeem overslaan en gewoon een kant-en-klaar pakket kopen.

Er zijn een paar op de RP2040 gebaseerde kits waarmee je meteen kunt beginnen met het spelen of ontwikkelen van je eigen spellen.

Laten we eens kijken naar het Pimoroni Picosysteem en het dan vergelijken met het proces om iets soortgelijks te bouwen met losse onderdelen.

Pimoroni Picosysteem

Laten we eens kijken naar het Pimoroni Picosysteem.

Zoals je ziet is hij veel groter dan de Raspberry Pi Pico W, maar dat komt ook omdat hij onder meer een vierweg D-pad, vier knoppen, een LCD-scherm, een lithium-ion batterij, een piëzospeaker en een USB-C poort heeft.

Hij heeft dezelfde processor en RAM, want zowel het Picosysteem als de Pico gebruiken de RP2040-chip. Hier zijn de volledige specificaties:

• Aangedreven door RP2040 (Dual Arm Cortex M0+ met 264kB SRAM)
• 16MB QSPI flash met ondersteuning voor XiP
• 1,54″ SPI IPS-kleurenscherm (240×240 en 120×120)
• D-pad en knoppen
• 525mAh LiPo batterij (6 uur+)
• Piezo zoemer/luidspreker
• Aan/uit-knop
• RGB LED
• Programmeerbaar en oplaadbaar via USB-C (kabel niet inbegrepen)

Grafische modi

PicoSystem ondersteunt twee grafische modi.

• 240×240: de native resolutie van het LCD-scherm
• 120×120: pixel verdubbeld modus (bespaart RAM)

Hoe ziet gamen op het Picosysteem eruit?

Gamen op de Picosystem is eenvoudig. Druk gewoon op de aan/uit-knop en je wordt getrakteerd op het voorgeïnstalleerde spel Super Square Bros.

Het spel is een eenvoudig platformspel, net als Mario.

Pimoroni heeft ook andere spellen opgenomen:

• Super Square Bros. door Scorpion Games - Een stuiterende vierzijdige platformer (voorgeïnstalleerd spel)
• Stippen - Dot popping puzzel. Maak ketens van twee of meer en race om de grootste score.
• Stenen en diamanten - Klassiek spel van rotsen ontwijken en diamanten pakken.
• Geometrie - Verpletter ruimtekeien met lasers om kleinere ruimtekeien te maken!
• Rainbow Ascent - De Dark Souls van procedureel gegenereerde verticale springpuzzels. Veel geluk.
• Super Blit Kart door Daft_Freak - Een op "Mode7" gebaseerd racespel.

Om deze spelletjes te installeren, doe je het volgende:

• Download het bestand.
• Sluit uw Picosystem aan op de PC
• Houd de X-toets ingedrukt en druk op de aan/uit-toets.
• Het Picosysteem moet worden gemount als een station met de naam RPI-RP2
• Kopieer het gedownloade .uf2 bestand naar het station. Het zal automatisch laden.

Om de een of andere reden werkte mijn USB-C naar USB-C kabel niet, maar de USB-A naar USB-C kabel werkte wel met het Picosysteem. Als u de rode LED niet ziet oplichten, probeer dan een andere kabel.

Programmeer je eigen spelletjes

Het beste aan het Picosysteem is dat het een systeem biedt waarmee je je eigen spellen kunt maken.

PicoSystem komt met een speciale API die u kan helpen bij het maken van uw spellen.

Het neemt ook veel van het vervelende werk weg dat nodig is om afzonderlijke onderdelen te kopen, zoals een LCD-scherm, knoppen, jumperdraden, breadboard en dan het uitzoeken van de bibliotheken en pakketten die nodig zijn om dit alles werkend te krijgen.

De API van het PicoSystem heeft functies voor het tekenen van dingen op het scherm, het uitvoeren van audio, hardwarefuncties en andere nutsfuncties. Dit maakt het makkelijker voor u om uw spel te bouwen.

Net als de Raspberry Pi Pico kan het PicoSystem worden gecodeerd in C++ of MicroPython. 

Is het makkelijk om een spel te programmeren met het Picosysteem?

Ik raad je aan wat tijd en geduld te hebben om je eigen spel te bouwen met het Picosysteem.

De documentatie biedt de basis om je op weg te helpen, maar het is het beste als je enige voorkennis hebt van het programmeren van spellen.

De grootste uitdaging voor beginners is dat er niet veel bronnen zijn die je leren hoe je voorbeeldprojecten moet coderen. Hier is echter een lijst met referenties die je kunnen helpen:

Picosystem MicroPython gids (in readme)

Picosystem MicroPython voorbeelden

Picosystem C++ Github

Picosysteem C++ voorbeelden

Picosystem API cheatsheet, plus afbeelding, font converter (op zijbalk)

DIY systeem: Het maken van de hardware

YouMakeTech's gids laat de lezer zien hoe je een complete spelcomputer maakt met een behuizing, een geluidssysteem en permanent solderen.

Laten we ter vergelijking eens kijken hoeveel het kost om een doe-het-zelf toestel te bouwen tegenover het Picosystem, dat een compleet bouwpakket is.

Laten we eens kijken naar de uiteindelijke kosten voor verschillende niveaus van doe-het-zelf-opstellingen:

Even een voorbehoud - YouMakeTech zegt dat je dit voor minder dan $20 kunt bouwen. Uit mijn onderzoek blijkt echter dat de kosten voor een doe-het-zelf set-up die overeenkomt met het Picosysteem niet echt veel verschillen, vooral als je de software en het gemak in aanmerking neemt.

Dat gezegd hebbende, de doe-het-zelf route is een geweldige leermogelijkheid. Eén ding dat me uitdaagde was het scherm. Terwijl het voorbeeld van YouMakeTech een I2C-verbinding gebruikt, gebruikte het scherm dat ik had een 4-pins SPI-interface. Dat vereist ofwel een andere codering of een aanpassing van de hardware om verder te gaan. Als je van uitdagingen houdt, is de DIY-route iets voor jou.

Dus, wat zijn de voordelen van zelfbouw versus het Picosysteem?

Het maken van het Pong-achtige spel op het Picosystem vs DIY systeem

Een merkwaardig experiment van mij is om te begrijpen hoeveel moeite het kost om een spel te ontwikkelen met behulp van het Picosysteem versus het vanaf nul te doen.

Om de twee systemen te vergelijken zal ik een Pong-achtig spel voor één speler bouwen op zowel het doe-het-zelf systeem van YouMakeTech als op het Picosysteem.

Het uitgangspunt van het spel is eenvoudig. Het is een Pong-achtig spel voor één speler dat je 10 punten geeft telkens als je bal van de peddel stuitert. Als hij op de bodem van het scherm valt, krijg je een "Game Over" bericht.

Het maken van het spel op beide systemen volgt een eenvoudige workflow die allemaal naar Thonny leidt.

Je moet MicroPython flashen op de Pico en dan gebruik je Thonny om je programma te coderen. 

De MicroPython die u op het Picosystem zou flashen is anders dan het officiële MicroPython UF2-bestand, dus zorg ervoor dat u de juiste flasht, want het Picosystem zal draaien op de officiële MicroPython-uitgave. Het werkt alleen niet zoals bedoeld.

Laten we nu eens kijken naar enkele fundamentele verschillen tussen de twee. Ik laat de spellogica hier buiten beschouwing en vergelijk alleen de verschillen in hardware-software interactie en programmeerpatronen.

U kunt de code van YouMakeTech hier bekijken.

Eerste verschil: hardwarecode

Dingen zijn erg "ruw" met de DIY route. Hier is wat code om het display, GPIO en knoppen te initialiseren die je met het Picosysteem niet hoeft te doen:

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)

Tweede verschil: Picosystem's API

Als je code schrijft op het Picosysteem, moet je binnen zijn systeem schrijven.

In het voorbeeld van YouMakeTech is alle spellogica ingekapseld in een terwijl True lus. Dit omvat knopinteractie, botsingsdetectie en tekenen op het scherm.

In het Picosysteem moet je binnen drie functies schrijven - init(), update() en tekenen().

In mijn code is alle logica van het spel geschreven in update() inclusief botsingsbehandeling en D-pad interactie.

In een eenvoudig Pong-spel zijn er een paar functies van de API die ik heb gebruikt om de dingen wat gemakkelijker te maken:

snijdt(x1, y1, w1, h1, x2, y2, w2, h2)  is waarschijnlijk de grootste hulp hier. Je geeft de coördinaten en afmetingen van de twee rechthoeken door, en het resultaat is waar als er een snijpunt is. In dit geval zijn de twee rechthoeken de bal en de balk (ook wel peddel genoemd). De tekortkoming van de intersects() functie is dat deze niet detecteert aan welke kant de botsing plaatsvond, dus moest ik extra code schrijven om botsingen aan de kant van de staaf af te handelen.

De API van het Picosysteem zal echt schitteren als je ingewikkelder spellen ontwikkelt, aangezien het al een methode heeft voor framebuffers, audio-uitvoer, blending, enz. 

Code voor Pimoroni Picosysteem Pong-achtig spel

#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()

Heb je een spel om aan te bevelen?

Als je een spel hebt voor de Raspberry Pi Pico, laat dan hieronder een reactie achter met een URL.

En als je onze Paragon Projects-serie wilt bekijken - ga dan naar hier.