Sound added!

broadcasters/__init__.py

@@ -31,10 +31,32 @@ def start_outputs(system_queue, demo_output_queue):
         logger.warning("Unable to import modules necessary to run MQTT output.")
         logger.warning("Program will continue to run without this output.")
 
+    try:
+        logger.info("Loading pygame.mixer output...")
+        from . import pygame_mixer_bc
+
+        pygame_mixer_q = Queue()
+
+        pygame_mixer_runner = None
+        if pygame_mixer_bc.check_if_available():
+            pygame_mixer_runner = pygame_mixer_bc.start_processing_output(
+                system_queue, pygame_mixer_q
+            )
+        logger.info("...done")
+    except (ImportError, ModuleNotFoundError) as e:
+        pygame_mixer_runner = None
+        logger.warning(e)
+        logger.warning("Unable to import modules necessary to run keyboard input.")
+        logger.warning("Program will continue to run without this input.")
+
     while True:
         for payload in utils.get_all_from_queue(demo_output_queue):
             if mqtt_runner:
                 mqtt_q.put(payload)
                 next(mqtt_runner)
 
+            if pygame_mixer_runner:
+                pygame_mixer_q.put(payload)
+                next(pygame_mixer_runner)
+
         yield

broadcasters/pygame_mixer_bc.py

@@ -0,0 +1,45 @@
+from loguru import logger
+from pygame import mixer
+
+from . import utils
+
+
+def check_if_available():
+    try:
+        mixer.init()
+        return True
+    except:
+        return False
+
+
+def start_processing_output(system_queue, pygame_mixer_q):
+    """Called by the broadcaster module to initialize a connection to a loudspeaker local to the system."""
+
+    def process():
+        # Go through and see what sounds we need to add
+        while True:
+            try:
+                for item in utils.get_all_from_queue(pygame_mixer_q):
+                    logger.debug("pygame_mixer: {}", item)
+                    if str(item).startswith("SOUND "):
+                        new_sound = str(item)[6:]
+
+                        short_Sound = mixer.Sound(new_sound)
+                        short_Sound.play()
+
+                        # if new_sound != current_sound:
+                        #     current_sound = new_sound
+                        #     mixer.Sound.load(new_sound)
+                        # mixer.Sound.play()
+                    elif str(item).startswith("BACKGROUND SOUND "):
+                        new_sound = str(item)[17:]
+                        mixer.music.load(new_sound)
+                        mixer.music.play(-1)
+                    elif str(item).startswith("STOP SOUND"):
+                        mixer.music.stop()
+            except:
+                logger.warning("Unable to play sound file: {}".format(new_sound))
+
+            yield
+
+    return process()

demos/breakout/main.py

@@ -2,6 +2,7 @@
 from random import getrandbits
 
 from demos.utils import get_all_from_queue
+from sss_sounds import sss_sounds
 
 ARENA_START = 14
 ARENA_END = ARENA_START - 15
@@ -73,6 +74,7 @@ def run(self):
         while True:
             try:
                 if self.input_queue.get(block=False) == "START_P":
+                    self.output_queue.put("SOUND " + sss_sounds.BEEP_06_GOOD)
                     break
             except queue.Empty:
                 pass
@@ -143,6 +145,8 @@ def run(self):
                             score += SCORE_INC
                             self.output_queue.put("SCORE " + str(score))
 
+                            self.output_queue.put("SOUND " + sss_sounds.TICK)
+
                             self.bricks[row].remove(self.ball[0])
                             screen.draw_pixel(self.ball[0], row, PIXEL_OFF)
                             if not self.ball[0] % 2:
@@ -161,6 +165,8 @@ def run(self):
                             self.output_queue.put("LIVES " + str(lives))
                         self.init_screen(screen)
 
+                        self.output_queue.put("SOUND " + sss_sounds.LEVEL_UP)
+
                 screen.draw_pixel(self.ball[0], self.ball[1], PIXEL_OFF)
 
                 # Bounds check for ball
@@ -178,6 +184,8 @@ def run(self):
                         self.frame_rate = 20 + (spin // (1 + spin // 2))
                         is_down = False
 
+                        self.output_queue.put("SOUND " + sss_sounds.BEEP_15)
+
                 # Checks to see if ball falls out of screen
                 if self.ball[1] >= screen.y_height - 1:
                     is_down = True
@@ -191,9 +199,13 @@ def run(self):
                     )
                     if lives == 0:
                         self.gameover = True
+
+                        self.output_queue.put("SOUND " + sss_sounds.END_FAIL_7)
                         break
                     self.ball = [screen.x_width // 2, screen.y_height // 2]
 
+                    self.output_queue.put("SOUND " + sss_sounds.END_FAIL_6)
+
                 # Calculates ball path
                 is_left, is_down = self.ball_travel(is_left, is_down, spin, screen)
 

demos/hangman/main.py

@@ -3,6 +3,7 @@
 from demos.hangman.guess import Guess
 from demos.hangman.trace import Trace
 from demos.utils import get_all_from_queue
+from sss_sounds import sss_sounds
 
 
 class Hangman:
@@ -53,6 +54,8 @@ def run(self):
 
         # Create generator here
         while True:
+            self.output_queue.put("SOUND " + sss_sounds.BEEP_01)
+
             trace.draw_init()
             trace.draw_choice(guess.letter_select(choice), True)
             word = guess.pick_word(seed_num)
@@ -87,12 +90,16 @@ def run(self):
                         for i in range(len(word)):
                             trace.draw_letter(i, word[i], True)
 
+                        self.output_queue.put("SOUND " + sss_sounds.END_FAIL_7)
+
                     # Check to see if the player has guessed all the letters in the word and the game is over
                     if num_correct == 5:
                         self.gameover = True
                         self.win = True
                         trace.draw_endgame(True)
 
+                        self.output_queue.put("SOUND " + sss_sounds.BEEP_06_GOOD)
+
                     # If the player presses the LEFT key then the game will scroll through the alphabet backwards
                     if repeat_left:
                         trace.draw_choice(guess.letter_select(choice), False)
@@ -103,6 +110,8 @@ def run(self):
                             choice = choice - 1
                             trace.draw_choice(guess.letter_select(choice), True)
 
+                        self.output_queue.put("SOUND " + sss_sounds.TICK)
+
                     # If the player pressed the RIGHT key then the game will scroll through the alphabet forwards
                     if repeat_right:
                         trace.draw_choice(guess.letter_select(choice), False)
@@ -113,6 +122,8 @@ def run(self):
                             choice = choice + 1
                             trace.draw_choice(guess.letter_select(choice), True)
 
+                        self.output_queue.put("SOUND " + sss_sounds.TICK)
+
                     # If the player pressed the START key then the game will check to see if that letter is in the word
                     # If the letter is in the word then the num_correct will increment
                     # If the letter is not in the word then the num_errors will increment
@@ -129,6 +140,10 @@ def run(self):
                                 correct = True
                                 num_correct += 1
                                 guess.add_guess_list(guess.letter_select(choice))
+
+                                if num_correct < 5:
+                                    self.output_queue.put("SOUND " + sss_sounds.BEEP_10)
+
                         if correct == False and guessed == False:
                             num_errors = num_errors + 1
                             trace.draw_person(num_errors, True)
@@ -140,6 +155,9 @@ def run(self):
                                 True,
                                 True,
                             )
+
+                            if num_errors < 7:
+                                self.output_queue.put("SOUND " + sss_sounds.BEEP_08)
                 yield
 
             # This will wait until the player has pressed the START button again before restarting a new game