TP Snake en python⚓

Langage python

Les variables permettent de stocker les valeurs

1
x = 4
2
y = 2

Ici, x et y représentent une position sur l’écran.

Les conditions if

Permet de prendre une décision.

1
if condition:
2
    action

Exemple

1
if x > 0:
2
    x = x - 1

Si x est supérieur à 0, on le diminue.

Avec plusieurs cas :

1
if direction == "left":
2
    x -= 1
3
elif direction == "right":
4
    x += 1

  • pas de parenthèses

  • : obligatoire

  • indentation obligatoire

Boucle while : Permet de répéter une action tant qu’une condition est vraie.

1
while condition:
2
    action

Exemple :

1
x = 0
2
3
while x < 8:
4
    print(x)
5
    x = x + 1
La boucle s’exécute tant que x < 8
Dans un jeu :
1
while True:
2
    # boucle infinie
Boucle for : Permet de parcourir une liste.
1
for element in liste:
2
    action
Exemple :
1
for i in range(8):
2
    print(i)
Affiche les nombres de 0 à 7.
Exemple avec le Sense HAT :
1
for x in range(8):
2
    sense.set_pixel(x, 2, (255, 0, 0))
Dessine une ligne rouge.
Les tuples :
Un tuple est un groupe de valeurs.
Exemple :
1
position = (4, 3)
Accès aux valeurs :
1
x = position[0]
2
y = position[1]
  • un tuple est non modifiable
  • utilisé pour stocker des coordonnées
Les listes :
Une liste contient plusieurs éléments.
1
snake = [(4,4), (3,4), (2,4)]
représente un serpent de 3 segments
Accès :
1
head = snake[0]
premier élément = tête
Ajouter un élément
1
snake.insert(0, (5,4))
Ajoute en début de liste
Supprimer un élément
1
snake.pop()
Application au Snake :
Principe du déplacement
1
snake = [(4,4), (3,4), (2,4)]
2
3
new_head = (5,4)
4
5
snake.insert(0, new_head)
6
snake.pop()
  • La tête avance
  • La queue disparaît
  • Le serpent se déplace
Programmer un serpent avec le Sense HAT
  • manipuler une liste en Python
  • représenter un objet (serpent) avec plusieurs coordonnées
  • gérer un déplacement avec mémoire de direction
  • utiliser le joystick
  • mettre à jour un affichage dynamique
Rappel : déplacer un point
Créer 01_point.py
1
from sense_hat import SenseHat
2
from time import sleep
3
4
sense = SenseHat()
5
6
vert = (0, 255, 0)
7
8
x = 4
9
y = 4
10
11
while True:
12
    events = sense.stick.get_events()
13
14
    for event in events:
15
        if event.action == "pressed":
16
            if event.direction == "left" and x > 0:
17
                x -= 1
18
            elif event.direction == "right" and x < 7:
19
                x += 1
20
            elif event.direction == "up" and y > 0:
21
                y -= 1
22
            elif event.direction == "down" and y < 7:
23
                y += 1
24
25
    sense.clear()
26
    sense.set_pixel(x, y, vert)
27
    sleep(0.05)
Créer un serpent (structure de données)
Un serpent = plusieurs segments.
On va utiliser une liste :
1
snake = [(4,4), (3,4), (2,4)]
tête = premier élément
corps = reste
Créer 02_snake_affichage.py
1
from sense_hat import SenseHat
2
from time import sleep
3
4
sense = SenseHat()
5
6
vert = (0, 255, 0)
7
8
snake = [(4,4), (3,4), (2,4)]
9
10
while True:
11
    sense.clear()
12
13
    for segment in snake:
14
        x = segment[0]
15
        y = segment[1]
16
        sense.set_pixel(x, y, vert)
17
18
    sleep(0.3)
Combien de pixels sont affichés ?
Pourquoi utilise-t-on une boucle for ?
Modifier la position du serpent.
Déplacer le serpent automatiquement
Principe fondamental du snake :
ajouter une nouvelle tête
supprimer la queue
Exemple : 
1
snake = [(4,4), (3,4), (2,4)]
2
3
nouvelle_tete = (5,4)
4
5
snake.insert(0, nouvelle_tete)
6
snake.pop()
Créer 03_snake_move_auto.py
1
from sense_hat import SenseHat
2
from time import sleep
3
4
sense = SenseHat()
5
6
vert = (0, 255, 0)
7
8
snake = [(4,4), (3,4), (2,4)]
9
10
while True:
11
    head = snake[0]
12
13
    new_head = (head[0] + 1, head[1])
14
15
    snake.insert(0, new_head)
16
    snake.pop()
17
18
    sense.clear()
19
20
    for segment in snake:
21
        sense.set_pixel(segment[0], segment[1], vert)
22
23
    sleep(0.5)
Ajouter le joystick
Maintenant on contrôle la direction.
Nouvelle variable
1
direction = "right"
Créer 04_snake_control.py
1
from sense_hat import SenseHat
2
from time import sleep
3
4
sense = SenseHat()
5
6
vert = (0, 255, 0)
7
8
snake = [(4,4), (3,4), (2,4)]
9
direction = "right"
10
11
while True:
12
    events = sense.stick.get_events()
13
14
    for event in events:
15
        if event.action == "pressed":
16
            if event.direction == "left":
17
                direction = "left"
18
            elif event.direction == "right":
19
                direction = "right"
20
            elif event.direction == "up":
21
                direction = "up"
22
            elif event.direction == "down":
23
                direction = "down"
24
25
    head = snake[0]
26
27
    if direction == "right":
28
        new_head = (head[0] + 1, head[1])
29
    elif direction == "left":
30
        new_head = (head[0] - 1, head[1])
31
    elif direction == "up":
32
        new_head = (head[0], head[1] - 1)
33
    elif direction == "down":
34
        new_head = (head[0], head[1] + 1)
35
36
    snake.insert(0, new_head)
37
    snake.pop()
38
39
    sense.clear()
40
41
    for segment in snake:
42
        sense.set_pixel(segment[0], segment[1], vert)
43
44
    sleep(0.3)
Attention : Problème volontaire
Le serpent peut sortir de l’écran.
Ajouter les limites empêcher demi-tour
1
if new_head[0] < 0 or new_head[0] > 7:
2
    break
Faire pareil pour y
Interdit de passer de droite à gauche directement
Ajouter cible pixel rouge - si tête touche cible → ne pas faire `pop()`