Jogos no Raspberry Pi Pico

Neste post, quero falar sobre jogos no Raspberry Pi Pico.

Lembro-me do meu primeiro telefone idiota, que na altura se chamava "telefone". Podia jogar jogos simples como o Snake. Isso era uma borda sangrenta.

Antes disso, teria de levar um aparelho portátil separado que jogasse Tetris ou um sistema de jogo mais dinâmico como um Gameboy.

O Raspberry Pi Pico é um microcontrolador bastante poderoso em comparação com o que funcionava nos anos 90. Naturalmente, oferece-nos a capacidade de jogar jogos dessa época.

Quão poderoso é o Raspberry Pi Pico

Em comparação com uma consola dos anos 80, o Raspberry Pi Pico é extremamente poderoso. 

Se programar um jogo semelhante aos requisitos de recursos de um jogo dos anos 80, o Raspberry Pi Pico irá provavelmente passar por ele.

É nos anos 90 que começa a ser um pouco mais difícil afirmar uma conclusão tão clara.

Por um lado, se pensarmos nele como um dispositivo capaz de jogar jogos semelhantes aos que se encontram num Gameboy ou num telemóvel, provavelmente ficaremos satisfeitos.

No entanto, os jogos no final dos anos 90 tornaram-se muito mais tributários. Não vai jogar Quake 3 (um jogo de 1999) no Pico, por exemplo.

De facto, enquanto o Raspberry Pi Pico vai jogar Doom (1993), foi um esforço de seis meses para a pessoa que o codificou porque era uma tarefa bastante difícil comprimir o jogo nos 2MB de armazenamento que o Raspberry Pi Pico tem.

Assim, embora o Pico tenha dois processadores de 133MHz, tem uma memória RAM e armazenamento limitados, o que dificulta a sua utilização.

Vamos ver como se compara a um Gameboy:

Porquê jogar jogos no Pico e não no Zero/Pi 4?

Boa pergunta.

Como sabem, o Raspberry Pi Pico é um microcontrolador enquanto o Raspberry Pi Zero ou Pi 4 são microcomputadores.

Ambos podem jogar jogos, mas o Raspberry Pi Pico é muito mais limitado.

Dito isto, se quisesse construir um emulador ou sistema de jogo a partir do Raspberry Pi Zero ou Pi 4s hoje (em 2022), é melhor que já tenha um ou então o seu maior engarrafamento é o stock.

É muito difícil conseguir um Pi Zero e bastante desafiante conseguir um Pi 4.

Por outro lado, o Pico é abundante. Também arranca quase imediatamente, enquanto que o microcomputador Pis tem de passar por um longo processo de arranque.

O Pico também dura muito mais tempo. Se quiser uma configuração móvel que funcione durante horas e seja portátil, fará muito melhor com o Pico.

Finalmente, para além do stock, o Pico é também abundante em stock.

Para ser justo com os Pi Zero e Pi 4, pode definitivamente jogar melhores jogos e ter melhores resultados de emulação com esses microcomputadores. Como verá na secção seguinte, o Pico tem dificuldade em jogar jogos que o Zero ou o Pi 4 vão passar.

Que jogos pode o Raspberry Pi Pico jogar?

Vamos começar por ver o que a comunidade de tinkering tem sido capaz de tocar no Raspberry Pi Pico.

RP2040 Doom é a resposta a "será a Doom?

Sim! O Raspberry Pi Pico pode jogar Doom.

Um tipo chamado Graham Sanderson, de Austin, Texas, conseguiu transportar o Doom para o Raspberry Pi Pico.

A sua fórmula mágica?

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

Ele explicado na sua documentação do processo que enfrentou múltiplas restrições das especificações de hardware que o Raspberry Pi Pico tinha. Afinal, não é um dispositivo destinado a jogos de azar.

No entanto, Graham também decidiu tornar ainda mais difícil a portabilidade do Doom. Ele queria a experiência autêntica de Doom, o que significava ter uma resolução 320×200 (cor), som estéreo, música OPL2, guardar e carregar, multiplayer de rede e outras características que estão disponíveis no nome original.

