De la neige en Python sur votre Pi Mini Screen

Avec l’hiver et Noël qui approchent, l’idée m’est venue de mettre un peu d’ambiance sur le Mini Pi Dash Screen en faisant tomber de la neige en Python avec PyGame. En rajoutant simplement quelques lignes de code, il est très facile en Python de simuler des flocons de neiges tombant et s’amassant en bas de l’écran.

Je me suis inspiré d’un ancien soft que je faisais tourner sur mes machines il y a longtemps, Xsnow.

Pour implémenter ces flocon qui tombe sur l’écran, le principe est simpliste au possible. Il s’agit tout bêtement de créer une liste de points (représentant chacun un flocon de neige), de leur attribuer à une coordonnée en X et Y sur l’écran, et d’incrémenter de quelques pixels leurs position en Y. Procédons.

Commençons par définir les variables clés :

screen_w = 800 # largeur en px de l'écran
screen_h = 480 # hauteur en px de l'écran

snow_floor_h = 13 # hauteur en px de la couche de neige en bas de l'écran
snow_flakes = 100 # nombre de flocons affichés en même temps

On initialise ensuite PyGame :

pygame.init()

pygame.mouse.set_visible(False)
pygame.display.set_caption('Liberty')
size = [screen_w, screen_h]
screen = pygame.display.set_mode(size)
clock = pygame.time.Clock()
screen.fill((0, 0, 0))
pygame.display.update()

start_time = 0
frame_count = 1
frame_rate = 10 # avec 10 images par secondes on obtient une chute de neige relativement fluide

On créé ensuite le tableau de flocons « snow_list », en leur attribuant à chacun des coordonnées aléatoires volontairement jusqu’à -10 et +10, par rapport à la largeur de l’écran) pour qu’ils apparaissent à peine en dehors de l’écran. En même temps on initialise un autre tableau « snow_floor » dans lequel on viendra placer les flocons qui tombent au moment où ils touchent le sol.

snow_list = []
snow_floor = []

for i in range(snow_flakes):
  x = random.randint(-10, screen_w+10)
  y = random.randint(-10, screen_h+10)
  snow_list.append([x, y])
  snow_floor.append([-10, -10])

Enfin, dans la boucle principale,

while True:

  # on remplit l'écran de noir
  screen.fill((0, 0, 0))

  # on dessine ensuite ce qui constitue la base de la couche de neige en bas de l'écran
  snow_floor_y=screen_h-snow_floor_h
  pygame.draw.rect(screen, WHITE, pygame.Rect(0, snow_floor_y, screen_w, snow_floor_h))
  
  # Ensuite, dessine les flocons un par un et on incrémente leurs coordonnées
  for i in range(len(snow_list)):
    
    # un simple cercle de 2px pour chaque flocons
    pygame.draw.circle(screen, WHITE, snow_list[i], 2)
    
    # les coordonnées en X sont aléatoirement modifiées entre -2 et +2 px pour éviter d'avoir une chute trop verticale.
    # si vous voulez ajouter un effet de vent latéral, vous pouvez par exemple modifier la coordonnées en X de -2 à +4 par exemple.
    snow_list[i][0] += random.randint(-2, 2)

    # les coordonnées en Y sont aléatoirement modifiées de +1 à +4 px pour avoir des vitesses de chute différentes et obtenir un rendu plus réaliste
    snow_list[i][1] += random.randint(1, 4)

    # si un flocon touche le sol, alors réinitialise s'est coordonnées pour qu'il reparte en haut de l'écran
    if snow_list[i][1] >= snow_floor_y:
      # coordonnée en X aléatoire sur toute la largeur de l'écran
      snow_list[i][0] = random.randint(-10, screen_w+10)
      # coordonnée en Y à -10 pour redémarrer à peine plus haut que le bord de l'écran
      snow_list[i][1] = -10
      # on copie les coordonnées du flocon dans la liste des flocons à afficher à la surface du sol
      snow_floor[i][0] = snow_list[i][0]
      snow_floor[i][1] = snow_list[i][1]
    # on dessine ensuite tous les flocon qui sont au sol
    pygame.draw.circle(screen, WHITE, snow_floor[i], 2)  

  frame_count += 1 
  clock.tick(frame_rate)
  pygame.display.flip()

Et voilà Il vous suffit d’implémenter ce morceau de code dans le celui du Mini Pi Dash Screen et le tour est joué !