Giochi su Raspberry Pi Pico

giochi 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:

SpecRaspberry Pi PicoGameboy (1989)Gameboy Color (1998)
DisplayLCD a colori o e-ink, dipende dalla vostra immaginazione.4 tonalità di grigio10, 32, 56 colori
RisoluzioneDipende dal display, ma è limitato dalle risorse di Pico.160x144px160×144 px
CPU133MHz dual core4MHz4MHz/8MHz
RAM264KB8KB32KB RAM, 16KB VRAM
Stoccaggio2MB Cartuccia Game Pak: 8MB ROM, 128KB RAMCartuccia Game Pak: 8MB ROM, 128KB RAM

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)

Immagine di u/j_selby (Reddit)

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

Hardware e configurazione dell'emulatore RP2040_GB, foto di Mahyar Koshkouei.

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.

Il sistema di gioco di YMTPimoroni Picosystem
CasoOpzionale, stampato in 3D ($4,47 per i progetti STL, più filamento e costi di noleggio/operazione della stampante 3D)Incluso
Raspberry Pi Pico$5 per Pico H perché sono necessari i connettori.Incluso
Display OLED$15 (display da 0,96 pollici)Incluso
PulsantiTrascurabileIncluso
Lavagna per pane$15 (kit breadboard)Incluso
Fili di ponticelloIncluso nel kit di breadboardIncluso
VitiFino a $1Incluso
PiezoTrascurabile Incluso
Costo totale$40,47, esclusi i costi di stampa 3D$70

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

ImpostazioneCosti
Nessuna batteria$40,47 esclusi i costi di stampa 3D
Batteria Lipo$8
Pimoroni Pico Lipo$16,39 - $4 (dato che stiamo usando il sostituto del Pimoroni Pico, possiamo dedurre il costo del Raspberry Pi Pico)
Totale per un kit a batteria$60,86 escluse le spese di stampa 3D

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.

Il prototipo di YouMakeTech che ha due pulsanti, uno schermo e può giocare a Pong

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?

Pro e controFAI DA TEPicosistema
Montaggio dell'hardwareFai tutto da teNon si fa nulla da soli
SoftwareNon c'è molto aiuto qui. È necessario autocostruirsi tutto e imparare a far funzionare ogni componente.È necessario imparare l'API di Picosystem
Opportunità di apprendimentoOpportunità di apprendimento più ampia perché si mettono insieme parti disparatePiù piccolo. È già pronto e il software sarà la più grande opportunità di apprendimento.
EstensibilitàDal momento che l'avete costruito voi, potete modificare lo schermo LCD, aggiungere altri pulsanti, aggiungere LED, ecc.Non molto, a meno che non si voglia smontare un sistema completo.

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:

da machine importare Pin, PWM, I2C,
da ssd1306 importare SSD1306_I2C
...
Pulsanti #
su = Pin(2, Pin.IN, Pin.PULL_UP)
giù = Pin(3, Pin.IN, Pin.PULL_UP)
sinistra = Pin(4, Pin.IN, Pin.PULL_UP)
destra = Pin(5, Pin.IN, Pin.PULL_UP)
pulsante1 = Pin(6, Pin.IN, Pin.PULL_UP)
pulsante2 = Pin(7, Pin.IN, Pin.PULL_UP)

Cicalino # collegato a GP18
cicalino = PWM(Pin(18))

Schermo OLED # collegato a GP14 (SDA) e 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 = pixel da sinistra, ad esempio 0 da sinistra
bar_pos_x = 50
#bar_pos_y = pixel dall'alto, ad esempio 100px dall'alto
bar_pos_y = 100
LARGHEZZA DELLA BARRA = 30

LUNGHEZZA_COSTANTE = 5

velocità della palla = 1
posizione_palla_x = 10
posizione_palla_y = 10
ball_dx = 2
ball_dy = 2

punteggio = 0
game_over = falso

def update(tick):
    
    global bar_pos_x
    globale bar_pos_y
    globale ball_pos_x
    globale ball_pos_y
    globale ball_dx
    globale ball_dy
    globale ball_speed
    punteggio globale
    globale game_over
    
    def reverse_ball_dx():
        global ball_dx
        palla_dx = palla_dx * -1
        
    def reverse_ball_dy():
        globale ball_dy
        ball_dy = ball_dy * -1
    
    ball_pos_x += ball_dx
    ball_pos_y += ball_dy
    
    se pulsante(SINISTRA) e bar_pos_x > 0:
        bar_pos_x -= 1
    
    se pulsante(DESTRA) e bar_pos_x < 120 - BAR_WIDTH :
        bar_pos_x += 1
        
    se ball_pos_x = 120 - LENGTH_CONSTANT :
        ball_pos_x = 120 - LUNGHEZZA_CONSTANTE
        invertire_palla_dx()
        
    se ball_pos_y >= 120 - LENGTH_CONSTANT :
        game_over = Vero
        
    se ball_pos_y <= 0:
        ball_pos_y = 0
        reverse_ball_dy()
        
    se interseca(bar_pos_x,bar_pos_y,BAR_WIDTH,LENGTH_CONSTANT, ball_pos_x, ball_pos_y, LENGTH_CONSTANT,LENGTH_CONSTANT):
        
        reverse_ball_dy()
        punteggio += 10
        
        #ermina l'intersezione tra palla e barra. se si intersecano, controlla se si intersecano sui lati.
        1TP4Se non si intersecano sui lati (cioè in alto) invertire la direzione Y. Altrimenti, invertire la direzione X.
        se interseca(bar_pos_x,bar_pos_y,1,LENGTH_CONSTANT, ball_pos_x, ball_pos_y, LENGTH_CONSTANT,LENGTH_CONSTANT):
            
            1TP4Interessante a sinistra
            
            invertire_palla_dx()
            ball_pos_x -= 2
            
        se interseca(bar_pos_x + BAR_WIDTH,bar_pos_y,1,LENGTH_CONSTANT, ball_pos_x, ball_pos_y, LENGTH_CONSTANT,LENGTH_CONSTANT):
            
            1TP4Interessante a destra
            
            invertire_palla_dx()
            ball_pos_x += 2

        
def draw(tick):
    
    se game_over:
        penna(0,0,0)
        cancellare()
        penna(15,15,15)
        testo("Game Over", 35, 60)
        
        
    altrimenti:
        penna(0, 0, 0)
        Cancella()
        penna(15,15,15)
    
        #disegna la barra (paletta)
        frect(bar_pos_x,bar_pos_y,BAR_WIDTH,LENGTH_CONSTANT)
    
        #disegna la palla
        frect(palla_pos_x, palla_pos_y, LUNGHEZZA_CONSTANTE,LUNGHEZZA_CONSTANTE)
        testo(str(punteggio), 80, 20)
    
inizio()

Avete un gioco da consigliare?

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

Lascia un commento