Embalar tanto jogo no Raspberry Pi Pico significava desafios com memória. Tanto a RAM como o armazenamento eram questões chave.

Primeiro, o Raspberry Pi Pico tem apenas 2MB de armazenamento, mas a versão shareware do Doom é o dobro desse tamanho. Enquanto outros criadores poderiam decidir cortar certas características como ecrãs de salpicos e downsampling de texturas, Graham não quis fazer isso.

A RAM foi também outra questão, com o código fonte Chocolate Doom a exigir cerca de 1MB de RAM enquanto que o Pico tem apenas cerca de 264KB. A memória é apertada porque a renderização dos gráficos ocupa um enorme pedaço do espaço da RAM, mas a RAM é também muito importante para o bom funcionamento do jogo. A fim de gerir ambos os aspectos, Graham teve de fazer o que ele chamou de "lipoaspiração".

Pode ler mais em a documentação, observando a sua lista de reprodução no YouTube ou revisão do código.

Emulador NES

O Raspberry Pi Pico foi transformado com sucesso num emulador NES.

Num tópico do Fórum da Zona EmuladoraO utilizador ropgar disse que o Raspberry Pi Pico tem o poder de emular um NES e pode fazer 60 quadros por segundo e pode emular perfeitamente APU e PPP.

Ropgar usa um teclado PS/2 como controlador, mas também pode usar o controlador NES original.

O som é bom e não há falhas no vídeo e na música de fundo do jogo.

O Pico tem cerca de 1,5MB de espaço de flash restante para diferentes jogos, que podem ser escolhidos premindo Caps Lock para alternar entre jogos. 

Os jogos que ropgar conseguiu carregar na sua demonstração são Pacman, Arkanoids, DK, DK Jr, BubbleBobble, Galaga, e muitos outros.

A única desvantagem é que não há código fonte público ou tutorial sobre como fazer isto.

Emulador Gameboy para o Raspberry Pi Pico

Pode fazer o seu próprio estojo Gameboy e depois usar o Raspberry Pi Pico para imitar o Gameboy.

A parte complicada aqui é que na realidade não é algo que tenha visto um grande sucesso. Por outras palavras, o que se constrói pode funcionar, mas nem sempre.

Vamos dar uma vista de olhos às opções lá fora.

Emulador Rust Gameboy (Porto OxidGB Pico)

Ao ver a imagem do Pokemon no ecrã, fiquei imediatamente entusiasmado.

No entanto, James Selby escreveu efectivamente sobre os desafios e deficiências do seu emulador Gameboy, escrito em Rust, chamado OxidGB Pico Port.

"Isto tem sido um passeio - um passeio frustrante, mas um passeio que, apesar de tudo, gostei muito de uma perspectiva educacional", disse Selby.

Problemas e vitórias

Aqui está o principal desafio: O emulador Rust Gameboy "não é exactamente jogável no seu estado actual, infelizmente".

Selby disse que os jogos só recebem cerca de 10 FPS porque o código do emulador é um estrangulamento, bem como a interface lenta do SPI para o visor.

É possível acelerar as coisas, mas isso exigiria tempo para planear e implementar.

O input não foi configurado, uma vez que os jogos não eram jogáveis. 

Teste do Porto do Pico de OxidGB

Se quiser tentar, pode seguir as instruções de Selby no seu Github repo para o Porto de OxidGB Pico.

RP2040_GB emulador

Outro emulador que pode tentar é o RP2040_GBque se baseia no Peanut-GB emulador.

O desempenho no RP2040_GB é decente, com Koshkouei a dizer que a sua configuração "funciona a mais de 70 fps sem emulação de áudio. Com salto de moldura e entrelaçamento, pode funcionar a até 120 fps".

Como pode ver, o RP2040_GB está a jogar Pokemon. Os passos para colocar uma ROM no RP2040 são como tal:

• Deve ter o Pico SDK
• Converta .gb ou .gbc ROM para um ficheiro de cabeçalho C utilizando o xxd programa
• Modificar o ficheiro convertido adicionando duas linhas de código (no Github readme)
• Copiar ROM para o src pasta e compilação.

