Introduction

Dans ce projet, tu vas utiliser le Raspberry Pi Build HAT, un encodeur et une roue de moteur LEGO® Technic™, ainsi que la bibliothèque Python Turtle pour fabriquer un contrôleur de jeu simple que tu pourras utiliser pour jouer à Pong.

Note

Pong est l'un des premiers jeux vidéo d'arcade, sorti à l'origine en 1972 par Atari. Il s'agit d'un jeu de ping-pong aux graphismes simples en deux dimensions. Les joueurs contrôlent des palettes de chaque côté de l'écran, qu'ils utilisent pour frapper une balle dans un sens ou dans l'autre.

Tu vas:

Apprendre à lire les degrés de rotation des moteurs LEGO® Technic™.
Apprendre à dessiner et à déplacer des graphiques de tortue à l'aide de moteurs LEGO® Technic™.
Apprendre à détecter les collisions entre les graphiques à l'aide des coordonnées x et y.

Tu auras besoin de :

Un Raspberry Pi
Un Raspberry Pi Build HAT
Un moteur LEGO® Technic™

Logiciels

Python 3
La librairie Build HAT Python

Avant de commencer, tu dois avoir configuré ton ordinateur Raspberry Pi et attaché ton Build Hat:

Monte ton Raspberry Pi sur la plaque LEGO Maker à l'aide de boulons et d'écrous M2. Et assure-toi que le Raspberry Pi se trouve sur le côté sans le « bord » :

Le montage du Raspberry Pi de cette façon permet un accès facile aux ports ainsi qu'à l'emplacement de la carte SD. La plaque Maker te permettra de connecter plus facilement le Raspberry Pi à la structure principale de ton tableau de bord.

Aligne le Build HAT avec le Raspberry Pi, en t'assurant que tu pourras voir l'étiquette This way up. Assure-toi que toutes les broches GPIO sont couvertes par le HAT et appuye fermement.

Tu dois maintenant alimenter ton Raspberry Pi à l'aide de la prise jack 7,5V du Build HAT, ce qui tu permettras d'utiliser les moteurs.

Si tu ne l'as pas encore fait, configure ton Raspberry Pi en suivant ces instructions :

Configuration du Raspberry Pi

Une fois que le Raspberry Pi a démarré, ouvre l'outil de configuration du Raspberry Pi en cliquant sur le bouton Raspberry Menu et en sélectionnant « Preferences » puis « Raspberry Pi Configuration ».

Clique sur l'onglet “interfaces” et met les option comme l'image si dessous:

Tu vas devoir installer la librairie Python pour le build Hat avec la commande suivante:

Ouvre une fenêtre de terminal sur ton Raspberry Pi en pressant Ctrl+Alt+T.

A l'invite de commande, tape:

sudo apt install python3-build-hat

Appuie sur Enter et attend le message “installation completed”.

Utilise les codeurs de moteur LEGO® Spike™

Les codeurs de moteur peuvent non seulement tourner, mais aussi détecter avec précision le nombre de degrés de rotation, dont ils ont été tournés.

Les moteurs LEGO® Spike™ sont tous équipés de codeurs. Si tu regardes la partie du disque rotatif du moteur, tu verras une marque en forme de sucette qui peut être alignée avec la marque 0 sur le corps blanc du moteur lui-même. Il s'agit de l'encodeur réglé sur zéro degré et tout mouvement angulaire de l'arbre du moteur peut être détecté et mesuré par rapport à ce point.

Fonctionnement des codeurs de moteur

Connecte un moniteur, un clavier et une souris à ton Raspberry Pi.

Connecte ton Build HAT à ton Raspberry Pi avec le logo imprimé vers le haut, en t'assurant que tu as correctement recouvert toutes les broches.

Enfin, connecte l'alimentation, soit par la prise Build HAT barrel jack, soit par le port USB-C du Raspberry Pi.

Connecte un moteur au port A du Build HAT.

