Space Invaders en Micropython sur Micro:bit : 5 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Dans nos articles précédents, nous avons exploré la création de jeux sur GameGo, une console de jeu rétro portable développée par TinkerGen Education. Les jeux que nous avons créés rappellent les anciens jeux Nintendo. Dans l'article d'aujourd'hui, nous allons prendre du recul, sur l'âge d'or des jeux d'arcade. Nous allons recréer le jeu Space Invaders en Micropython sur le microcontrôleur Micro:bit - et comme une torsion, nous utiliserons également l'extension BitPlayer Micro:bit, qui nous permet de jouer au jeu plus facilement.

Étant donné que ce didacticiel concerne le codage du jeu en Micropython, au lieu de la séquence traditionnelle étape par étape que nous utilisions auparavant pour les didacticiels de programmation graphique, nous allons passer en revue le code bloc par bloc - en passant par les fonctions importantes, les classes et les principaux boucle. Vous pouvez télécharger le code complet dans le référentiel GitHub de ce projet. Attachez-vous et commençons!

Fournitures

TinkerGen BitPlayer

BBC Micro:bit

Étape 1: boucle principale

Dans ce tutoriel, j'utiliserai assez souvent le mot "méthode". Une méthode en python est quelque peu similaire à une fonction, sauf qu'elle est associée à un objet/des classes. Donc, pour simplifier, vous pouvez le lire comme "une fonction au sein de la classe". Vous pouvez en savoir plus sur les méthodes ici.

Nous entrons dans la boucle principale avec

sans game_over:

état. À l'intérieur, nous obtenons le nombre d'envahisseurs, la probabilité de leur apparition et le nombre nécessaire pour passer au niveau suivant du dictionnaire des niveaux. Ensuite, nous vérifions le mouvement gauche-droite avec les méthodes d'instance Listen_Dir de l'instance de classe JoyStick. Si l'une des conditions est vraie, nous incrémentons/décrémentons la valeur x de notre personnage jouable. On le contraint à [-2, 2] avec deux conditions if. Ensuite, nous initialisons une instance de la classe DisplayBuffer et vérifions les pressions sur les boutons "shield" ou "fire bullet". Nous utilisons la méthode DisplayBuffer.set() pour définir des objets pour un rendu ultérieur. Pour le rendu du bouclier, nous utilisons directement DisplayBuffer.set(), mais pour les balles et les envahisseurs, nous les ajoutons à leur liste respective et les définissons () un par un dans la boucle for avec le code suivant pour un rendu ultérieur avec DispBuffer.render():

pour b dans les puces: b.render(dispBuf) pour v dans vaders: v.render(dispBuf)

Tous les envahisseurs, les balles et le bouclier sont affichés une fois chaque itération de boucle principale avec

dispBuf.render()

Avant la fin de la boucle principale, nous vérifions si l'une des balles des envahisseurs a atteint la fin de l'écran, et si elles le sont, nous les supprimons de leurs listes respectives.

Étape 2: manette de jeu

BitPlayer est facile à tenir et à utiliser, avec un joystick à 2 axes comme les contrôleurs Gameboy ou PSP, il comprend également 6 autres boutons programmables étiquetés L, R, A, B, C et D. Pour une expérience immersive et interactive, le BitPlayer lui-même dispose d'un buzzer, d'un moteur de vibration et d'un port Grove I2C pour connecter des périphériques supplémentaires comme un écran OLED.

Nous n'utilisons que la bascule gauche-droite du joystick pour ce jeu, pour un exemple complet sur l'utilisation de tous les boutons BitPlayer, vous pouvez consulter joystick_example.py dans le référentiel GitHub de ce projet. Lors de la création de l'instance de la classe JoyStick, nous vérifions la lecture par défaut de l'axe X et stockons cette valeur dans self. Read_X. Ensuite, dans la fonction Listen_Dir, nous vérifions si l'écart par rapport à cette valeur par défaut est supérieur à la variable de sensibilité (essayez de le peaufiner vous-même, si vous pensez que JoyStick est trop sensible) et renvoyons True of False en fonction de la direction détectée.

Voyons un exemple concret de comment cela fonctionne:

Disons que notre lecture par défaut de l'axe X est 0. Ensuite, si nous déplaçons le joystick vers la droite:

New_X = JoyStick_X.read_analog() #New_X=200

Droite = New_X - self. Read_X #Right = 200 Left = self. Read_X - New_X #Left = -200

Ensuite, lorsque nous vérifions la direction:

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: renvoie True else: renvoie False

Étape 3: Tampon d'affichage

La classe DisplayBuf est responsable du contrôle de l'écran LED. Cela se fait à l'aide de deux méthodes, set() et render(). La méthode set() modifie les valeurs correspondant aux pixels de l'écran LED. Vous vous souvenez peut-être que les pixels sur l'écran LED Micro:bit peuvent être exprimés sous forme de chaîne ou de liste - "00000:000000:0000:00000:00000" est un écran vide. "00000:000000:0000:00000:00100" est un écran avec un pixel faiblement éclairé au centre de la rangée du bas.

00000:

00000

:00000

:00000:

00100"

Cette notation pourrait être plus facile à traiter:)

Ainsi, ce que nous faisons pendant la boucle principale est d'appeler la méthode set() de DisplayBuf pour définir tous nos objets qui doivent être affichés à l'écran. Ensuite, nous utilisons la méthode render () pour les afficher tous à l'écran simultanément.

Étape 4: les envahisseurs, les balles et le joueur

Les balles et les envahisseurs appartiennent à la classe Mover. Les instances de classe Mover ont leurs emplacements x, y et leur vitesse, ainsi que leur luminosité. La classe Mover a deux méthodes d'instance, set() et move(). La méthode set() appelle simplement la méthode DisplayBuf set() avec des coordonnées mises à jour à enregistrer pour un rendu ultérieur sur la matrice LED. La méthode move () met à jour les coordonnées de l'instance en fonction de la vitesse de l'instance - cela s'avère utile plus tard, lorsque nous devons modifier la vitesse des envahisseurs au fur et à mesure que les niveaux progressent.

La classe Bullet et la classe Invader sont des sous-classes de la classe Mover. Ici, nous utilisons quelque chose appelé héritage. La fonctionnalité de super() nous permet d'appeler des méthodes de la superclasse en sous-classe, sans avoir besoin de répéter le code.

Étape 5: Faites-en le vôtre

Toutes nos félicitations! Vous venez de recréer le jeu classique Space Invaders sur Micro:bit avec du matériel de jeu sympa. Bien sûr, vous pouvez améliorer le code du jeu à partir d'ici - par exemple, pour le moment, le jeu n'a qu'un seul niveau - vous pouvez en ajouter des plus difficiles. De plus, comme vous vous en souvenez peut-être, le jeu original a des rochers flottant devant le joueur, que vous pouvez également ajouter.

Si vous faites une version améliorée du jeu, partagez-la dans les commentaires ci-dessous ! Pour plus d'informations sur BitPlayer et d'autres matériels pour les fabricants et les éducateurs STEM, visitez notre site Web, https://tinkergen.com/ et abonnez-vous à notre newsletter.

TinkerGen a récemment créé une campagne Kickstarter pour MARK (Make A Robot Kit), un kit de robot pour enseigner le codage, la robotique, l'IA !

Le code Micropython original de hexkcd/micro-vaders a été modifié pour fonctionner avec TinkerGen BitPlayer.