sound/music, set ground color, script key changes

Author: flipcoder

game/base/entity.py

@@ -164,6 +164,7 @@ def play_sound(self, filename, callback=None, *args):
         channel = pygame.mixer.find_channel()
         if not channel:
             return None, None, None
+        channel.set_volume(SOUND_VOLUME)
         if callback:
             slot = self.scene.when.once(self.sounds[0].get_length(), callback)
             self.slots.add(slot)

game/base/script.py

@@ -25,8 +25,9 @@ def __init__(self, app, ctx, script, use_input=True, script_args=None):
 
         # these are accumulated between yields
         # this is different from get_pressed()
-        self.key_down = set()
-        self.key_up = set()
+        self.keys = set()
+        self.keys_down = set()
+        self.keys_up = set()
 
         if use_input:
             self.event_slot = self.app.on_event.connect(self.event)
@@ -48,9 +49,14 @@ def resume(self):
 
     def event(self, ev):
         if ev.type == pygame.KEYDOWN:
-            self.key_down.add(ev.key)
+            self.keys_down.add(ev.key)
+            self.keys.add(ev.key)
         elif ev.type == pygame.KEYUP:
-            self.key_up.add(ev.key)
+            self.keys_up.add(ev.key)
+            try:
+                self.keys.remove(ev.key)
+            except KeyError:
+                pass
 
     def running(self):
         return self._script is not None
@@ -66,8 +72,19 @@ def key(self, k):
         assert self.event_slot  # input needs to be enabled (default)
 
         if isinstance(k, str):
-            return self.key_down[ord(k)]
-        return self.key_down[k]
+            return ord(k) in self.keys
+        return k in self.keys
+
+    def key_down(self, k):
+        # if we're in a script: return keys since last script yield
+        # assert self.script.inside
+
+        assert self.inside  # please only use this in scripts
+        assert self.event_slot  # input needs to be enabled (default)
+
+        if isinstance(k, str):
+            return ord(k) in self.keys_down
+        return k in self.keys_down
 
     def key_up(self, k):
         # if we're in a script: return keys since last script yield
@@ -77,23 +94,23 @@ def key_up(self, k):
         assert self.event_slot  # input needs to be enabled (default)
 
         if isinstance(k, str):
-            return self.key_up[ord(k)]
-        return self.key_up[k]
+            return ord(k) in self.keys_up
+        return k in self.keys_up
 
     # This makes scripting cleaner than checking script.keys directly
     # We need these so scripts can do "keys = script.keys"
     # and then call keys(), since it changes
-    def keys(self):
-        # return key downs since last script yield
-        assert self.inside  # please only use this in scripts
-        assert self.event_slot  # input needs to be enabled (default)
-        return self.key_down
-
-    def keys_up(self):
-        # return key ups since last script yield
-        assert self.inside  # please only use this in scripts
-        assert self.event_slot  # input needs to be enabled (default)
-        return self.key_up
+    # def keys(self):
+    #     # return key downs since last script yield
+    #     assert self.inside  # please only use this in scripts
+    #     assert self.event_slot  # input needs to be enabled (default)
+    # return self._keys
+
+    # def keys_up(self):
+    #     # return key ups since last script yield
+    #     assert self.inside  # please only use this in scripts
+    #     assert self.event_slot  # input needs to be enabled (default)
+    #     return self._key_up
 
     @property
     def script(self):

game/constants.py

@@ -16,6 +16,9 @@
 MUSIC_DIR = os.path.join(ASSETS_DIR, "music")
 FONTS_DIR = ASSETS_DIR
 
+SOUND_VOLUME = 0.1
+MUSIC_VOLUME = 1.0
+
 # Images should all be in the SPRITES_DIR
 SHIP_IMAGE_PATH = "ship.png"
 CROSSHAIR_IMAGE_PATH = "crosshair.png"

game/entities/ground.py

@@ -11,6 +11,7 @@ class Ground(Entity):
     def __init__(self, app, scene, height):
         super().__init__(app, scene)
         self.position = vec3(0, height, float("-inf"))
+        self.color = GREEN
 
     def render(self, camera: Camera):
         super().render(camera)