Fixe une grande roue au moteur à l'aide de quatre chevilles de connexion. Tourne la roue de manière à ce que la marque de la sucette soit alignée avec le zéro.

Ouvre Thonny à partir du menu de programmation du Raspberry Pi et clique sur la boîte Shell au bas de la fenêtre.

Tout d'abord, importe la bibliothèque Build HAT.

from buildhat import Motor

Appuie sur Enter.

Ensuite, crée un objet moteur qui indique à Python que le moteur est connecté au port A.

Tape:

from buildhat import Motor

motor_left = Motor('A')

Appuie sur Enter. (Il y aura un léger retard, sois patient !)

Tu peux maintenant demander au moteur d'indiquer sa position absolue. Cette sera toujours entre -180 et 180.

from buildhat import Motor

motor_left = Motor('A')
motor_left.get_aposition()

Selon la façon dont tu as positionné le moteur au départ, tu devrais obtenir une valeur proche de 0.

Déplace le moteur et lance le programme une deuxième fois pour voir comment la valeur change.

Tu peux également suivre la position relative du moteur. Il s'agit de la distance à laquelle il s'est déplacé depuis le début du programme, et elle augmentera ou diminuera donc de 360 pour chaque tour de roue.

from buildhat import Motor

motor_left = Motor('A')
motor_left.get_aposition()
motor_left.get_position()

Déplace le moteur et vérifie ses positions absolues et relatives, afin de comprendre comment les valeurs changent.

Réagir au mouvement du codeur moteur

Pour utiliser les moteurs LEGO® Technic™ comme contrôleur pour un jeu, tu devras être capable de lire constamment leurs positions absolues.

Dans la fenêtre principale de Thonny au-dessus du shell, tu peux utiliser les commandes que tu connais déjà pour trouver la position absolue du moteur. Ensuite, dans une boucle while True:, tu peux imprimer la valeur de la position.

                from buildhat import Motor

motor_left = Motor('A')

while True:
    print(motor_left.get_aposition())

tu devrais voir que ton programme imprime continuellement la position du moteur. Si tu fais pivoter le moteur, ces valeurs devraient changer.

Il y a cependant une meilleure façon de faire cela. Tu n'as besoin de lire la position du moteur que s'il est déplacé.

Supprime la boucle while True de ton programme et créez cette simple fonction qui imprime la position absolue du moteur. Tu devras également ajouter une autre ligne d'importation pour utiliser la fonction pause().

                from buildhat import Motor
from signal import pause

motor_left = Motor('A')

def moved_left(motor_speed, motor_pos, motor_apos):
    print(motor_apos)

Ouvre Thonny depuis le menu Programmation de Raspberry Pi et clique sur la boîte Shell en bas de la fenêtre.

Tout d'abord, importe la bibliothèque Build HAT.

                from buildhat import Motor

Appuyez sur Entrée.

Maintenant, définis cette fonction pour qu'elle s'exécute lorsque le codeur du moteur est déplacé:

                from buildhat import Motor
from signal import pause

motor_left = Motor('A')

def moved_left(motor_speed, motor_pos, motor_apos):
    print(motor_apos)

motor_left.when_rotated = moved_left
pause()

Exécute ton code et tu devrais voir les valeurs imprimées dans le shell changer lorsque le moteur est déplacé.

Sauvegarde ton projet.

Crée ton écran Pong

Turtle est une bibliothèque de dessin et d'animation, et tu peux en apprendre davantage à ce sujet avec cet excellent projet.

Tout d'abord, crée une fenêtre où le jeu se déroulera.

Ouvre un nouveau fichier dans Thonny et ajoute le code suivant pour importer les bibliothèques Turtle, time et Build HAT, puis configure un écran. Exécute le fichier et tu devrais voir une fenêtre noire avec le titre "PONG". Tu n'as pas besoin d'inclure les commentaires #.

                from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

