P2E-FAST-GAME

De MCHobby - Wiki
Sauter à la navigation Sauter à la recherche
Page-under-construction.pngPage(s) en cours de traduction/élaboration.

Page(s) under translation/construction

Fast Game

Ce jeu du plus rapide se joue à deux joueurs.

Le but de chaque joueur étant de presser le plus rapidement possible son bouton une fois que le signal sonore est émis.

La LED du vainqueur clignotera avec un petite mélodie de victoire.

 

A noter que si un joueur presse son bouton avant le signal sonore alors ce dernier est automatiquement perdant (accompagné d'une petite mélodie funèbre).

Déroulement d'une partie

Le déroulement d'une partie est décrit par le diagramme ci-dessous:

 

Brancher

Réaliser les branchements suivants:

Pico Pico-2-Explorer
GP28 LED Rouge
GP27 Led Orange
GP26 LED Verte
GP21 Bouton 3
GP20 Bouton 2
GP19 Bouton 1
GP13 Buzzer

 

Code

Le script fastgame.py est disponible dans le dépôt dédié au Pico-2-Explorer.

Ce dernier est repris-ci dessous avec quelques commentaire sur son fonctionnement. 

  1 from micropython import const
  2 from random import randint
  3 from machine import Pin
  4 from rtplay import *
  5 import time
  6 
  7 START_SONG = "Counter Strike - Time Bomb : d=4,o=5,b=100:16c#7,8p,16c#7,8p,16c#7,8p,16c#7"
  8 WIN_SONG = "Black Robb - Whoa : d=4,o=5,b=100:16g,16p,16g6,16a#6,16a6,16a#6,16g6,16p,16g,16p,16g6,16a#6,16a6,16a#6,16g6"
  9 LOOSE_SONG = "dark:d=4,o=5,b=140:8f#6,8e6,2f#6,16e6,16d#6,16d6,16b,a#,1b" 
 10 
 11 class Blinky:
 12 	""" Just handle LED with blink state """
 13 	FIXED = const( 0 )
 14 	BLINK_SLOW = const( 500 ) # 500 ms
 15 	BLINK_FAST = const( 200 ) # 200 ms
 16 
 17 	def __init__( self, pin ):
 18 		self.pin = pin
 19 		self.off()
 20 
 21 	def on( self ):
 22 		self.interval = self.FIXED
 23 		self.last_update = time.ticks_ms()
 24 		self.pin.value( True )
 25 
 26 	def off( self ):
 27 		self.interval = self.FIXED
 28 		self.last_update = time.ticks_ms()
 29 		self.pin.value( False )
 30 
 31 	def blink( self, fast=False ):
 32 		self.interval = self.BLINK_FAST if fast else self.BLINK_SLOW
 33 		self.last_update = time.ticks_ms() 
 34 		self.pin.value( True )
 35 		
 36 
 37 	def update( self ):
 38 		if self.interval == self.FIXED:
 39 			return
 40 		if time.ticks_diff( time.ticks_ms(), self.last_update ) < self.interval:
 41 			return
 42 		self.pin.toggle()
 43 		self.last_update = time.ticks_ms()
 44 
 45 
 46 # === Player 1 / Joueur 1 =================================
 47 led1 = Blinky( Pin( Pin.board.GP28, Pin.OUT ) )
 48 btn1 = Pin( Pin.board.GP19, Pin.IN, Pin.PULL_UP )
 49 first_btn1 = None # first time btn1 was pressed
 50 def btn1_pressed( obj ):
 51 	global first_btn1
 52 	if first_btn1==None:
 53 		first_btn1 = time.ticks_ms()
 54 btn1.irq( trigger=Pin.IRQ_FALLING, handler=btn1_pressed )
 55 
 56 # === Player 2 / Joueur 2 =================================
 57 led2 = Blinky( Pin( Pin.board.GP26, Pin.OUT ) ) 
 58 btn2 = Pin( Pin.board.GP21, Pin.IN, Pin.PULL_UP )
 59 first_btn2 = None
 60 def btn2_pressed( obj ):
 61 	global first_btn2
 62 	if first_btn2==None:
 63 		first_btn2 = time.ticks_ms()
 64 btn2.irq( trigger=Pin.IRQ_FALLING, handler=btn2_pressed )
 65 
 66 # === Other / Autre =======================================
 67 # Start / Demarrer
 68 btn_start = Pin( Pin.board.GP20, Pin.IN, Pin.PULL_UP )
 69 # LED status / LED de Status
 70 led_status = Blinky( Pin( Pin.board.GP27, Pin.OUT ) )
 71 # Buzzer
 72 buzzer = RingTonePlayer( Pin.board.GP13 )
 73 
 74 # === Game / Jeux =========================================
 75 
 76 # Start Button ? / Boutons Start ?
 77 led_status.blink()
 78 while btn_start.value()==1:
 79 	led_status.update()
 80 	time.sleep_ms(20)
 81 led_status.off()
 82 
 83 while True:
 84 	# All LEDs on / Toutes LEDs allumées 
 85 	led1.on()
 86 	led2.on()
 87 	led_status.on()
 88 
 89 	# Init round / initialisation round
 90 	wait_ms = randint( 3, 10 )*1000
 91 	first_btn1 = None
 92 	first_btn2 = None
 93 	buzzer.play_str( START_SONG )
 94 
 95 	# The round is starting / debut du round
 96 	led1.off()
 97 	led2.off()
 98 	led_status.off()
 99 
100 	# Wait loop
101 	start_ms = time.ticks_ms()
102 	_led = None
103 	while time.ticks_diff( time.ticks_ms(), start_ms ) < wait_ms:
104 		time.sleep_ms(100)
105 		if (first_btn1!=None) or (first_btn2!=None):
106 			_led = led1 if first_btn1!= None else led2
107 			_led.on()
108 			buzzer.play_str( LOOSE_SONG ) # End of game
109 			break
110 
111 	# Still running the game ? / Le jeux continue encore ?
112 	if (first_btn1==None) and (first_btn2==None):
113 		# Go Signal 
114 		buzzer.play_tone( 2500, 500 )
115 
116 		# Wait the first player to press a button
117 		# Attendre le premier joueur qui presse son bouton
118 		while (first_btn1==None) and (first_btn2==None):
119 			time.sleep_ms( 20 )
120 
121 		# We have a Winnner / Nous avons un gagnant
122 		if first_btn1==None:
123 			_led = led2
124 		elif first_btn2==None:
125 			_led = led1
126 		else:
127 			_led = led1 if first_btn1<first_btn2 else led2
128 		_led.on()
129 		buzzer.play_str( WIN_SONG )
130 
131 	_led.blink()
132 
133 	# Start Button ? / Boutons Start ?
134 	while btn_start.value()==1:
135 		_led.update()
136 		time.sleep_ms(20)
137 	_led.off()

Quelques mots d'explications:

  • Lignes 11 à 43 : déclaration de la classe Blinky prenant en charge une broche (en sortie) afin d'allumer, éteindre une LED mais aussi pour la faire clignoter. L'appel régulier à la méthode update() fera en sorte de mettre à jour l'état de la LED au moment adéquat.
  • Ligne 47 : déclaration de la LED pour je joueur 1. L'utilisation de la classe Blinky permet de doter celle-ci d'un effet de clignotement.
  • Ligne 48 : déclaration du bouton pour le joueur 1. L'entrée en maintenue au niveau HAUT par la résistance PULL_UP interne. L'entrée passe au niveau bas quand le bouton est pressé.
  • Ligne 49 : déclaration de la variable first_btn1 pour le joueur 1. Cette variable est à None lorsque l'utilisateur n'a pas encore pressé le bouton. La première fois que l'utilisateur presse son bouton, cette variable contiendra le temps de la première pression sur le bouton.
  • Lignes 50 à 53 : définition de la fonction de rappel (callback en anglais) pour le bouton1. Celle-ci est appelée à chaque fois que le bouton 1 est pressé. La fonction vérifie si la variable `first_btn1` n'est pas initialisée, auquel cas le temps est stocké dans en lieu et place de None.
  • Ligne 54 : c'est sur cette ligne que le lien entre btn1 et sa fonction de rappel est réalisé. Tel que configuré, la fonction de btn1_pressed() est appelée lorsque le signal passe du niveau haut au niveau bas (flan descendant, dit "FALLING" en anglais) sur btn1. Le signal sur btn1 (GP19) passe effectivement au niveau bas lorsque le bouton est pressé.
  • Lignes 57 à 64 : sont identiques aux lignes 47 à 54 exception fait que cela s'applique au joueur 2 (donc led2, btn2, btn2_pressed).
  • Lignes 67 à 72 : initialisation des derniers éléments, le bouton "Start", la LED de statut et le `buzzer` comme élément sonore. La classe RingTonePlayer était abordé dans ce tutoriel.
  • Ligne 77 : configuration de la LED de statut led_status en mode clignotant (BLINK).
  • Lignes 78 à 80: boucle while attendant que l'on presse sur le bouton "Start". Dans l'attente l'appel à la méthode led_status.update() permet de faire clignoter la LED à intervalle régulier.
  • Ligne 81 : le bouton "Start" a été pressé, la LED de statut est éteinte.
  • Ligne 82 : boucle while infinie permettant de jouer round après round. Le corps du script situé entre les lignes 83 à 137 permet donc de jouer un round.

Exécution d'un round

  • Ligne 90 : utilisation de fonction randint(3,10) pour générer un nombre aléatoire entre 3 et 10 secondes. Cette valeur est multipliée par 1000 pour obtenir une valeur en millisecondes. Cette valeur est stockée dans la variable wait_ms .
  • Lignes 91 à 92 : réinitialiser les variables first_btn1 et first_btn2 à None (bouton pas encore pressé).
  • Ligne 93 : jouer la mélodie de début de jeu.
  • Ligne 101 : capture du nombre de millisecondes écoulée dans start_ms. Cela permet de mesurer l'écoulement du temps.
  • Ligne 102 : initialisation de la variable _led à None. Cette variable sera initialisée à led1 ou led2 pour désigner le joueur (gagnant ou perdant).
  • Lignes 103 à 109 : boucle d'attente de 0 à wait_ms millisecondes avant d'envoyer le signal "GO". Si un joueur presse son bouton durant ce laps de temps, alors la variable correspondant first_btnX est initialisée (donc différent de None).
  • Ligne 106 : expression ternaire qui initialise _led à led1 ou led2 en fonction du bouton pressé. Cela identifie le perdant!
  • Ligne 107 à 109 : allumer la LED du joueur perdant, jouer la musique "Perdu" et interrompre la boucle d'attente avec l'instruction break .
  • Ligne 111 : lorsque le script passe sur cette ligne: (1) soit le temps d'attente avant le GO est terminé, (2) soit un joueur a pressé sur son bouton avant le GO!
  • Ligne 112 : SI ni le bouton du joueur 1 et ni le bouton du joueur 2 ont été pressé ALORS le jeu continue entre les lignes 113 à 129 SINON nous avons un perdant et l'exécution se poursuit directement à la ligne 131.
  • Ligne 114 : émission du signal DO (une tonalité produite pendant 1/2 seconde).
  • Lignes 118 à 119 : boucle d'attente jusqu'à ce que l'un des deux boutons joueur soit pressé (donc que la variable first_btnX correspondante soit initialisée).
  • Lignes 122 à 117 : un des joueurs a pressé son bouton (si pas les deux joueurs). Les lignes suivantes vont identifier lequel de joueur 1 ou joueur 2 est le gagnant et assigner la variable _led avec la référence de la LED du joueur (donc soit led1, soit led2).
  • Lignes 128 et 129 : allumer la LED du joueur gagnant. LED identifiée par la variable _led. Ensuite, jouer la mélodie "Gagnant".
  • Ligne 131 : c'est a cette ligne que se rejoint le code du script gagnant et script perdant. La variable _led référence la LED du gagnant ou du perdant (selon le cas). L'instruction _led.blink() passe la LED en mode 'clignotant'. C'est la fin du round!
  • Lignes 134 à 136 : boucle d'attente de pression sur le bouton Start. L'appel à _led.update() prend en charge le clignotement de la LED du gagnant/perdant.
  • Ligne 137 : extinction de la LED et retour au début de la boucle while à la ligne 83 (pour le prochain).

Un problème?

xxx


Traduction augmentée réalisée par Meurisse. D pour shop.MCHobby.be - Licence CC-BY-SA.


MCHobby investit du temps et de l'argent dans la réalisation de traduction et/ou documentation. C'est un travail long et fastidieux réalisé dans l'esprit Open-Source... donc gratuit et librement accessible.
SI vous aimez nos traductions et documentations ALORS aidez nous à en produire plus en achetant vos produits chez MCHobby.
Récupérée de « https://wiki.mchobby.be/index.php?title=P2E-FAST-GAME&oldid=32961 »