@@ -53,4 +54,4 @@ def render(self, camera: Camera):
 
         if len(poly) > 2:
             poly = [tuple(camera.world_to_screen(p)) for p in poly]
-            pygame.draw.polygon(self.app.screen, GREEN, poly)
+            pygame.draw.polygon(self.app.screen, self.color, poly)

game/scene.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 
 import functools
-from game.base.signal import Signal, Slot
+from game.base.signal import Signal, Slot, SlotList
 from game.base.when import When
 from os import path
 from pygame import Color
@@ -22,12 +22,15 @@ def __init__(self, app, state, script=None, script_args=None):
         super().__init__()
         self.app = app
         self.state = state
-        self._when = When()
+        self.when = When()
+        self.slotlist = SlotList()
 
         # self.script_paused = False
         # self.script_slots = []
         self.sky_color = None
         self.dt = 0
+        self.sounds = {}
+
         # self.script_fn = script
         # self.event_slot = self.app.on_event.connect(self.event)
 
@@ -51,14 +54,50 @@ def __init__(self, app, state, script=None, script_args=None):
         else:
             self._script = None
 
-    @property
-    def when(self):
-        if self._script and self._script.running():
-            # Sanity Check:
-            # Don't use scene.when() when inside a script.
-            # Use script.when()
-            assert not self._script.inside
-        return self._when
+    def remove_sound(self, filename):
+        if filename in self.sounds:
+            self.sounds[filename][0].stop()
+            del self.sounds[filename]
+            return True
+        return False
+
+    def ensure_sound(self, filename, callback=None, *args):
+        """
+        Ensure a sound is playing.  If it isn't, play it.
+        """
+        if filename in self.sounds:
+            return None, None, None
+        return self.play_sound(filename, callback, *args)
+
+    def play_sound(self, filename, callback=None, *args):
+        """
+        Plays the sound with the given filename (relative to SOUNDS_DIR).
+        Returns sound, channel, and callback slot.
+        """
+
+        if filename in self.sounds:
+            self.sounds[filename][0].stop()
+            del self.sounds[filename]
+
+        filename = path.join(SOUNDS_DIR, filename)
+        sound = self.app.load(filename, lambda: pygame.mixer.Sound(filename))
+        if not sound:
+            return None, None, None
+        channel = pygame.mixer.find_channel()
+        if not channel:
+            return None, None, None
+        channel.set_volume(SOUND_VOLUME)
+        if callback:
+            slot = self.when.once(self.sounds[0].get_length(), callback)
+            self.slotlist += slot
+        else:
+            slot = None
+        self.sounds[filename] = (sound, channel, slot)
+        channel.play(sound, *args)
+        self.slotlist += self.when.once(
+            sound.get_length(), lambda: self.remove_sound(sound)
+        )
+        return sound, channel, slot
 
     @property
     def script(self):
@@ -76,6 +115,17 @@ def script(self, fn):
     def music(self):
         return self._music
 
+    @property
+    def ground_color(self):
+        return self.color(self.app.state.ground.color)
+
+    @ground_color.setter
+    def ground_color(self, color):
+        c = self.color(color)
+        self.app.state.ground.color = pygame.Color(
+            int(c[0] * 255), int(c[1] * 255), int(c[2] * 255)
+        )
+
     @music.setter
     def music(self, filename):
         self._music = filename