La bibliothèque Turtle dispose également d'un moyen utile de définir les coordonnées pour une zone d'écran. Ajoute cette ligne à ton programme :

Ajoute cette dernière ligne dans le fichier.

                                    from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

Cela crée une fenêtre rectangulaire de 400 pixels de large et 340 de haut, avec 0 au centre.

Maintenant, tu dois mettre à jour ta zone de jeu pour voir la raquette et la balle. Ajoute une boucle de jeu en bas de ton code et appele la méthode update().

                                    from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)
                                        
while True:
    game_area.update()

Exécute ton code et tu devrais voir une fenêtre noire apparaître.

Ensuite, tu peux créer une balle en utilisant une Turtle configurée pour être un cercle blanc. La balle doit commencer au milieu de l'écran et ne doit pas tracer une ligne lorsqu'elle bouge.

Au-dessus de ta boucle while True, ajoute le code suivant :

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                                                            
while True:
    game_area.update()

Exécute à nouveau ton code. Tu devrais voir une balle blanche apparaître dans ta fenêtre.

Ensuite, tu peux configurer une raquette de la même manière. Elle sera un rectangle vert, positionné à l'extrême gauche de l'écran.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)

paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)
                                                                            
while True:
    game_area.update()

Exécute ton code et tu devrais voir ta balle et ta raquette.

Sauvegarde ton projet.

Déplacer la balle

La balle va rebondir autour de l'écran, donc deux variables sont nécessaires pour suivre sa vitesse dans les directions x et y. Ces nombres peuvent être augmentés pour rendre le jeu plus difficile, ou réduits pour le rendre plus facile.

Ajoute le code suivant à ton programme :

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 1
ball.speed_y = 1

while True:
    game_area.update()

Tu peux vérifier où se trouve une Turtle en utilisant turtle.xcor() et turtle.ycor() pour trouver respectivement les coordonnées x et y.

Donc, pour faire bouger la balle, tu peux combiner la position et la vitesse.

Ajoute les lignes ci-dessous à ton programme :

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 1
ball.speed_y = 1

while True:
    game_area.update()

    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

Exécute le programme et vois ce qui se passe !

La balle devrait se déplacer en diagonale vers le coin supérieur droit de la zone de jeu et continuer. Si tu veux que ton jeu soit rapide et difficile, tu peux augmenter les valeurs speed_x et speed_y pour faire bouger la balle plus rapidement.

La balle devrait rebondir sur le mur supérieur plutôt que de disparaître de l'écran. Pour ce faire, la vitesse peut être inversée, faisant voyager la balle dans la direction opposée si sa position y est supérieure à 160.

Ajoute le code suivant dans ta boucle de jeu et exécute-le.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 1
ball.speed_y = 1

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

Exécute à nouveau ton code, et la balle devrait rebondir sur le haut de l'écran, mais disparaître sur le côté droit de l'écran.

De la même manière que le code vérifie la position y supérieure de la balle pour la faire rebondir, il peut vérifier la position x droite et la position y inférieure, dans ta boucle de jeu.

Ajoute ces vérifications sur la position de la balle.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 1
ball.speed_y = 1

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1

La balle devrait maintenant rebondir autour de l'écran et s'envoler par le bord gauche. Ensuite, tu contrôleras ta raquette pour renvoyer la balle depuis le bord gauche.

Sauvegarde ton projet.

Contrôler la raquette

Conception des commandes

Le moteur LEGO® Spike™ sera utilisé pour contrôler la position de la raquette, mais tu ne veux pas pouvoir faire des tours complets.

Un moyen simple de limiter le mouvement de la roue consiste à ajouter un élément LEGO® pour empêcher la roue de tourner complètement.

Aligne les marques du codeur sur ton moteur en utilisant la roue, comme auparavant. Insére une cheville ou un axe aussi près que possible du niveau des marqueurs.

Ajoute une ligne pour créer l'objet motor_left après la ligne d'importation.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 1
ball.speed_y = 1

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1

