init commit

Author: Sentdex

Chapter 10/10-1.py

@@ -0,0 +1,6 @@
+def stereo_pan(x_coord, screen_width):
+
+    right_volume = float(x_coord) / screen_width 
+    left_volume = 1.0 - right_volume
+
+    return (left_volume, right_volume)

Chapter 10/10-2.py

@@ -0,0 +1,5 @@
+tank.explode() # Do explosion visual 
+explosion_channel = explosion_sound.play() 
+if explosion_channel is not None:
+    left, right = stereo_pan(tank.position.x, SCREEN_SIZE[0])
+    explosion_channel.set_volume(left, right)

Chapter 10/10-3.py

@@ -0,0 +1,3 @@
+pygame.mixer.set_reserved(2) 
+reserved_channel_0 = pygame.mixer.Channel(0) 
+reserved_channel_1 = pygame.mixer.Channel(1)

Chapter 10/10-4.py

@@ -0,0 +1,163 @@
+import pygame
+from pygame.locals import *
+from random import randint
+from gameobjects.vector2 import Vector2
+
+SCREEN_SIZE = (640, 480)
+
+# In pixels per second, per second
+GRAVITY = 250.0
+# Increase for more bounciness, but don't go over 1!
+BOUNCINESS = 0.7
+
+def stero_pan(x_coord, screen_width):
+
+    right_volume = float(x_coord) / screen_width
+    left_volume = 1.0 - right_volume
+
+    return (left_volume, right_volume)
+
+
+class Ball(object):
+
+    def __init__(self, position, speed, image, bounce_sound):
+
+        self.position = Vector2(position)
+        self.speed = Vector2(speed)
+        self.image = image
+        self.bounce_sound = bounce_sound
+        self.age = 0.0
+
+    def update(self, time_passed):
+
+        w, h = self.image.get_size()
+
+        screen_width, screen_height = SCREEN_SIZE
+
+        x, y = self.position
+        x -= w/2
+        y -= h/2
+
+        # Has the ball bounce
+        bounce = False
+
+        # Has the ball hit the bottom of the screen?
+        if y + h >= screen_height:
+            self.speed.y = -self.speed.y * BOUNCINESS
+            self.position.y = screen_height - h / 2.0 - 1.0
+            bounce = True
+
+        # Has the ball hit the left of the screen?
+        if x <= 0:
+            self.speed.x = -self.speed.x * BOUNCINESS
+            self.position.x = w / 2.0 + 1
+            bounce = True
+
+        # Has the ball hit the right of the screen
+        elif x + w >= screen_width:
+            self.speed.x = -self.speed.x * BOUNCINESS
+            self.position.x = screen_width - w / 2.0 - 1
+            bounce = True
+
+        # Do time based movement
+        self.position += self.speed * time_passed
+        # Add gravity
+        self.speed.y += time_passed * GRAVITY
+
+        if bounce:
+            self.play_bounce_sound()
+
+        self.age += time_passed
+
+
+    def play_bounce_sound(self):
+
+        channel = self.bounce_sound.play()
+
+        if channel is not None:
+            # Get the left and right volumes
+            left, right = stero_pan(self.position.x, SCREEN_SIZE[0])
+            channel.set_volume(left, right)
+
+
+    def render(self, surface):
+
+        # Draw the sprite center at self.position
+        w, h = self.image.get_size()
+        x, y = self.position
+        x -= w/2
+        y -= h/2
+        surface.blit(self.image, (x, y))
+
+
+def run():
+
+    # Initialise 44KHz 16-bit stero sound
+    pygame.mixer.pre_init(44100, 16, 2, 1024*4)
+    pygame.init()
+    pygame.mixer.set_num_channels(8)
+    screen = pygame.display.set_mode(SCREEN_SIZE, 0)
+
+    print(pygame.display.get_wm_info())
+    hwnd = pygame.display.get_wm_info()["window"]
+    x, y = (200, 200)
+
+    pygame.mouse.set_visible(False)
+
+    clock = pygame.time.Clock()
+
+    ball_image = pygame.image.load("ball.png").convert_alpha()
+    mouse_image = pygame.image.load("mousecursor.png").convert_alpha()
+
+    # Load the sound file
+    bounce_sound = pygame.mixer.Sound("bounce.wav")
+
+    balls = []
+
+    while True:
+
+        for event in pygame.event.get():
+
+            if event.type == QUIT:
+                pygame.quit()
+                quit()
+
+            if event.type == MOUSEBUTTONDOWN:
+
+                # Create a new ball at the mouse position
+                random_speed = ( randint(-400, 400), randint(-300, 0) )
+                new_ball = Ball( event.pos,
+                                 random_speed,
+                                 ball_image,
+                                 bounce_sound )
+                balls.append(new_ball)
+
+        time_passed_seconds = clock.tick() / 1000.
+
+        screen.fill((255, 255, 255))
+
+        dead_balls = []
+
+        for ball in balls:
+
+            ball.update(time_passed_seconds)
+            ball.render(screen)
+
+            # Make not of any balls that are older than 10 seconds
+            if ball.age > 10.0:
+                dead_balls.append(ball)
+
+        # remove any 'dead' balls from the main list
+        for ball in dead_balls:
+
+            balls.remove(ball)
+
+        # Draw the mouse cursor
+        mouse_pos = pygame.mouse.get_pos()
+        screen.blit(mouse_image, mouse_pos)
+
+        pygame.display.update()
+
+if __name__ == "__main__":
+
+    run()

Chapter 10/10-5.py

@@ -0,0 +1,2 @@
+pygame.mixer.music.load("techno.ogg")
+pygame.mixer.music.play()