@@ -88,15 +138,18 @@ def color(self, c):
         Given a color string, a pygame color, or vec3,
         return that as a normalized vec4 color
         """
-        # print(c)
         if isinstance(c, str):
             c = vec4(*pygame.Color(c)) / 255.0
+        elif isinstance(c, tuple):
+            c = vec4(*c, 0) / 255.0
         elif isinstance(c, pygame.Color):
-            c = vec4(*c) / 255.0
+            c = vec4(*c, 0) / 255.0
         elif isinstance(c, vec3):
             c = vec4(*c, 0)
         elif isinstance(c, (float, int)):
             c = vec4(c, c, c, 0)
+        elif c is None:
+            c = vec4(0)
         return c
 
     def mix(self, a, b, t):
@@ -170,11 +223,14 @@ def sky_color(self):
 
     @sky_color.setter
     def sky_color(self, c):
-        self._sky_color = self.color(c)
+        self._sky_color = self.color(c) if c else None
 
     # for scripts to call when.fade(1, set_sky_color)
     def set_sky_color(self, c):
-        self._sky_color = self.color(c)
+        self._sky_color = self.color(c) if c else None
+
+    def set_ground_color(self, c):
+        self.ground_color = self.color(c) if c else None
 
     def remove(self, entity):
         super().disconnect(entity)

game/scripts/level.py

@@ -51,16 +51,16 @@ def pause(self, duration):
 
     def __call__(self):
         self.scene.sky_color = self.sky
-        self.cloudy()
+        self.scene.ground_color = self.ground
+        self.scene.music = self.music
 
         if self.name:
             terminal = self.app.state.terminal
-            typ = pygame.mixer.Sound("data/sounds/type.wav")
 
             left = ivec2((terminal.size.x - len(self.name)) / 2, 5)
             for i, letter in enumerate(self.name):
                 terminal.write(letter, left + (i, 0), "white")
-                typ.play()
+                self.scene.play_sound("type.wav")
                 yield self.pause(0.1)
 
             terminal.clear(left[1])

game/scripts/level1.py

@@ -6,13 +6,17 @@
 # Yield when you want to wait until the next event.
 # This is a generator.  Using a busy loop will halt the game.
 from game.scripts.level import Level
+from game.constants import GREEN
 
 
 class Level1(Level):
     name = "Level 1"
     sky = "#59ABE3"
+    ground = GREEN
+    music = "butterfly.mp3"
 
     def __call__(self):
+
         yield from super().__call__()
 
         for _ in range(10):

game/states/game.py

@@ -29,7 +29,7 @@ def __init__(self, app, state=None):
 
         self.app.inputs = self.build_inputs()
         self.camera = self.scene.add(Camera(app, self.scene, self.app.size))
-        self.scene.add(Ground(app, self.scene, GROUND_HEIGHT))
+        self.ground = self.scene.add(Ground(app, self.scene, GROUND_HEIGHT))
         self.player = self.scene.add(Player(app, self.scene))
         # self.msg = self.scene.add(Message(self.app, self.scene, "HELLO"))
 

game/states/intro.py

@@ -45,7 +45,6 @@ def __call__(self, script):
         scene = self.scene
         color = self.scene.color
         terminal = self.terminal
-        keys = script.keys
 
         when.fade(3, scene.__class__.sky_color.setter, (vec4(0), vec4(1)))
         a = when.fade(
@@ -57,13 +56,11 @@ def __call__(self, script):
         )
 
         # scene.sky_color = "black"
-        typ = pygame.mixer.Sound("data/sounds/type.wav")
-
         msg = "Welcome to Butterfly Destroyers!"
         for i in range(len(msg)):
             terminal.write(msg[i], (i, 0), "red")
-            typ.play()
-            yield script.sleep(0.1)
+            scene.ensure_sound("type.wav")
+            yield script.sleep(0.01 if script.keys else 0.05)
 
         msg = [
             "In the year, 20XX, the butterfly",
@@ -78,8 +75,8 @@ def __call__(self, script):
         for y, line in enumerate(msg):
             for x, m in enumerate(line):
                 terminal.write(m, (x, y * 2 + 3), "white")
-                typ.play()
-                yield script.sleep(0.05)
+                scene.ensure_sound("type.wav")
+                yield script.sleep(0.01 if script.keys else 0.05)
 
         t = 0
         while True:
@@ -93,15 +90,7 @@ def __call__(self, script):
             #     terminal.offset((x,20), (0, math.sin(t*math.tau*300)*4 - 2))
 
             yield script.sleep(0.2)
-            if len(keys()):
-                break
-
-            # t += script.dt
-
-            terminal.clear(20)
-
-            yield script.sleep(0.2)
-            if len(keys()):
+            if script.keys_down:
                 break
 
         self.app.state = "game"

tests/test_when.py

@@ -47,7 +47,9 @@ def test_once():
     slot = s.once(2, lambda: c.increment())
     s.update(1)
     assert c.x == 0
-    s.update(1)
+    s.update(0.5)
+    assert c.x == 0
+    s.update(0.5)
     assert c.x == 1
     s.update(10)
     assert c.x == 1