Gry na Raspberry Pi Pico

W tym poście chcę porozmawiać o grach na Raspberry Pi Pico.

Pamiętam mój pierwszy dumbphone, który był wtedy nazywany "telefonem". Mógł grać w proste gry jak Snake. To był bleeding edge.

Wcześniej trzeba było mieć przy sobie osobnego handhelda, który grał w Tetrisa lub bardziej dynamiczny system do gier, jak Gameboy.

Raspberry Pi Pico to całkiem potężny mikrokontroler w porównaniu do tego, na czym działały handheldy w latach 90. Oczywiście oferuje nam możliwość grania w gry z tamtej epoki.

Jak potężne jest Raspberry Pi Pico

W porównaniu z konsolą z lat 80. Raspberry Pi Pico jest niezwykle potężny. 

Jeśli zaprogramujesz grę, która jest podobna do wymagań zasobów gry z lat 80-tych, Raspberry Pi Pico prawdopodobnie przebrnie przez nią.

To właśnie w latach 90. zaczyna być nieco trudniej o tak jednoznaczne stwierdzenie.

Z jednej strony, jeśli myślicie o nim jako o urządzeniu zdolnym do grania w gry podobne do tych, które znajdziecie na Gameboyu czy telefonie komórkowym, to zapewne będziecie zadowoleni.

Jednak gry pod koniec lat 90. stały się znacznie bardziej wymagające. Na przykład na Pico nie zagrasz w Quake 3 (gra z 1999 roku).

W rzeczywistości, podczas gdy Raspberry Pi Pico zagra w Doom (1993), było to sześciomiesięczne przedsięwzięcie dla osoby, która go zakodowała, ponieważ było to dość trudne zadanie, aby skompresować grę do 2MB pamięci, którą ma Raspberry Pi Pico.

Tak więc, podczas gdy Pico ma dwa procesory 133MHz, ma ograniczoną pamięć RAM i pamięć masową, co utrudnia pracę.

Zobaczmy, jak wypada w porównaniu z Gameboyem:

Dlaczego warto grać w gry na Pico, a nie na Zero/Pi 4?

Dobre pytanie.

Jak wiadomo, Raspberry Pi Pico to mikrokontroler, natomiast Raspberry Pi Zero czy Pi 4 to mikrokomputery.

Oba mogą grać w gry, ale Raspberry Pi Pico jest znacznie bardziej ograniczone.

To powiedziawszy, jeśli chciałeś zbudować emulator lub system gier z Raspberry Pi Zero lub Pi 4s dzisiaj (w 2022 roku), lepiej mieć już jeden lub inaczej twoje największe wąskie gardło to zapas.

Bardzo trudno jest dostać Pi Zero i dość trudne do zdobycia Pi 4.

Z drugiej strony, Pico jest obfity. Również uruchamia się niemal natychmiast, podczas gdy mikrokomputer Pis musi przejść przez długi proces uruchamiania.

Pico działa również znacznie dłużej. Jeśli chcesz mobilnego setupu, który będzie działał przez wiele godzin i jest przenośny, zrobisz dużo lepiej z Pico.

Wreszcie, oprócz zapasów, obfite są też zapasy Pico.

Aby być sprawiedliwym wobec Pi Zero i Pi 4, można zdecydowanie grać w lepsze gry i mieć lepsze wyniki emulacji z tych mikrokomputerów. Jak zobaczysz w następnej sekcji, Pico ma problemy z grami, w które Pi Zero lub Pi 4 gra bez problemu.

W jakie gry może grać Raspberry Pi Pico?

Zaczniemy od sprawdzenia, co udało się społeczności majsterkowiczów ugrać na Raspberry Pi Pico.

RP2040 Doom to odpowiedź na pytanie "czy to będzie Doom?".

Tak! Raspberry Pi Pico może grać w Dooma.

Niejaki Graham Sanderson z Austin w Teksasie zdołał przeportować Dooma na Raspberry Pi Pico.

Jego magiczna formuła?

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

On wyjaśnił w swojej dokumentacji procesu że spotkał się z wieloma ograniczeniami wynikającymi ze specyfikacji sprzętowej, jaką posiadał Raspberry Pi Pico. W końcu nie jest to urządzenie przeznaczone do gier.

Mimo to Graham postanowił również, że portowanie Dooma będzie jeszcze trudniejsze. Chciał autentycznego doświadczenia Dooma, co oznaczało posiadanie rozdzielczości 320×200 (kolor), dźwięku stereo, muzyki OPL2, zapisywania i ładowania, sieciowego multiplayera i innych funkcji, które są dostępne w oryginale.