Maintenant, une nouvelle variable est nécessaire pour suivre l'emplacement de la raquette. Elle sera appelée pos_left et définie sur 0.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1

Crée une fonction pour la raquette qui s'exécutera lorsque le codeur moteur bouge. Note qu'elle utilise une variable global pour pouvoir changer la valeur de la variable pos_left.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0

def moved_left(motor_speed, motor_rpos, motor_apos):
    global pos_left
    pos_left = motor_apos

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1

Ajoute maintenant une ligne unique qui utilisera cette fonction à chaque fois que le moteur est déplacé. Elle peut être juste avant ta boucle while.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0

def moved_left(motor_speed, motor_rpos, motor_apos):
    global pos_left
    pos_left = motor_apos
    
motor_left.when_rotated = moved_left

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1

Ensuite, ajoute une ligne à la boucle while True pour mettre à jour l'objet raquette sur l'écran à la nouvelle position.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0

def moved_left(motor_speed, motor_rpos, motor_apos):
    global pos_left
    pos_left = motor_apos
    
motor_left.when_rotated = moved_left

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1

    paddle_left.sety(pos_left)

Exécute ton code puis tourne la roue de ton codeur moteur. Tu devrais voir ta raquette monter et descendre sur l'écran.

Sauvegarde ton projet.

Collisions de la raquette

Le jeu est presque terminé - mais d'abord, tu dois ajouter une détection de collision supplémentaire qui couvre la balle frappant la raquette.

Dans la boucle while True, vérifie si la position x de la balle se trouve dans la zone horizontale couverte par la raquette. Utilise également un and pour vérifier que la position y de la balle se trouve dans la ligne verticale dans laquelle la raquette se déplace.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0

def moved_left(motor_speed, motor_rpos, motor_apos):
    global pos_left
    pos_left = motor_apos
    
motor_left.when_rotated = moved_left

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1

paddle_left.sety(pos_left)
    
    if (ball.xcor() < -180 and ball.xcor() > -190) and (ball.ycor() < paddle_left.ycor() + 20 and ball.ycor() > paddle_left.ycor() - 20):
        ball.setx(-180)
        ball.speed_x *= -1

Essaye le programme. tu devrais pouvoir faire rebondir la balle sur ta raquette et jouer à un jeu solo de "squash"!

Maintenant que tu as un moyen d'empêcher la balle de disparaître de l'écran, il est temps de penser à ce qui se passe si tu ne parviens pas à faire une sauvegarde.

Pour l'instant, réinitialisons simplement la balle à son point de départ.

Ajoute ce code dans la boucle while True:

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0

def moved_left(motor_speed, motor_rpos, motor_apos):
    global pos_left
    pos_left = motor_apos
    
motor_left.when_rotated = moved_left

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1
    
    paddle_left.sety(pos_left)
    
    if (ball.xcor() < -180 and ball.xcor() > -190) and (ball.ycor() < paddle_left.ycor() + 20 and ball.ycor() > paddle_left.ycor() - 20):
        ball.setx(-180)
        ball.speed_x *= -1

    if ball.xcor() < -195: #Left
        ball.hideturtle()
        ball.goto(0,0)
        ball.showturtle()

Une fois que tu es satisfait des différents paramètres, il est temps d'ajouter la deuxième raquette.

En utilisant ce que tu as créé pour la raquette de gauche comme point de départ, ajoute une deuxième raquette sur le côté droit de la zone de jeu.

Tout d'abord, connecte un deuxième moteur LEGO® Technic™ au Build HAT (port B) et configure-le dans le programme.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')
motor_right = Motor('B')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0

def moved_left(motor_speed, motor_rpos, motor_apos):
    global pos_left
    pos_left = motor_apos
    
