Giochi su Raspberry Pi Pico

In questo post voglio parlare del gioco su Raspberry Pi Pico.

Ricordo il mio primo dumbphone, che all'epoca si chiamava "telefono". Poteva giocare a giochi semplici come Snake. Era all'avanguardia.

Prima di allora, era necessario portare con sé una console portatile separata che riproducesse Tetris o un sistema di gioco più dinamico come il Gameboy.

Il Raspberry Pi Pico è un microcontrollore piuttosto potente se paragonato ai palmari degli anni Novanta. Naturalmente, ci offre la possibilità di giocare a giochi di quell'epoca.

Quanto è potente il Raspberry Pi Pico

Rispetto a una console degli anni '80, il Raspberry Pi Pico è estremamente potente. 

Se si programma un gioco simile ai requisiti di risorse di un gioco degli anni '80, il Raspberry Pi Pico probabilmente lo supererà senza problemi.

È negli anni '90 che diventa un po' più difficile affermare una conclusione così netta.

Da un lato, se si pensa che si tratta di un dispositivo in grado di riprodurre giochi simili a quelli che si possono trovare su un Gameboy o su un telefono cellulare, probabilmente si rimarrà soddisfatti.

Tuttavia, alla fine degli anni '90 i giochi sono diventati molto più impegnativi. Ad esempio, non potrete giocare a Quake 3 (un gioco del 1999) sul Pico.

In realtà, il Raspberry Pi Pico è in grado di riprodurre Doom (1993), ma è stato un lavoro di sei mesi per la persona che lo ha codificato, perché è stato un compito piuttosto difficile comprimere il gioco nei 2 MB di memoria del Raspberry Pi Pico.

Quindi, pur disponendo di due processori a 133 MHz, il Pico ha una RAM e una memoria limitate, che lo rendono difficile da gestire.

Vediamo come si comporta rispetto a un Gameboy:

Perché giocare con il Pico e non con lo Zero/Pi 4?

Bella domanda.

Come sapete, Raspberry Pi Pico è un microcontrollore, mentre Raspberry Pi Zero o Pi 4 sono microcomputer.

Entrambi possono giocare, ma il Raspberry Pi Pico è molto più limitato.

Detto questo, se voleste costruire un emulatore o un sistema di gioco a partire dal Raspberry Pi Zero o dal Pi 4s oggi (nel 2022), fareste meglio ad averne già uno, altrimenti il vostro più grande collo di bottiglia saranno le scorte.

È molto difficile ottenere un Pi Zero e piuttosto impegnativo ottenere un Pi 4.

D'altra parte, il Pico è abbondante. Inoltre si avvia quasi immediatamente, mentre il microcomputer Pis deve affrontare un lungo processo di avvio.

Inoltre, il Pico dura molto di più. Se volete un'installazione mobile che funzioni per ore e sia portatile, farete molto meglio con il Pico.

Infine, oltre alle scorte, anche il Pico è abbondantemente disponibile.

Per essere onesti con il Pi Zero e il Pi 4, con questi microcomputer è possibile giocare a giochi migliori e ottenere risultati di emulazione migliori. Come si vedrà nella prossima sezione, il Pico fatica a riprodurre i giochi che il Pi Zero o il Pi 4 sono in grado di riprodurre senza problemi.

A quali giochi può giocare il Raspberry Pi Pico?

Cominciamo a vedere cosa è riuscito a fare la comunità di tinkering con il Raspberry Pi Pico.

RP2040 Doom è la risposta a "sarà Doom?".

Sì! Il Raspberry Pi Pico può giocare a Doom.

Un ragazzo di nome Graham Sanderson di Austin, Texas, è riuscito a portare Doom sul Raspberry Pi Pico.

La sua formula magica?

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

Lui ha spiegato nella sua documentazione del processo che ha dovuto affrontare diverse restrizioni dovute alle specifiche hardware del Raspberry Pi Pico. Dopo tutto, non si tratta di un dispositivo destinato al gioco.

Ciononostante, Graham decise di rendere il porting di Doom ancora più difficile. Voleva l'esperienza autentica di Doom, il che significava avere una risoluzione di 320×200 (a colori), audio stereo, musica OPL2, salvataggi e caricamenti, multiplayer in rete e altre caratteristiche disponibili nel nome originale.