Upakowanie tak dużej ilości gier na Raspberry Pi Pico oznaczało wyzwania związane z pamięcią. Zarówno pamięć RAM, jak i pamięć masowa były kluczowymi kwestiami.

Po pierwsze, Raspberry Pi Pico ma tylko 2MB pamięci, ale shareware'owa wersja Dooma jest dwa razy większa. Podczas gdy inni deweloperzy mogą zdecydować się na wycięcie pewnych funkcji, takich jak splash screens czy downsampling tekstur, Graham nie chciał tego robić.

Kolejnym problemem była pamięć RAM - kod źródłowy Chocolate Doom wymaga około 1MB pamięci RAM, podczas gdy Pico ma tylko około 264KB. Pamięć jest ciasna, ponieważ renderowanie grafiki zajmuje ogromny kawałek miejsca w pamięci RAM, ale pamięć RAM jest również bardzo ważna dla płynnego działania gry. Aby poradzić sobie z obydwoma aspektami, Graham musiał zrobić coś, co nazwał "liposukcją".

Więcej można przeczytać wchodząc na stronę dokumentacja, oglądając jego playlista na YouTube lub przeglądanie kodu.

Emulator NES

Z Raspberry Pi Pico udało się zrobić emulator NES-a.

W wątku na forum Emulator Zone, użytkownik ropgar powiedział, że Raspberry Pi Pico ma moc emulowania NES-a i potrafi zrobić 60 klatek na sekundę oraz doskonale emuluje APU i PPP.

Ropgar wykorzystuje klawiaturę PS/2 jako kontroler, ale można też użyć oryginalnego kontrolera NES.

Dźwięk jest dobry i nie ma żadnych glitchy na wideo i muzyce w tle gry.

W Pico pozostało około 1,5MB miejsca w pamięci flash na różne gry, które można wybrać naciskając Caps Lock, aby przełączać się między grami. 

Gry, które ropgar zdołał załadować na swoje demo to Pacman, Arkanoids, DK, DK Jr, BubbleBobble, Galaga i wiele innych.

Jednym minusem jest to, że nie ma publicznego kodu źródłowego lub samouczka, jak to zrobić.

Emulator Gameboya dla Raspberry Pi Pico

Możesz zrobić własną obudowę Gameboya, a następnie użyć Raspberry Pi Pico do emulacji Gameboya.

Trudną częścią tutaj jest to, że w rzeczywistości nie jest to coś, co widziało wielką ilość sukcesów. Innymi słowy, to co budujesz może działać, ale nie zawsze.

Przyjrzyjmy się dostępnym opcjom.

Emulator Rust Gameboy (OxidGB Pico Port)

Po ujrzeniu na ekranie obrazu Pokemonów, od razu byłem podekscytowany.

Jednak James Selby faktycznie napisał o wyzwaniach i niedociągnięciach swojego emulatora Gameboya, napisanego w Rust, o nazwie OxidGB Pico Port.

"To była przejażdżka - frustrująca przejażdżka, ale przejażdżka, którą mimo wszystko dokładnie cieszyłem się z perspektywy edukacyjnej" - powiedział Selby.

Problemy i zwycięstwa

Oto główne wyzwanie: Emulator Rust Gameboy "nie jest do końca grywalny w obecnym stanie niestety".

Selby powiedział, że gry uzyskują tylko około 10 FPS, ponieważ kod emulatora jest wąskim gardłem, jak również powolny interfejs SPI do wyświetlacza.

Można przyspieszyć, ale to wymagałoby czasu na zaplanowanie i wdrożenie.

Input nie został skonfigurowany, ponieważ gry nie były grywalne. 

Testowanie portu Pico OxidGB

Jeśli chcesz spróbować, możesz postępować zgodnie z instrukcjami Selby'ego na jego stronie Github repo dla portu OxidGB Pico.

Emulator RP2040_GB

Innym emulatorem, który możesz wypróbować jest RP2040_GB, który opiera się na. Peanut-GB emulator.

Wydajność RP2040_GB jest przyzwoita, a Koshkouei twierdzi, że jego konfiguracja "działa z prędkością ponad 70 klatek na sekundę bez emulacji dźwięku. Z pomijaniem klatek i przeplotem może działać z prędkością do 120 fps."

Jak widać, RP2040_GB gra w Pokemona. Kroki do uzyskania ROMu na RP2040 są takie:

• Musisz mieć Pico SDK
• Konwertuj .gb lub .gbc ROM do pliku nagłówkowego C przy użyciu xxd program
• Zmodyfikuj przekonwertowany plik, dodając dwie linie kodu (w Github readme)
• Kopiowanie pamięci ROM do src folder i skompilować.