Chapter 10/10-6.py

@@ -0,0 +1,201 @@
+import pygame
+from pygame.locals import *
+
+from math import sqrt
+import os
+import os.path
+
+# Location of music on your computer
+MUSIC_PATH = "./MUSIC"
+SCREEN_SIZE = (800, 600)
+
+def get_music(path):
+    
+    # Get the filenames in a folder
+    raw_filenames = os.listdir(path)
+    
+    music_files = []
+    for filename in raw_filenames:
+                
+        # We only want ogg files
+        if filename.endswith('.ogg'):
+            music_files.append(os.path.join(MUSIC_PATH, filename))
+            
+    return sorted(music_files)
+
+
+class Button(object):
+    
+    def __init__(self, image_filename, position):
+        
+        self.position = position
+        self.image = pygame.image.load(image_filename)
+
+    def render(self, surface):
+        
+        # Render at the center
+        x, y = self.position
+        w, h = self.image.get_size()
+        x -= w /2
+        y -= h / 2
+        
+        surface.blit(self.image, (x, y))
+        
+        
+    def is_over(self, point):
+        
+        # Return True if a point is over the button
+        point_x, point_y = point
+        x, y = self.position
+        w, h = self.image.get_size()
+        x -= w /2
+        y -= h / 2
+        
+        in_x = point_x >= x and point_x < x + w
+        in_y = point_y >= y and point_y < y + h
+            
+        return in_x and in_y
+
+def run():
+        
+    pygame.mixer.pre_init(44100, 16, 2, 1024*4)
+    pygame.init()
+    screen = pygame.display.set_mode(SCREEN_SIZE, 0)     
+    
+    default_font = pygame.font.get_default_font()
+    font = pygame.font.SysFont("default_font", 50, False)    
+    
+    # Create our buttons
+    x = 100
+    y = 240
+    button_width = 150
+    
+    # Store the buttons in a dictionary, so we can assign them names
+    buttons = {}
+    buttons["prev"] = Button("prev.png", (x, y))    
+    buttons["pause"] = Button("pause.png", (x+button_width*1, y))
+    buttons["stop"] = Button("stop.png", (x+button_width*2, y))
+    buttons["play"] = Button("play.png", (x+button_width*3, y))
+    buttons["next"] = Button("next.png", (x+button_width*4, y))
+            
+    music_filenames = get_music(MUSIC_PATH)
+    
+    if len(music_filenames) == 0:
+        print("No OGG files found in ", MUSIC_PATH)
+        return
+    
+    white = (255, 255, 255)    
+    label_surfaces = []    
+    
+    # Render the track names
+    for filename in music_filenames:
+        
+        txt = os.path.split(filename)[-1]
+        
+        print("Track:", txt)
+        
+        txt = txt.split('.')[0]
+        surface = font.render(txt, True, (100, 0, 100))
+        label_surfaces.append(surface)
+        
+    current_track = 0
+    max_tracks = len(music_filenames)
+    
+    pygame.mixer.music.load( music_filenames[current_track] )  
+    
+    clock = pygame.time.Clock()
+        
+    playing = False
+    paused = False
+    
+    # This event is sent when a music track ends
+    TRACK_END = USEREVENT + 1
+    pygame.mixer.music.set_endevent(TRACK_END)
+        
+    while True:
+        
+        button_pressed = None
+        
+        for event in pygame.event.get():
+            
+            if event.type == QUIT:
+                pygame.quit()
+                quit()
+            
+            if event.type == MOUSEBUTTONDOWN:
+                
+                # Find the pressed button
+                for button_name, button in buttons.items():
+                    if button.is_over(event.pos):
+                        print(button_name, "pressed")
+                        button_pressed = button_name
+                        break
+            
+            if event.type == TRACK_END:
+                # If the track has ended, simulate pressing the next button
+                button_pressed = "next"
+        
+        if button_pressed is not None:
+                        
+            if button_pressed == "next":
+                current_track = (current_track + 1) % max_tracks
+                pygame.mixer.music.load( music_filenames[current_track] )
+                if playing:
+                    pygame.mixer.music.play()
+                
+            elif button_pressed == "prev":
+                
+                # If the track has been playing for more that 3 seconds,
+                # rewind i, otherwise select the previous track
+                if pygame.mixer.music.get_pos() > 3000:
+                    pygame.mixer.music.stop()
+                    pygame.mixer.music.play()                                        
+                else:
+                    current_track = (current_track - 1) % max_tracks
+                    pygame.mixer.music.load( music_filenames[current_track] )
+                    if playing:
+                        pygame.mixer.music.play()
+                
+            elif button_pressed == "pause":
+                if paused:
+                    pygame.mixer.music.unpause()
+                    paused = False
+                else:                    
+                    pygame.mixer.music.pause()
+                    paused = True
+                
+            elif button_pressed == "stop":                
+                pygame.mixer.music.stop()
+                playing = False
+                
+            elif button_pressed == "play":
+                if paused:
+                    pygame.mixer.music.unpause()
+                    paused = False
+                else:
+                    if not playing:
+                        pygame.mixer.music.play()
+                        playing = True
+                        
+        
+        screen.fill(white)
+        
+                
+        # Render the name of the currently track
+        label = label_surfaces[current_track]
+        w, h = label.get_size()
+        screen_w = SCREEN_SIZE[0]        
+        screen.blit(label, ((screen_w - w)/2, 450))
+        
+        # Render all the buttons
+        for button in list(buttons.values()):
+            button.render(screen)
+        
+        # No animation, 5 frames per second is fine!
+        clock.tick(5)
+        pygame.display.update()
+
+
+if __name__ == "__main__":
+            
+    run()