Existem algumas limitações deste emulador:

• "Este emulador é impreciso e é muito um trabalho em curso ... alguns jogos podem correr incorrectamente ou não correr de todo". 
• Os jogos Gameboy Color irão lançar um erro
• Não optimizado para microcontrolador: Koshkouei sugeriu que, "Utilizando uma APU optimizada para o espaço e velocidade" pode ajudar.

Ver o RP2040_GB's Github repo aqui.

Mega Jogos Compilação com Raspberry Pi Pico

A melhor parte deste projecto é que é simples e as instruções são adequadas para que possa iniciar rapidamente uma consola de jogo Raspberry Pi Pico.

Roger Bühler tem peças, instruções e demonstrações incluídas no seu Github.

A Mega Compilação de Jogos vem com os seguintes jogos:

1. Tiny Gilbert
2. Truque minúsculo
3. Tiny Invaders v3.1
4. Pinball v2 minúsculo
5. Tiny Pacman v1.2
6. Bombardeiro minúsculo v1.3
7. Bicicleta Pequena v1.2
8. Tiny Bert 1.1
9. Arkanoid minúsculo v2
10. Tiny Tris v2.1e
11. Placa minúscula
12. Tiny DDug
13. Míssil minúsculo v1.1
14. Tiny Lander v1.0 ( por Roger Buehler )
15. Pequeno Morpião
16. Cano minúsculo

As peças de que vai precisar são as seguintes:

1. Framboesa Pi Pico
2. Visor OLED SSD1309 128x64px SPI (2,42" a 2:1 ratio)
3. Sinal sonoro piezoeléctrico
4. Cinco botões
5. Tabuleiro do pão
6. Cabos de salta
7. Opcional: resistências de 10 ohm, condensador electrolítico classificado para pelo menos 10V e 220uF

Também precisará de Biblioteca SSD1306 da Adafruit.

Veja aqui como ligar o visor:

• GND -> Mostrar GND 
• 3V3(OUT) -> Mostrar VCC 
• GP16 -> Mostrar DC (Comando de dados) 
• GP17 -> Mostrar CS (Selecção de Canal) 
• GP18 -> Mostrar SCL (Relógio) 
• GP19 -> Mostrar SDA (MOSI) 
• GP20 -> Mostrar RES (Reiniciar)

E para ligar os botões:

• GP15 -> botão UP 
• GP14 -> botão DOWN 
• GP13 -> botão ESQUERDA 
• GP12 -> botão DIREITO 
• GP11 -> botão FIRE (todos os botões para GND)

E para ligar a campainha piezoeléctrica:

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

Instalação de software:

Para instalar o software, é necessário utilizar o Arduino IDE.

Jogo do tipo Tamagotchi- no Pico de Framboesa Pi (Pico-Tamachibi)

Porque se chama Pico-Tamachibi?

De acordo com Kevin McAleer, o criador deste dispositivo, "tama" significa "ovo" e "chibi" refere-se a gráficos onde a personagem tem uma cabeça grande. 

Criar o Tamachibi é fácil porque Kevin passa por cada passo do caminho no seu tutorial de 90 minutos.

Construa a sua própria máquina de jogo

Se quiser fazer a sua própria máquina de jogo Raspberry Pi Pico, há duas maneiras gerais de o fazer: compre um kit pronto a usar ou construa você mesmo um.

Kit pronto a usar vs hardware de jogo DIY Raspberry Pi Pico

Embora seja possível começar do zero, talvez queira saltar o incómodo de construir o seu próprio sistema e simplesmente comprar um pacote pronto a usar.

Existem alguns kits baseados em RP2040 que lhe permitem saltar directamente para jogar ou desenvolver os seus próprios jogos.

Vamos olhar para o Pimoroni Picosystem e depois compará-lo com o processo de construção de algo semelhante utilizando peças individuais.

Pimoroni Picosystem

Vamos dar uma olhada ao Pimoroni Picosystem.

Como se pode ver, é muito maior que o Raspberry Pi Pico W, mas também porque tem um D-pad de quatro vias, quatro botões, ecrã LCD, uma bateria de iões de lítio, altifalante piezo e uma porta USB-C, entre outras adições.

Tem o mesmo processador e RAM, já que tanto o Picosystem como o Pico utilizam o chip RP2040. Aqui estão as especificações completas:

• Alimentado por RP2040 (Dual Arm Cortex M0+ com 264kB de SRAM)
• 16MB de flash QSPI que suporta XiP
• 1.54″ LCD SPI IPS a cores (240×240 e 120×120 modos)
• D-pad e botões
• 525mAh bateria LiPo (6hrs+)
• Sinal sonoro/altifalante piezoeléctrico
• Botão de ligar/desligar
• LED RGB
• Programável e recarregável via USB-C (cabo não incluído)

Modos gráficos

O PicoSystem suporta dois modos gráficos.

• 240×240: a resolução nativa do LCD
• 120×120: modo duplo de pixel (poupa RAM)

Como é que são os jogos no Picosystem?

O jogo no Picosystem é fácil. Basta premir o botão de ligar e é tratado ao jogo pré-carregado chamado Super Square Bros.

O jogo é um simples jogo de plataforma muito parecido com o Mario.

Pimoroni também incluiu outros jogos:

• Super Square Bros. por Scorpion Games - Um quadrilátero saltitante (jogo pré-carregado)
• Pontos - Puzzler de pontos. Criar cadeias de dois ou mais e correr para obter a maior pontuação.
• Rochas e Diamantes - Jogo clássico de esquivar-se às rochas e agarrar diamantes.
• Geometria - Esmagar rochas espaciais com lasers para fazer rochas espaciais mais pequenas!
• Subida ao arco-íris - As Almas Escuras dos puzzles de saltos verticais gerados por procedimentos. Boa sorte.
• Super Blit Kart por Daft_Freak - Um jogo de corridas baseado no "Mode7".

A fim de instalar estes jogos, faça o seguinte

• Descarregar o ficheiro.
• Ligue o seu Picosystem ao PC
• Premir e manter premido o botão X e o botão de ligar/desligar.
• O Picosystem deve ser montado como uma unidade chamada RPI-RP2
• Copiar o ficheiro .uf2 descarregado para a unidade. Será automaticamente carregado.

Por alguma razão, o meu cabo USB-C para USB-C não funcionou, mas o cabo USB-A para USB-C funcionou com o Picosystem. Se não vir o LED vermelho a acender, então tente outro cabo.

Programe os seus próprios jogos

A melhor parte sobre o Picosystem é que fornece um sistema para que possa criar os seus próprios jogos.

Em vez de codificar do zero, o PicoSystem vem com uma API especial que o pode ajudar a criar os seus jogos.

Também retira muito do tedioso trabalho necessário para comprar peças individuais como um ecrã LCD, botões, fios de jumper, tábua de cortar pão e depois descobrir as bibliotecas e pacotes necessários para pôr todas estas peças a funcionar.

O API do PicoSystem tem funções para desenhar coisas no ecrã, para emitir áudio, funções de hardware e outras funções utilitárias. Isto facilita-lhe a construção do seu jogo.

Tal como o Raspberry Pi Pico, o PicoSystem pode ser codificado em C++ ou MicroPython. 

É fácil programar um jogo com o Picosystem?

Recomendaria que tivesse algum tempo e paciência para construir o seu próprio jogo com o Picosystem.

A documentação oferece o básico para que possa começar, mas será melhor se tiver algum conhecimento prévio de programação de jogos.

O maior desafio para os principiantes é que não há muitos recursos por aí que lhe ensinem a codificar projectos de amostra. No entanto, aqui está uma lista de referência que o ajudará:

Guia Picosystem MicroPython (em readme)

Exemplos de Picosystem MicroPython

Picosystem C++ Github

Exemplos de Picosystem C++

Picosystem API cheatsheet, mais imagem, conversor de fontes (na barra lateral)

Sistema de bricolage: Criação do hardware

Guia do YouMakeTech acompanha o leitor através de como fazer uma consola de jogos completa com uma caixa, sistema de som e solda permanente.

Para a nossa comparação, vejamos quanto custaria construir uma unidade de bricolage versus o Picosystem, que é um kit completo.

Vejamos então os custos finais para diferentes níveis de configurações de bricolage:

Apenas uma advertência - YouMakeTech diz que pode construir isto por menos de $20. Na minha pesquisa, no entanto, os custos de uma instalação de bricolage que corresponda ao Picosystem não diferem assim tanto, especialmente quando se considera o software e a conveniência.

Dito isto, o percurso de bricolage é uma grande oportunidade de aprendizagem. Uma coisa que me desafiou foi o ecrã. Enquanto o exemplo do YouMakeTech usa uma ligação I2C, o ecrã que eu tinha usado uma interface SPI de 4 pinos. Isto requer ou uma alteração na codificação ou uma modificação do hardware para poder prosseguir. Se gosta de desafios, a rota de bricolage é para si.

Então, quais são as vantagens de o fazer de bricolage contra o Picosistema?

Criação do jogo tipo Pong- no sistema Picosystem vs DIY

Uma curiosa experiência minha envolve compreender quanto esforço será necessário para desenvolver um jogo usando o Picosystem versus fazê-lo a partir do zero.

A fim de comparar os dois sistemas, estarei a construir um jogo de um jogador, tipo Pong-, tanto no sistema de bricolage do YouMakeTech como no Picosystem.

A premissa do jogo é simples. É um jogo de um jogador, tipo Pong-, que lhe dá 10 pontos cada vez que a sua bola salta da raquete. Se cair para o fundo do ecrã, recebe uma mensagem de "Game Over".

A criação do jogo em ambos os sistemas segue um fluxo de trabalho simples que tudo leva ao Thonny.

Terá de fazer piscar MicroPython no Pico e depois usará Thonny para codificar o seu programa. 

O MicroPython que piscaria no Picosystem é diferente do ficheiro oficial do MicroPython UF2, por isso certifique-se de que está a piscar o correcto porque o Picosystem funcionará no lançamento oficial do MicroPython. Simplesmente não funcionará como pretendido.

Agora, vejamos algumas diferenças fundamentais entre os dois. Estou aqui a excluir a lógica do jogo e apenas a comparar diferenças na interacção entre o software de hardware e os padrões de programação.

Pode ver o código do YouMakeTech aqui.

Primeira diferença: código de hardware

As coisas estão muito "cruas" com a rota do bricolage. Aqui está algum código para inicializar o visor, GPIO e botões que não precisará de fazer com o 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)