Istnieją pewne ograniczenia tego emulatora:

• "Ten emulator jest niedokładny i jest w dużym stopniu pracą w toku ... niektóre gry mogą działać niepoprawnie lub nie działać w ogóle". 
• Gry na Gameboy Color wyrzucają błąd
• Nie jest zoptymalizowany pod kątem mikrokontrolera: Koshkouei zasugerował, że, "Używanie APU, które jest zoptymalizowane pod kątem przestrzeni i prędkości" może pomóc.

Zobacz repo RP2040_GB na Githubie tutaj.

Kompilacja Mega Games z Raspberry Pi Pico

Najlepsze w tym projekcie jest to, że jest prosty, a instrukcje są wystarczające, abyś mógł szybko rozpocząć pracę nad konsolą do gier Raspberry Pi Pico.

Roger Bühler ma części, instrukcje i dema zawarte na swoim Githubie.

W skład kompilacji Mega Games wchodzą następujące gry:

1. Tiny Gilbert
2. Tiny Trick
3. Tiny Invaders v3.1
4. Tiny Pinball v2
5. Malutki 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. Tiny Plaque
12. Tiny DDug
13. Tiny Missile v1.1
14. Tiny Lander v1.0 ( przez Roger Buehler )
15. Tiny Morpion
16. Mała rura

Części, których będziesz potrzebował, są następujące:

1. Raspberry Pi Pico
2. SSD1309 128x64px SPI OLED display (wyświetlacz 2,42" w proporcjach 2:1)
3. Brzęczyk piezoelektryczny
4. Pięć przycisków
5. Tablica ogłoszeń
6. Kable do skoczka
7. Opcjonalnie: rezystory 10 ohm, kondensator elektrolityczny o napięciu co najmniej 10V i 220uF

Potrzebne będą również Biblioteka SSD1306 firmy Adafruit.

Oto jak podłączyć wyświetlacz:

• GND -> masa wyświetlacza 
• 3V3(OUT) -> Wyświetlacz VCC 
• GP16 -> Wyświetlanie DC (Data Command) 
• GP17 -> Wyświetlanie CS (Channel Select) 
• GP18 -> Wyświetlacz SCL (Clock) 
• GP19 -> Wyświetlacz SDA (MOSI) 
• GP20 -> Wyświetlacz RES (Reset)

I do podłączenia przycisków:

• GP15 -> przycisk UP 
• GP14 -> przycisk DOWN 
• GP13 -> przycisk LEWO 
• GP12 -> przycisk PRAWO 
• GP11 -> przycisk FIRE (wszystkie przyciski do GND)

I do podłączenia buzera piezoelektrycznego:

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

Instalacja oprogramowania:

Aby zainstalować oprogramowanie, należy skorzystać z Arduino IDE.

Gra przypominająca Tamagotchi na Raspberry Pi Pico (Pico-Tamachibi)

Dlaczego nazywa się to Pico-Tamachibi?

Według Kevina McAleera, twórcy tego urządzenia, "tama" oznacza "jajko", a "chibi" odnosi się do grafik, w których postać ma dużą głowę. 

Tworzenie Tamachibi jest łatwe, ponieważ Kevin w swoim 90 minutowym tutorialu przedstawia każdy krok na drodze.

Zbuduj swój własny automat do gier

Jeśli chcesz stworzyć własną maszynę do gier Raspberry Pi Pico, istnieją dwa ogólne sposoby, w jakie możesz to zrobić: kupić gotowy zestaw lub zbudować go samodzielnie.

Gotowy zestaw vs sprzęt do gier DIY Raspberry Pi Pico

Choć można zacząć od podstaw, warto pominąć kłopotliwe budowanie własnego systemu i po prostu kupić gotowy pakiet.

Istnieje kilka zestawów opartych na RP2040, które pozwalają wskoczyć prosto do grania lub tworzenia własnych gier.

Przyjrzyjmy się Pikosystemowi Pimoroni, a następnie porównajmy go z procesem budowania czegoś podobnego przy użyciu pojedynczych części.

Pikosystem Pimoroni

Przyjrzyjmy się pikosystemowi Pimoroni.

Jak widać, jest on znacznie większy od Raspberry Pi Pico W, ale to także dlatego, że ma m.in. czterokierunkowy D-pad, cztery przyciski, ekran LCD, baterię litowo-jonową, głośnik piezoelektryczny i port USB-C.

Posiada ten sam procesor i pamięć RAM, gdyż zarówno Picosystem jak i Pico korzystają z układu RP2040. Poniżej pełna specyfikacja:

• Zasilany przez RP2040 (Dual Arm Cortex M0+ z 264kB pamięci SRAM)
• 16MB pamięci QSPI flash obsługującej XiP
• 1,54″ kolorowy SPI IPS LCD (tryby 240×240 i 120×120)
• D-pad i przyciski
• Bateria LiPo 525mAh (6h+)
• Brzęczyk/głośnik piezoelektryczny
• Przycisk zasilania On/off
• RGB LED
• Możliwość programowania i ładowania przez USB-C (kabel nie jest dołączony)

Tryby graficzne

PicoSystem obsługuje dwa tryby graficzne.

• 240×240: rozdzielczość natywna wyświetlacza LCD
• 120×120: tryb podwojenia pikseli (oszczędza RAM)

Jak wygląda rozgrywka na Picosystemie?

Granie na Picosystemie jest proste. Wystarczy nacisnąć przycisk zasilania, a pojawi się preinstalowana gra o nazwie Super Square Bros.

Gra jest prostą platformówką bardzo podobną do Mario.

Pimoroni włączyło również inne gry:

• Super Square Bros. autorstwa Scorpion Games - Odważna platformówka w kształcie czworokąta (wstępnie załadowana gra)
• Kropki - Puzzle z kropkami. Twórz łańcuchy z dwóch lub więcej i ścigaj się, aby uzyskać największy wynik.
• Skały i diamenty - Klasyczna gra polegająca na unikaniu skał i chwytaniu diamentów.
• Geometria - Rozbij laserami kosmiczne głazy, aby stworzyć mniejsze kosmiczne głazy!
• Tęczowe wznoszenie się - Dark Souls proceduralnie generowanych pionowych łamigłówek do skakania. Powodzenia.
• Super Blit Kart by Daft_Freak - Gra wyścigowa oparta na "Mode7".

Aby zainstalować te gry, wykonaj następujące czynności:

• Pobierz plik.
• Podłącz swój Picosystem do komputera.
• Naciśnij i przytrzymaj przycisk X, a następnie naciśnij przycisk zasilania.
• Picosystem powinien być zamontowany jako napęd o nazwie RPI-RP2
• Skopiuj na dysk pobrany plik .uf2. Zostanie on automatycznie załadowany.

Z jakiegoś powodu mój kabel USB-C do USB-C nie działał, ale kabel USB-A do USB-C działał z Picosystemem. Jeśli nie widzisz, że czerwona dioda się świeci, to spróbuj innego kabla.

Zaprogramuj swoje własne gry

Najlepsze w Picosystemie jest to, że zapewnia on system do tworzenia własnych gier.

Zamiast kodować od podstaw, PicoSystem jest dostarczany ze specjalnym API, które może pomóc w tworzeniu gier.

Odejmuje to również wiele żmudnej pracy wymaganej przy zakupie poszczególnych części, takich jak ekran LCD, przyciski, zworki, deska do krojenia, a następnie rozgryzanie bibliotek i pakietów wymaganych do uruchomienia wszystkich tych elementów.

API PicoSystemu posiada funkcje do rysowania rzeczy na ekranie, do wyprowadzania dźwięku, funkcje sprzętowe i inne funkcje użytkowe. Dzięki temu łatwiej będzie ci zbudować swoją grę.

Podobnie jak Raspberry Pi Pico, PicoSystem może być kodowany w języku C++ lub MicroPython. 

Czy łatwo jest zaprogramować grę za pomocą Picosystemu?

Polecałbym mieć trochę czasu i cierpliwości, aby zbudować własną grę z Picosystemem.

Dokumentacja oferuje podstawy, aby zacząć, ale najlepiej będzie, jeśli będziesz miał jakąś wcześniejszą wiedzę na temat programowania gier.

Największym wyzwaniem dla początkujących jest to, że nie ma wielu zasobów tam, które uczą cię, jak kodować przykładowe projekty. Jednak tutaj jest lista referencji, które pomogą ci:

Przewodnik po Picosystem MicroPython (w readme)

Przykłady Picosystem MicroPython

Picosystem C++ Github

Przykłady Picosystem C++

Picosystem API cheatsheet, plus konwerter obrazów, czcionek (na pasku bocznym)

System DIY: Tworzenie okuć

Przewodnik YouMakeTech'a prowadzi czytelnika przez to, jak zrobić kompletną konsolę do gier z obudową, systemem dźwiękowym i trwałym lutowaniem.

Dla naszego porównania zobaczmy, ile kosztowałoby zbudowanie urządzenia DIY w porównaniu z Picosystemem, który jest kompletnym zestawem.

Zobaczmy więc ostateczne koszty dla różnych poziomów konfiguracji DIY:

Tylko zastrzeżenie - YouMakeTech twierdzi, że można to zbudować za mniej niż $20. Z moich badań wynika jednak, że koszty zestawu DIY, który dorównuje Picosystemowi, nie różnią się tak bardzo, zwłaszcza jeśli weźmiemy pod uwagę oprogramowanie i wygodę.

To powiedziawszy, trasa DIY jest świetną okazją do nauki. Jedną z rzeczy, która stanowiła dla mnie wyzwanie był ekran. Podczas gdy przykład YouMakeTecha używa połączenia I2C, ekran, który miałem, używał 4-pinowego interfejsu SPI. To albo wymaga zmiany w kodowaniu, albo modyfikacji sprzętu, aby kontynuować. Jeśli lubisz wyzwania, to trasa DIY jest dla ciebie.

Jakie są więc zalety robienia tego DIY vs. Picosystem?

Tworzenie gry typu Pong na systemie Picosystem vs DIY

Mój ciekawy eksperyment polega na sprawdzeniu, ile wysiłku wymaga stworzenie gry przy użyciu Picosystemu, a ile zrobienie jej od podstaw.

Aby porównać oba systemy, będę budował jednoosobową grę typu Pong zarówno na systemie DIY firmy YouMakeTech, jak i na Picosystemie.

Założenie gry jest proste. Jest to gra dla jednego gracza w stylu Ponga, która daje ci 10 punktów za każdym razem, gdy twoja piłka odbije się od łopatki. Jeśli spadnie na dół ekranu, otrzymasz wiadomość "Game Over".

Tworzenie gry na obu systemach odbywa się według prostego workflow, który wszystkie prowadzi do Thonny.

Musiałbyś flashować MicroPython na Pico, a następnie użyjesz Thonny do zakodowania swojego programu. 

Plik MicroPython, który zostanie uruchomiony na Picosystemie, różni się od oficjalnego pliku MicroPython UF2, więc upewnij się, że uruchamiasz ten właściwy, ponieważ Picosystem będzie działał na oficjalnym wydaniu MicroPythona. Po prostu nie będzie działał zgodnie z przeznaczeniem.

Przyjrzyjmy się teraz pewnym fundamentalnym różnicom między nimi. Wyłączam tutaj logikę gry i porównuję jedynie różnice w interakcji sprzęt-oprogramowanie oraz wzorce programowania.

Kod YouMakeTech możecie zobaczyć tutaj.

Pierwsza różnica: kod sprzętowy

W przypadku trasy DIY rzeczy są bardzo "surowe". Oto trochę kodu do inicjalizacji wyświetlacza, GPIO i przycisków, którego nie będziesz musiał robić z Picosystemem:

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)