L'inserimento di così tanti giochi nel Raspberry Pi Pico ha comportato problemi di memoria. Sia la RAM che lo spazio di archiviazione erano problemi fondamentali.

In primo luogo, il Raspberry Pi Pico ha solo 2 MB di memoria, ma la versione shareware di Doom ha una dimensione doppia. Mentre altri sviluppatori potrebbero decidere di tagliare alcune caratteristiche come gli splash screen e il downsampling delle texture, Graham non ha voluto farlo.

Anche la RAM era un altro problema: il codice sorgente di Chocolate Doom richiedeva circa 1 MB di RAM, mentre il Pico ne aveva solo 264 KB. La memoria è limitata perché il rendering della grafica occupa un'enorme fetta di spazio nella RAM, ma la RAM è anche molto importante per il buon funzionamento del gioco. Per gestire entrambi gli aspetti, Graham ha dovuto effettuare quella che ha chiamato "liposuzione".

Per saperne di più, visitate il sito la documentazione, guardando la sua playlist su YouTube o revisione del codice.

Emulatore NES

Il Raspberry Pi Pico è stato trasformato con successo in un emulatore NES.

In un thread del forum Emulator ZoneL'utente ropgar ha dichiarato che il Raspberry Pi Pico ha la potenza necessaria per emulare un NES e può raggiungere i 60 fotogrammi al secondo e può emulare perfettamente APU e PPP.

Ropgar utilizza una tastiera PS/2 come controller, ma è possibile utilizzare anche il controller originale del NES.

L'audio è buono e non ci sono problemi con i video e la musica di sottofondo.

Il Pico dispone di circa 1,5 MB di spazio flash per diversi giochi, che possono essere scelti premendo il tasto Caps Lock per passare da un gioco all'altro. 

I giochi che ropgar è riuscito a caricare sulla sua demo sono Pacman, Arkanoids, DK, DK Jr, BubbleBobble, Galaga e molti altri.

L'unico inconveniente è che non esiste un codice sorgente pubblico o un tutorial su come farlo.

Emulatore di Gameboy per Raspberry Pi Pico

È possibile realizzare il proprio case per il Gameboy e poi utilizzare Raspberry Pi Pico per emulare il Gameboy.

La parte difficile è che non si tratta di una soluzione che ha avuto un grande successo. In altre parole, quello che costruite potrebbe funzionare, ma non sempre.

Diamo un'occhiata alle opzioni disponibili.

Emulatore di Rust Gameboy (porta OxidGB Pico)

Quando ho visto l'immagine dei Pokemon sullo schermo, mi sono subito emozionato.

Tuttavia, James Selby ha scritto delle sfide e dei difetti del suo emulatore di Gameboy, scritto in Rust, chiamato OxidGB Pico Port.

"È stata una corsa, una corsa frustrante, ma che mi è piaciuta molto dal punto di vista educativo", ha detto Selby.

Problemi e vittorie

Ecco la sfida principale: L'emulatore Rust Gameboy "non è esattamente giocabile nel suo stato attuale, purtroppo".

Selby ha detto che i giochi raggiungono solo circa 10 FPS perché il codice dell'emulatore è un collo di bottiglia, oltre alla lentezza dell'interfaccia SPI con il display.

È possibile accelerare le cose, ma ciò richiede tempo per la pianificazione e l'implementazione.

L'input non è stato configurato, poiché i giochi non erano giocabili. 

Test della porta Pico di OxidGB

Se volete provare, potete seguire le istruzioni di Selby sul suo sito web Repository Github per la porta Pico di OxidGB.

Emulatore RP2040_GB

Un altro emulatore che si può provare è il RP2040_GB, che si basa sulla Arachide-GB emulatore.

Le prestazioni dell'RP2040_GB sono discrete e Koshkouei afferma che la sua configurazione "funziona a più di 70 fps senza emulazione audio. Con il frame skip e l'interlacciamento, può raggiungere i 120 fps".

Come si può vedere, l'RP2040_GB sta giocando a Pokemon. I passaggi per inserire una ROM nell'RP2040 sono i seguenti:

• È necessario disporre dell'SDK Pico
• Convertire .gb o .gbc ROM a un file di intestazione C utilizzando l'opzione xxd programma
• Modificare il file convertito aggiungendo due righe di codice (nel readme di Github)
• Copiare la ROM nel src e compilare.

Questo emulatore presenta alcune limitazioni:

• "Questo emulatore è impreciso ed è un lavoro in corso... alcuni giochi potrebbero funzionare in modo non corretto o non funzionare affatto". 
• I giochi per Gameboy Color generano un errore
• Non ottimizzato per il microcontrollore: Koshkouei ha suggerito che "l'utilizzo di un'APU ottimizzata per spazio e velocità" può essere utile.

Vedere il repo Github di RP2040_GB qui.

Compilazione di mega giochi con Raspberry Pi Pico

La parte migliore di questo progetto è che è semplice e le istruzioni sono adeguate per iniziare rapidamente a creare una console di gioco Raspberry Pi Pico.

Roger Bühler ha incluso parti, istruzioni e dimostrazioni nel suo Github.

La Mega Games Compilation contiene i seguenti giochi:

1. Tiny Gilbert
2. Piccolo trucco
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. Tris piccolo v2.1e
11. Targa minuscola
12. Piccolo DDug
13. Tiny Missile v1.1
14. Tiny Lander v1.0 ( da Roger Buehler )
15. Piccolo Morpione
16. Tubo piccolo

Le parti necessarie sono le seguenti:

1. Raspberry Pi Pico
2. Display OLED SSD1309 128x64px SPI (display da 2,42" con rapporto 2:1)
3. Cicalino piezoelettrico
4. Cinque pulsanti
5. Lavagna per pane
6. Cavi di emergenza
7. Opzionale: resistenze da 10 ohm, condensatore elettrolitico da almeno 10 V e 220uF

È inoltre necessario Libreria SSD1306 di Adafruit.

Ecco come collegare il display:

• GND -> GND del display 
• 3V3(OUT) -> Display VCC 
• GP16 -> Visualizzazione DC (comando dati) 
• GP17 -> Visualizzazione CS (Selezione canale) 
• GP18 -> Display SCL (orologio) 
• GP19 -> Display SDA (MOSI) 
• GP20 -> Display RES (Reset)

E per collegare i pulsanti:

• GP15 -> pulsante SU 
• GP14 -> pulsante DOWN 
• GP13 -> pulsante SINISTRA 
• GP12 -> pulsante DESTRA 
• GP11 -> pulsante FIRE (tutti i pulsanti su GND)

E per collegare il cicalino piezoelettrico:

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

Installazione del software:

Per installare il software, è necessario utilizzare l'IDE Arduino.

Gioco simile al Tamagotchi su Raspberry Pi Pico (Pico-Tamachibi)

Perché si chiama Pico-Tamachibi?

Secondo Kevin McAleer, il creatore di questo dispositivo, "tama" significa "uovo" e "chibi" si riferisce alla grafica in cui il personaggio ha una grande testa. 

Creare il Tamachibi è facile perché Kevin illustra ogni fase del processo nel suo tutorial di 90 minuti.

Costruite la vostra macchina da gioco

Se volete creare la vostra macchina da gioco Raspberry Pi Pico, ci sono due modi generali per farlo: acquistare un kit già pronto o costruirlo da soli.

Kit pronti per l'uso e hardware di gioco Raspberry Pi Pico fai da te

Sebbene sia possibile partire da zero, è preferibile evitare la fatica di costruire il proprio sistema e acquistare un pacchetto già pronto.

Esistono alcuni kit basati sull'RP2040 che consentono di passare direttamente alla riproduzione o allo sviluppo dei propri giochi.

Vediamo il Picosistema Pimoroni e poi confrontiamolo con il processo di costruzione di qualcosa di simile utilizzando i singoli pezzi.

Pimoroni Picosystem

Diamo un'occhiata al Picosistema Pimoroni.

Come si può vedere, è molto più grande del Raspberry Pi Pico W, ma questo anche perché ha un D-pad a quattro vie, quattro pulsanti, uno schermo LCD, una batteria agli ioni di litio, un altoparlante piezoelettrico e una porta USB-C, tra le altre aggiunte.

Ha lo stesso processore e la stessa RAM, poiché sia il Picosystem che il Pico utilizzano il chip RP2040. Ecco le specifiche complete:

• Alimentato da RP2040 (Dual Arm Cortex M0+ con 264kB di SRAM)
• 16 MB di flash QSPI con supporto XiP
• LCD SPI IPS da 1,54″ a colori (modalità 240×240 e 120×120)
• D-pad e pulsanti
• Batteria LiPo da 525 mAh (6 ore e più)
• Cicalino piezoelettrico/altoparlante
• Pulsante di accensione/spegnimento
• LED RGB
• Programmabile e ricaricabile tramite USB-C (cavo non incluso)

Modalità grafiche

PicoSystem supporta due modalità grafiche.

• 240×240: la risoluzione nativa dell'LCD
• 120×120: modalità pixel raddoppiati (risparmia RAM)

Come si presenta il gioco sul Picosystem?

Giocare con il Picosystem è facile. Basta premere il pulsante di accensione per accedere al gioco precaricato Super Square Bros.

Il gioco è un semplice platform simile a Mario.

Pimoroni ha incluso anche altri giochi:

• Super Square Bros. di Scorpion Games - Un platform a quadrilateri rimbalzante (gioco precaricato)
• Puntini - Rompicapo con i puntini. Create catene di due o più punti e gareggiate per ottenere il punteggio più alto.
• Rocce e diamanti - Classico gioco di schivare le rocce e afferrare i diamanti.
• Geometria - Distruggi i massi spaziali con i laser per creare massi spaziali più piccoli!
• Salita arcobaleno - Il Dark Souls dei puzzle a salto verticale generati proceduralmente. Buona fortuna.
• Super Blit Kart di Daft_Freak - Un gioco di corse basato su "Mode7".

Per installare questi giochi, procedere come segue:

• Scaricare il file.
• Collegare il Picosystem al PC
• Tenere premuto il tasto X e premere il tasto di accensione.
• Il Picosystem deve essere montato come unità chiamata RPI-RP2.
• Copiare il file .uf2 scaricato sull'unità. Verrà caricato automaticamente.

Per qualche motivo, il mio cavo da USB-C a USB-C non ha funzionato, ma il cavo da USB-A a USB-C ha funzionato con Picosystem. Se il LED rosso non si accende, provare con un altro cavo.

Programmare i propri giochi

La parte migliore di Picosystem è che fornisce un sistema per creare i propri giochi.

Piuttosto che codificare da zero, PicoSystem viene fornito con una speciale API che può aiutarvi a creare i vostri giochi.

Inoltre, elimina gran parte del noioso lavoro necessario per acquistare i singoli componenti, come lo schermo LCD, i pulsanti, i fili dei ponticelli, la breadboard e poi per capire le librerie e i pacchetti necessari per far funzionare tutti questi componenti.

L'API di PicoSystem contiene funzioni per disegnare sullo schermo, per emettere audio, funzioni hardware e altre funzioni di utilità. In questo modo è più facile costruire il proprio gioco.

Proprio come il Raspberry Pi Pico, il PicoSystem può essere codificato in C++ o MicroPython. 

È facile programmare un gioco con il Picosystem?

Vi consiglio di avere un po' di tempo e di pazienza per costruire il vostro gioco con il Picosystem.

La documentazione offre le nozioni di base per iniziare, ma sarebbe meglio se si avesse una conoscenza preliminare della programmazione dei giochi.

La sfida più grande per i principianti è che non ci sono molte risorse che insegnano a codificare progetti di esempio. Tuttavia, ecco un elenco di riferimenti che vi aiuteranno:

Guida Picosystem MicroPython (in readme)

Esempi di Picosystem MicroPython

Picosystem C++ Github

Esempi di Picosystem C++

Picosystem API cheatsheet, oltre al convertitore di immagini e font (sulla barra laterale)

Sistema fai da te: Creare l'hardware

La guida di YouMakeTech Il libro illustra al lettore come realizzare una console di gioco completa di custodia, sistema audio e saldature permanenti.

Per il nostro confronto, vediamo quanto costerebbe costruire un'unità fai-da-te rispetto al Picosystem, che è un kit completo.

Vediamo quindi i costi finali per i diversi livelli di configurazione fai-da-te:

Solo un'avvertenza: YouMakeTech dice che è possibile costruirlo per meno di $20. Dalle mie ricerche, tuttavia, i costi per una configurazione fai-da-te che corrisponda al Picosystem non differiscono molto, soprattutto se si considerano il software e la convenienza.

Detto questo, il fai-da-te è una grande opportunità di apprendimento. Un aspetto che mi ha messo in difficoltà è stato lo schermo. Mentre l'esempio di YouMakeTech utilizza una connessione I2C, lo schermo che avevo io utilizzava un'interfaccia SPI a 4 pin. Questo richiede un cambiamento nella codifica o una modifica all'hardware per poter procedere. Se vi piacciono le sfide, la strada del fai-da-te fa per voi.

Quali sono i vantaggi del fai-da-te rispetto al Picosystem?

Creazione del gioco simile a Pong sul sistema Picosystem contro il fai-da-te

Un mio curioso esperimento consiste nel capire quanto impegno richieda sviluppare un gioco utilizzando il Picosystem rispetto a farlo da zero.

Per confrontare i due sistemi, costruirò un gioco simile a Pong per un solo giocatore sia sul sistema fai-da-te di YouMakeTech che su Picosystem.

La premessa del gioco è semplice. È un gioco simile a Pong per un solo giocatore che assegna 10 punti ogni volta che la palla rimbalza sulla paletta. Se la palla cade sul fondo dello schermo, si riceve il messaggio "Game Over".

La creazione del gioco su entrambi i sistemi segue un semplice flusso di lavoro che porta a Thonny.

È necessario flashare MicroPython sul Pico e poi utilizzare Thonny per codificare il programma. 

Il MicroPython da flashare sul Picosystem è diverso dal file ufficiale MicroPython UF2, quindi assicuratevi di aver flashato quello giusto perché il Picosystem funzionerà con la versione ufficiale di MicroPython. Solo che non funzionerà come previsto.

Esaminiamo ora alcune differenze fondamentali tra i due. Escludo la logica di gioco e mi limito a confrontare le differenze nell'interazione hardware-software e nei modelli di programmazione.

Potete vedere il codice di YouMakeTech qui.

Prima differenza: codice hardware

Le cose sono molto "grezze" con la strada dell'autocostruzione. Ecco un po' di codice per inizializzare il display, il GPIO e i pulsanti che non è necessario fare con il 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)

