Space Invaders in Micropython op Micro:bit - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

In onze vorige artikelen hebben we het maken van games op GameGo onderzocht, een draagbare retro-gameconsole ontwikkeld door TinkerGen Education. De games die we maakten deden denken aan oude Nintendo-games. In het artikel van vandaag gaan we een stap terug doen, naar de gouden eeuw van arcadespellen. We zullen de Space Invaders-game opnieuw maken in Micropython op Micro:bit-microcontroller - en als een twist gebruiken we ook de BitPlayer Micro:bit-extensie, waarmee we het spel gemakkelijker kunnen spelen.

Aangezien deze tutorial gaat over het coderen van het spel in Micropython, in plaats van de traditionele stapsgewijze volgorde die we eerder gebruikten voor grafische programmeertutorials, gaan we de code blok voor blok doornemen - belangrijke functies, klassen en de belangrijkste lus. U kunt de volledige code downloaden in de GitHub-repository van dit project. Zet je schrap en laten we beginnen!

Benodigdheden

TinkerGen BitPlayer

BBC Micro:bit

Stap 1: Hoofdlus

In deze tutorial zal ik het woord "methode" vrij vaak gebruiken. Een methode in python lijkt enigszins op een functie, behalve dat deze is gekoppeld aan object/klassen. Dus ter vereenvoudiging kun je het lezen als "een functie binnen de klasse". U kunt hier meer lezen over methoden.

We gaan de hoofdlus in met

terwijl niet game_over:

voorwaarde. Binnen krijgen we het aantal indringers, de kans dat ze verschijnen en het aantal dat nodig is om naar het volgende niveau te gaan vanuit het niveauswoordenboek. Vervolgens controleren we op links-rechts beweging met de Listen_Dir-instantiemethoden van de klasse-instantie JoyStick. Als een van de voorwaarden als Waar wordt beoordeeld, verhogen/verlagen we de x-waarde van ons speelbare personage. We beperken het tot [-2, 2] met twee if-voorwaarden. Vervolgens initialiseren we een instantie van de klasse DisplayBuffer en controleren of er op de knop "shield" of "fire bullet" wordt gedrukt. We gebruiken de methode DisplayBuffer.set() om objecten in te stellen voor latere weergave. Voor het renderen van het schild gebruiken we DisplayBuffer.set() rechtstreeks, maar voor opsommingstekens en indringers voegen we ze toe aan hun respectievelijke lijst en stellen ze () ze één voor één in voor een lus met de volgende code voor latere weergave met DispBuffer.render():

voor b in opsommingstekens: b.render(dispBuf) voor v in vaders: v.render(dispBuf)

Alle indringers, kogels en schilden worden één keer per hoofdlus-iteratie weergegeven met

dispBuf.render()

Voor het einde van de hoofdlus controleren we of een van de kogels van indringers het einde van het scherm heeft bereikt, en als dat zo is, verwijderen we ze uit hun respectievelijke lijsten.

Stap 2: Joystick

BitPlayer is gemakkelijk vast te houden en te gebruiken, met een 2-assige joystick zoals Gameboy- of PSP-controllers, het bevat ook nog eens 6 programmeerbare knoppen met de labels L, R, A, B, C en D. Voor een meeslepende en interactieve ervaring biedt de BitPlayer zelf is voorzien van een zoemer, een vibratiemotor en een Grove I2C-poort om extra randapparatuur zoals een OLED-scherm aan te sluiten.

We gebruiken alleen de links-rechts rocker van de joystick voor dit spel, voor het volledige gebruik van alle BitPlayer-knoppen kun je bijvoorbeeld joystick_example.py in de GitHub-repository van dit project bekijken. Bij het maken van de instantie van JoyStick-klasse controleren we de standaardwaarde van de X-as en slaan die waarde op in self. Read_X. Vervolgens controleren we in de functie Listen_Dir of de afwijking van die standaardwaarde hoger is dan de gevoeligheidsvariabele (probeer het zelf aan te passen, als u vindt dat JoyStick te gevoelig is) en retourneren True of False volgens de gedetecteerde richting.

Laten we eens kijken naar een concreet voorbeeld van hoe dit werkt:

Laten we zeggen dat onze standaardwaarde voor de X-as 0 is. Als we de joystick vervolgens naar rechts bewegen:

New_X = JoyStick_X.read_analog() #New_X=200

Rechts = New_X - zelf. Read_X #Right = 200 Links = zelf. Read_X - New_X #Left = -200

Als we dan de richting controleren:

Precision = 150if Right > Precision: #200 > 150 True Get_Rocker = DIR['R'] elif Left > Precision: #-200 > 150 False Get_Rocker = DIR['L'] else: Get_Rocker = DIR['NONE'] if Dir == Get_Rocker: return True else: return False

Stap 3: Buffer weergeven

De DisplayBuf-klasse is verantwoordelijk voor het besturen van het LED-scherm. Het wordt gedaan met behulp van twee methoden, set() en render(). set() methode verandert de waarden die overeenkomen met LED-schermpixels. U herinnert zich misschien dat pixels op het Micro:bit LED-scherm kunnen worden uitgedrukt als een tekenreeks of een lijst - "00000:00000:00000:00000:00000" is een leeg scherm. "00000:00000:00000:00000:00100" is een scherm met een zwak verlichte pixel in het midden van de onderste rij.

00000:

00000

:00000

:00000:

00100"

Deze notatie is misschien makkelijker te verwerken:)

Dus wat we tijdens de hoofdlus doen, is de methode set() van DisplayBuf aanroepen om al onze objecten in te stellen die op het scherm moeten worden weergegeven. Vervolgens gebruiken we de methode render() om ze allemaal tegelijkertijd op het scherm weer te geven.

Stap 4: Indringers, kogels en de speler

Bullets and Invaders behoren tot de Mover-klasse. Mover-klasse-instanties hebben hun x-, y-locaties en snelheid, evenals helderheid. De klasse Mover heeft twee instantiemethoden, set() en move(). set() methode roept eenvoudig de DisplayBuf set() methode aan met bijgewerkte coördinaten om op te slaan voor latere weergave op LED-matrix. move() methode werkt instantiecoördinaat bij op basis van instantiesnelheid - dat komt later van pas, wanneer we de snelheid van indringers moeten veranderen naarmate de niveaus vorderen.

Class Bullet en class Invader zijn subklassen van de Mover-klasse. Hier gebruiken we iets dat overerving wordt genoemd. De functionaliteit van super() stelt ons in staat om methoden van de superklasse in subklasse aan te roepen, zonder de code te hoeven herhalen.

Stap 5: Maak het je eigen

Gefeliciteerd! Je hebt zojuist het klassieke Space Invaders-spel opnieuw gemaakt op Micro:bit met coole gaming-hardware. Natuurlijk kun je vanaf hier de spelcode verbeteren - vanaf nu heeft de game bijvoorbeeld maar één niveau - je kunt meer uitdagende toevoegen. Ook, zoals je je misschien herinnert, heeft het originele spel stenen die voor de speler zweven, die je ook kunt toevoegen.

Als je een verbeterde versie van de game maakt, deel deze dan in de reacties hieronder! Voor meer informatie over BitPlayer en andere hardware voor makers en STEM-docenten, bezoek onze website, https://tinkergen.com/ en abonneer je op onze nieuwsbrief.

TinkerGen heeft onlangs een Kickstarter-campagne opgezet voor MARK (Make A Robot Kit), een robotkit voor het aanleren van codering, robotica, AI!

De originele Micropython-code van hexkcd/micro-vaders is gewijzigd om te werken met TinkerGen BitPlayer.