Druga różnica: API firmy Picosystem

Jeśli piszesz kod na Picosystemie, musiałbyś pisać w obrębie jego systemu.

W przykładzie YouMakeTech, cała logika gry jest zamknięta w ramach while True loop. Obejmuje to interakcję z przyciskami, wykrywanie kolizji i rysowanie na ekranie.

W Picosystemie wymagane jest pisanie w obrębie trzech funkcji -. init(), update() oraz draw().

W moim kodzie cała logika gry jest zapisana w update() w tym obsługę kolizji i interakcję z D-padem.

W prostej grze Pong, jest kilka funkcji z API, których użyłem, które nieco ułatwiły sprawę:

przecina(x1, y1, w1, h1, x2, y2, w2, h2)  jest prawdopodobnie największą pomocą tutaj. Przekazałbyś współrzędne i rozmiary dwóch kwadratów, a to zwróci true, jeśli istnieje przecięcie. W tym przypadku dwa prostokąty to piłka i drążek (a.k.a. paddle). Wadą funkcji intersects() jest to, że nie wykrywa ona, po której stronie nastąpiła kolizja, więc musiałem napisać dodatkowy kod, aby poradzić sobie z kolizjami po stronie pręta.

API Picosystemu będzie naprawdę błyszczeć, gdy będziesz tworzyć bardziej skomplikowane gry, biorąc pod uwagę, że ma już metody dla framebufferów, wyjścia audio, blendingu itp. 

Kod dla gry Pimoroni Picosystem Pong-like

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

Masz jakąś grę do polecenia?

Jeśli masz grę dla Raspberry Pi Pico, zostaw komentarz poniżej z adresem URL.

A jeśli chcesz zapoznać się z naszą serią Paragon Projects - przejdź do strony tutaj.