Segunda diferença: API do Picosystem

Se estiver a escrever código no Picosystem, terá de escrever dentro do seu sistema.

No exemplo do YouMakeTech, toda a lógica de jogo está encapsulada dentro de um embora Verdadeiro laço. Isto inclui interacção de botões, detecção de colisão e desenho para o ecrã.

No Picosystem, é-lhe exigido que escreva dentro de três funções - init(), update() e sacar().

No meu código, toda a lógica do jogo está escrita em actualização() incluindo a manipulação de colisões e a interacção D-pad.

Num jogo simples de Pong, há algumas funções do API que utilizei que facilitaram um pouco as coisas:

intersecções(x1, y1, w1, h1, x2, y2, w2, h2)  é provavelmente a maior ajuda aqui. Passaria as coordenadas e tamanhos dos dois quadrados e voltaria a ser verdade se houvesse um cruzamento. Neste caso, os dois rectângulos são a bola e a barra (também conhecida como remo). A falha da função intersecção() é que não detecta de que lado a colisão ocorreu, pelo que tive de escrever código extra para lidar com colisões no lado da barra.

A API do Picosystem irá realmente brilhar à medida que se desenvolvem jogos mais complicados, dado que já tem um método para framebuffers, saída de áudio, mistura, etc. 

Código para Pimoroni Picosystem Jogo tipo 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()

Tem um jogo a recomendar?

Se tiver um jogo para o Raspberry Pi Pico, deixe um comentário abaixo com um URL.

E se quiser ver a nossa série Paragon Projects - vá a aqui.