motor_left.when_rotated = moved_left

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1
   
    paddle_left.sety(pos_left)
    
    if (ball.xcor() < -180 and ball.xcor() > -190) and (ball.ycor() < paddle_left.ycor() + 20 and ball.ycor() > paddle_left.ycor() - 20):
        ball.setx(-180)
        ball.speed_x *= -1
        
    if ball.xcor() < -195: #Left
        ball.hideturtle()
        ball.goto(0,0)
        ball.showturtle()

Tu peux copier et coller ton code pour configurer ta raquette gauche, et changer le nom et les valeurs pour ta raquette droite.

Crée ta raquette droite.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')
motor_right = Motor('B')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

paddle_right = Turtle()
paddle_right.color('blue')
paddle_right.shape("square")
paddle_right.shapesize(4,1,1)
paddle_right.penup()
paddle_right.setpos(190,0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0

def moved_left(motor_speed, motor_rpos, motor_apos):
    global pos_left
    pos_left = motor_apos
    
motor_left.when_rotated = moved_left

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1
    
    paddle_left.sety(pos_left)
    
    if (ball.xcor() < -180 and ball.xcor() > -190) and (ball.ycor() < paddle_left.ycor() + 20 and ball.ycor() > paddle_left.ycor() - 20):
        ball.setx(-180)
        ball.speed_x *= -1
        
    if ball.xcor() < -195: #Left
        ball.hideturtle()
        ball.goto(0,0)
        ball.showturtle()

Ajoute une variable pour la position de la raquette droite, une fonction pour la raquette et la ligne pour appeler la fonction lorsque le moteur droit est déplacé.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')
motor_right = Motor('B')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

paddle_right = Turtle()
paddle_right.color('blue')
paddle_right.shape("square")
paddle_right.shapesize(4,1,1)
paddle_right.penup()
paddle_right.setpos(190,0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0
pos_right = 0

def moved_left(motor_speed, motor_rpos, motor_apos):
    global pos_left
    pos_left = motor_apos

def moved_right(motor_speed, motor_rpos, motor_apos):
    global pos_right
    pos_right = motor_apos

motor_left.when_rotated = moved_left
motor_right.when_rotated = moved_right

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1
    
    paddle_left.sety(pos_left)
    
    if (ball.xcor() < -180 and ball.xcor() > -190) and (ball.ycor() < paddle_left.ycor() + 20 and ball.ycor() > paddle_left.ycor() - 20):
        ball.setx(-180)
        ball.speed_x *= -1
        
    if ball.xcor() < -195: #Left
        ball.hideturtle()
        ball.goto(0,0)
        ball.showturtle()

Ajoute une ligne pour mettre à jour la raquette à l'écran dans la boucle while True:

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')
motor_right = Motor('B')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

paddle_right = Turtle()
paddle_right.color('blue')
paddle_right.shape("square")
paddle_right.shapesize(4,1,1)
paddle_right.penup()
paddle_right.setpos(190,0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0
pos_right = 0

def moved_left(motor_speed, motor_rpos, motor_apos):
    global pos_left
    pos_left = motor_apos

def moved_right(motor_speed, motor_rpos, motor_apos):
    global pos_right
    pos_right = motor_apos

motor_left.when_rotated = moved_left
motor_right.when_rotated = moved_right

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1

    paddle_left.sety(pos_left)
    paddle_right.sety(pos_right)
    
    if (ball.xcor() < -180 and ball.xcor() > -190) and (ball.ycor() < paddle_left.ycor() + 20 and ball.ycor() > paddle_left.ycor() - 20):
        ball.setx(-180)
        ball.speed_x *= -1
        
    if ball.xcor() < -195: #Left
        ball.hideturtle()
        ball.goto(0,0)
        ball.showturtle()

Actuellement, la balle rebondira sur le mur droit. Modifie les lignes de ton programme qui le font pour que la balle soit plutôt réinitialisée au centre.

Change la condition pour le xcor de la balle afin qu'elle se réinitialise.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')
motor_right = Motor('B')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

paddle_right = Turtle()
paddle_right.color('blue')
paddle_right.shape("square")
paddle_right.shapesize(4,1,1)
paddle_right.penup()
paddle_right.setpos(190,0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0
pos_right = 0

def moved_left(motor_speed, motor_rpos, motor_apos):
    global pos_left
    pos_left = motor_apos

def moved_right(motor_speed, motor_rpos, motor_apos):
    global pos_right
    pos_right = motor_apos

motor_left.when_rotated = moved_left
motor_right.when_rotated = moved_right

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1
    
    paddle_left.sety(pos_left)
    paddle_right.sety(pos_right)
    
    if (ball.xcor() < -180 and ball.xcor() > -190) and (ball.ycor() < paddle_left.ycor() + 20 and ball.ycor() > paddle_left.ycor() - 20):
        ball.setx(-180)
        ball.speed_x *= -1
        
    if ball.xcor() < -195: #Left
        ball.hideturtle()
        ball.goto(0,0)
        ball.showturtle()
    
    if ball.xcor() > 195:
        ball.hideturtle()
        ball.goto(0,0)
        ball.showturtle()

Ajoute maintenant une condition similaire pour la raquette droite comme tu l'as fait pour la gauche, pour gérer les collisions.

from turtle import Screen, Turtle
from time import sleep
from buildhat import Motor

motor_left = Motor('A')
motor_right = Motor('B')

game_area = Screen() #Créer un écran
game_area.title("PONG") #Donner un titre à l'écran
game_area.bgcolor('black') #Définir la couleur de fond
game_area.tracer(0) #Donner des animations plus fluides

game_area.setworldcoordinates(-200, -170, 200, 170)

ball = Turtle()
ball.color('white')
ball.shape('circle')
ball.penup()
ball.setpos(0,0)
                                    
paddle_left = Turtle()
paddle_left.color('green')
paddle_left.shape('square')
paddle_left.shapesize(4, 1, 1)
paddle_left.penup()
paddle_left.setpos(-190, 0)

paddle_right = Turtle()
paddle_right.color('blue')
paddle_right.shape("square")
paddle_right.shapesize(4,1,1)
paddle_right.penup()
paddle_right.setpos(190,0)

ball.speed_x = 0.4
ball.speed_y = 0.4

pos_left = 0
pos_right = 0

def moved_left(motor_speed, motor_rpos, motor_apos):
    global pos_left
    pos_left = motor_apos

def moved_right(motor_speed, motor_rpos, motor_apos):
    global pos_right
    pos_right = motor_apos

motor_left.when_rotated = moved_left
motor_right.when_rotated = moved_right

while True:
    game_area.update()
    
    ball.setx(ball.xcor() + ball.speed_x)
    ball.sety(ball.ycor() + ball.speed_y)

    if ball.ycor() > 160:
        ball.speed_y *= -1

    if ball.xcor() > 195:
        ball.speed_x *= -1

    if ball.ycor() < -160:
        ball.speed_y *= -1

    paddle_left.sety(pos_left)
    paddle_right.sety(pos_right)
    
    if (ball.xcor() < -180 and ball.xcor() > -190) and (ball.ycor() < paddle_left.ycor() + 20 and ball.ycor() > paddle_left.ycor() - 20):
        ball.setx(-180)
        ball.speed_x *= -1

    if (ball.xcor() > 180 and ball.xcor() < 190) and (ball.ycor() < paddle_right.ycor() + 20 and ball.ycor() > paddle_right.ycor() - 20):
        ball.setx(180)
        ball.speed_x *= -1
        
    if ball.xcor() < -195: #Left
        ball.hideturtle()
        ball.goto(0,0)
        ball.showturtle()
    
    if ball.xcor() > 195:
        ball.hideturtle()
        ball.goto(0,0)
        ball.showturtle()

Tu devrais maintenant pouvoir profiter d'un jeu basique à deux joueurs de Pong.

Sauvegarde ton projet.