Seconda differenza: API di Picosystem

Se state scrivendo codice sul Picosystem, dovrete scrivere all'interno del suo sistema.

Nell'esempio di YouMakeTech, tutta la logica di gioco è incapsulata all'interno di un file mentre Vero loop. Questo include l'interazione con i pulsanti, il rilevamento delle collisioni e il disegno sullo schermo.

Nel Picosystem, si richiede di scrivere all'interno di tre funzioni. init(), update() e disegnare().

Nel mio codice, tutta la logica del gioco è scritta in aggiornamento() compresa la gestione delle collisioni e l'interazione con il D-pad.

In un semplice gioco di Pong, sono state utilizzate alcune funzioni dell'API che hanno reso le cose un po' più semplici:

interseca(x1, y1, w1, h1, x2, y2, w2, h2)  è probabilmente il più grande aiuto in questo caso. Si passano le coordinate e le dimensioni dei due quadrati e il risultato è vero se c'è un'intersezione. In questo caso, i due rettangoli sono la palla e la barra (alias paletta). Il difetto della funzione intersects() è che non rileva il lato in cui avviene la collisione, quindi ho dovuto scrivere del codice aggiuntivo per gestire le collisioni sul lato della barra.

L'API di Picosystem si farà notare quando si svilupperanno giochi più complicati, dato che dispone già di un metodo per i framebuffer, l'uscita audio, il blending, ecc. 

Codice per il gioco simile a Pimoroni Picosystem Pong

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

Avete un gioco da consigliare?

Se avete un gioco per Raspberry Pi Pico, lasciate un commento qui sotto con un URL.

E se volete dare un'occhiata alla nostra serie di Progetti Paragon, andate qui.