783 lines
28 KiB
Python
783 lines
28 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""Sound handling for Storm Games.
|
|
|
|
Provides functionality for:
|
|
- Playing background music and sound effects
|
|
- Positional audio
|
|
- Volume controls
|
|
"""
|
|
|
|
import os
|
|
import pygame
|
|
import random
|
|
import re
|
|
import time
|
|
from os import listdir
|
|
from os.path import isfile, join
|
|
from .services import VolumeService
|
|
|
|
# Global instance for backward compatibility
|
|
volumeService = VolumeService.get_instance()
|
|
|
|
class Sound:
|
|
"""Handles sound loading and playback."""
|
|
|
|
def __init__(self, soundDir="sounds/", volumeService=None):
|
|
"""Initialize sound system.
|
|
|
|
Args:
|
|
soundDir (str): Directory containing sound files (default: "sounds/")
|
|
volumeService (VolumeService): Volume service (default: global instance)
|
|
"""
|
|
self.soundDir = soundDir
|
|
self.sounds = {}
|
|
self.volumeService = volumeService or VolumeService.get_instance()
|
|
|
|
# Initialize pygame mixer if not already done
|
|
if not pygame.mixer.get_init():
|
|
pygame.mixer.pre_init(44100, -16, 2, 1024)
|
|
pygame.mixer.init()
|
|
pygame.mixer.set_num_channels(32)
|
|
pygame.mixer.set_reserved(0) # Reserve channel for cut scenes
|
|
|
|
# Load sounds
|
|
self.load_sounds()
|
|
|
|
def load_sounds(self):
|
|
"""Load all sound files from the sound directory and its subdirectories.
|
|
|
|
Searches recursively through subdirectories and loads all sound files with
|
|
.ogg or .wav extensions. Sound names are stored as relative paths from the
|
|
sound directory, with directory separators replaced by forward slashes.
|
|
"""
|
|
try:
|
|
# Walk through directory tree
|
|
for dirPath, dirNames, fileNames in os.walk(self.soundDir):
|
|
# Get relative path from soundDir
|
|
relPath = os.path.relpath(dirPath, self.soundDir)
|
|
|
|
# Process each file
|
|
for fileName in fileNames:
|
|
# Check if file is a valid sound file
|
|
if fileName.lower().endswith(('.ogg', '.wav')):
|
|
# Full path to the sound file
|
|
fullPath = os.path.join(dirPath, fileName)
|
|
|
|
# Create sound key (remove extension)
|
|
baseName = os.path.splitext(fileName)[0]
|
|
|
|
# If in root sounds dir, just use basename
|
|
if relPath == '.':
|
|
soundKey = baseName
|
|
else:
|
|
# Otherwise use relative path + basename, normalized with forward slashes
|
|
soundKey = os.path.join(relPath, baseName).replace('\\', '/')
|
|
|
|
# Load the sound
|
|
self.sounds[soundKey] = pygame.mixer.Sound(fullPath)
|
|
|
|
except Exception as e:
|
|
print(f"Error loading sounds: {e}")
|
|
|
|
def play_sound(self, soundName, volume=1.0, loop=False):
|
|
"""Play a sound with current volume settings applied.
|
|
|
|
Args:
|
|
soundName (str): Name of sound to play
|
|
volume (float): Base volume for the sound (0.0-1.0, default: 1.0)
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: The channel the sound is playing on
|
|
"""
|
|
if soundName not in self.sounds:
|
|
return None
|
|
|
|
sound = self.sounds[soundName]
|
|
if loop:
|
|
channel = sound.play(-1)
|
|
else:
|
|
channel = sound.play()
|
|
if channel:
|
|
channel.set_volume(volume * self.volumeService.get_sfx_volume())
|
|
return channel
|
|
|
|
def calculate_volume_and_pan(self, playerPos, objPos, maxDistance=12):
|
|
"""Calculate volume and stereo panning based on relative positions.
|
|
|
|
Args:
|
|
playerPos (float): Player's position on x-axis
|
|
objPos (float): Object's position on x-axis
|
|
maxDistance (float): Maximum audible distance (default: 12)
|
|
|
|
Returns:
|
|
tuple: (volume, left_vol, right_vol) values between 0 and 1
|
|
"""
|
|
distance = abs(playerPos - objPos)
|
|
|
|
if distance > maxDistance:
|
|
return 0, 0, 0 # No sound if out of range
|
|
|
|
# Calculate volume (non-linear scaling for more noticeable changes)
|
|
# Apply masterVolume as the maximum possible volume
|
|
volume = (((maxDistance - distance) / maxDistance) ** 1.5) * self.volumeService.masterVolume
|
|
|
|
# Determine left/right based on relative position
|
|
if playerPos < objPos:
|
|
# Object is to the right
|
|
left = max(0, 1 - (objPos - playerPos) / maxDistance)
|
|
right = 1
|
|
elif playerPos > objPos:
|
|
# Object is to the left
|
|
left = 1
|
|
right = max(0, 1 - (playerPos - objPos) / maxDistance)
|
|
else:
|
|
# Player is on the object
|
|
left = right = 1
|
|
|
|
return volume, left, right
|
|
|
|
def obj_play(self, soundName, playerPos, objPos, loop=True):
|
|
"""Play a sound with positional audio.
|
|
|
|
Args:
|
|
soundName (str): Name of sound to play
|
|
playerPos (float): Player's position for audio panning
|
|
objPos (float): Object's position for audio panning
|
|
loop (bool): Whether to loop the sound (default: True)
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: Sound channel object, or None if out of range
|
|
"""
|
|
if soundName not in self.sounds:
|
|
return None
|
|
|
|
volume, left, right = self.calculate_volume_and_pan(playerPos, objPos)
|
|
if volume == 0:
|
|
return None # Don't play if out of range
|
|
|
|
# Play the sound on a new channel
|
|
channel = self.sounds[soundName].play(-1 if loop else 0)
|
|
if channel:
|
|
channel.set_volume(
|
|
volume * left * self.volumeService.sfxVolume,
|
|
volume * right * self.volumeService.sfxVolume
|
|
)
|
|
return channel
|
|
|
|
def obj_update(self, channel, playerPos, objPos):
|
|
"""Update positional audio for a playing sound.
|
|
|
|
Args:
|
|
channel: Sound channel to update
|
|
playerPos (float): New player position
|
|
objPos (float): New object position
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: Updated channel, or None if sound should stop
|
|
"""
|
|
if channel is None:
|
|
return None
|
|
|
|
volume, left, right = self.calculate_volume_and_pan(playerPos, objPos)
|
|
if volume == 0:
|
|
channel.stop()
|
|
return None
|
|
|
|
# Apply the volume and pan
|
|
channel.set_volume(
|
|
volume * left * self.volumeService.sfxVolume,
|
|
volume * right * self.volumeService.sfxVolume
|
|
)
|
|
return channel
|
|
|
|
def obj_stop(self, channel):
|
|
"""Stop a playing sound channel.
|
|
|
|
Args:
|
|
channel: Sound channel to stop
|
|
|
|
Returns:
|
|
None if stopped successfully, otherwise returns original channel
|
|
"""
|
|
try:
|
|
channel.stop()
|
|
return None
|
|
except:
|
|
return channel
|
|
|
|
def play_ambiance(self, soundNames, probability, randomLocation=False):
|
|
"""Play random ambient sounds with optional positional audio.
|
|
|
|
Args:
|
|
soundNames (list): List of possible sound names to choose from
|
|
probability (int): Chance to play (1-100)
|
|
randomLocation (bool): Whether to randomize stereo position
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: Sound channel if played, None otherwise
|
|
"""
|
|
# Check if any of the sounds in the list is already playing
|
|
for soundName in soundNames:
|
|
if pygame.mixer.find_channel(True) and pygame.mixer.find_channel(True).get_busy():
|
|
return None
|
|
|
|
if random.randint(1, 100) > probability:
|
|
return None
|
|
|
|
# Choose a random sound from the list
|
|
ambianceSound = random.choice(soundNames)
|
|
if ambianceSound not in self.sounds:
|
|
return None
|
|
|
|
channel = self.sounds[ambianceSound].play()
|
|
|
|
if randomLocation and channel:
|
|
leftVolume = random.random() * self.volumeService.get_sfx_volume()
|
|
rightVolume = random.random() * self.volumeService.get_sfx_volume()
|
|
channel.set_volume(leftVolume, rightVolume)
|
|
|
|
return channel
|
|
|
|
def play_random(self, soundPrefix, pause=False, interrupt=False):
|
|
"""Play a random variation of a sound.
|
|
|
|
Args:
|
|
soundPrefix (str): Base name of sound (will match all starting with this)
|
|
pause (bool): Whether to pause execution until sound finishes
|
|
interrupt (bool): Whether to interrupt other sounds
|
|
"""
|
|
keys = []
|
|
for i in self.sounds.keys():
|
|
if re.match("^" + soundPrefix + ".*", i):
|
|
keys.append(i)
|
|
|
|
if not keys: # No matching sounds found
|
|
return None
|
|
|
|
randomKey = random.choice(keys)
|
|
|
|
if interrupt:
|
|
self.cut_scene(randomKey)
|
|
return
|
|
|
|
channel = self.sounds[randomKey].play()
|
|
sfxVolume = self.volumeService.get_sfx_volume()
|
|
|
|
if channel:
|
|
channel.set_volume(sfxVolume, sfxVolume)
|
|
|
|
if pause:
|
|
time.sleep(self.sounds[randomKey].get_length())
|
|
|
|
return channel
|
|
|
|
def play_random_positional(self, soundPrefix, playerX, objectX):
|
|
"""Play a random variation of a sound with positional audio.
|
|
|
|
Args:
|
|
soundPrefix (str): Base name of sound to match
|
|
playerX (float): Player's x position
|
|
objectX (float): Object's x position
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: Sound channel if played, None otherwise
|
|
"""
|
|
keys = [k for k in self.sounds.keys() if k.startswith(soundPrefix)]
|
|
if not keys:
|
|
return None
|
|
|
|
randomKey = random.choice(keys)
|
|
volume, left, right = self.calculate_volume_and_pan(playerX, objectX)
|
|
|
|
if volume == 0:
|
|
return None
|
|
|
|
channel = self.sounds[randomKey].play()
|
|
if channel:
|
|
channel.set_volume(
|
|
volume * left * self.volumeService.sfxVolume,
|
|
volume * right * self.volumeService.sfxVolume
|
|
)
|
|
return channel
|
|
|
|
def play_directional_sound(self, soundName, playerPos, objPos, centerDistance=3, volume=1.0):
|
|
"""Play a sound with simplified directional audio.
|
|
|
|
For sounds that need to be heard clearly regardless of distance, but still provide
|
|
directional feedback. Sound plays at full volume but pans left/right based on relative position.
|
|
|
|
Args:
|
|
soundName (str): Name of sound to play
|
|
playerPos (float): Player's x position
|
|
objPos (float): Object's x position
|
|
centerDistance (float): Distance within which sound plays center (default: 3)
|
|
volume (float): Base volume multiplier (0.0-1.0, default: 1.0)
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: The channel the sound is playing on
|
|
"""
|
|
if soundName not in self.sounds:
|
|
return None
|
|
|
|
channel = self.sounds[soundName].play()
|
|
if channel:
|
|
# Apply volume settings
|
|
finalVolume = volume * self.volumeService.get_sfx_volume()
|
|
|
|
# If player is within centerDistance tiles of object, play in center
|
|
if abs(playerPos - objPos) <= centerDistance:
|
|
# Equal volume in both speakers (center)
|
|
channel.set_volume(finalVolume, finalVolume)
|
|
elif playerPos > objPos:
|
|
# Object is to the left of player
|
|
channel.set_volume(finalVolume, (finalVolume + 0.01) / 2)
|
|
else:
|
|
# Object is to the right of player
|
|
channel.set_volume((finalVolume + 0.01) / 2, finalVolume)
|
|
return channel
|
|
|
|
def cut_scene(self, soundName):
|
|
"""Play a sound as a cut scene, stopping other sounds.
|
|
|
|
Args:
|
|
soundName (str): Name of sound to play
|
|
"""
|
|
if soundName not in self.sounds:
|
|
return
|
|
|
|
pygame.event.clear()
|
|
pygame.mixer.stop()
|
|
|
|
# Get the reserved channel (0) for cut scenes
|
|
channel = pygame.mixer.Channel(0)
|
|
|
|
# Apply the appropriate volume settings
|
|
sfxVolume = self.volumeService.get_sfx_volume()
|
|
channel.set_volume(sfxVolume, sfxVolume)
|
|
|
|
# Play the sound
|
|
channel.play(self.sounds[soundName])
|
|
|
|
while pygame.mixer.get_busy():
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.KEYDOWN and event.key in [pygame.K_ESCAPE, pygame.K_RETURN, pygame.K_SPACE]:
|
|
pygame.mixer.stop()
|
|
return
|
|
pygame.time.delay(10)
|
|
|
|
def play_random_falling(self, soundPrefix, playerX, objectX, startY,
|
|
currentY=0, maxY=20, existingChannel=None):
|
|
"""Play or update a falling sound with positional audio and volume based on height.
|
|
|
|
Args:
|
|
soundPrefix (str): Base name of sound to match
|
|
playerX (float): Player's x position
|
|
objectX (float): Object's x position
|
|
startY (float): Starting Y position (0-20, higher = quieter start)
|
|
currentY (float): Current Y position (0 = ground level) (default: 0)
|
|
maxY (float): Maximum Y value (default: 20)
|
|
existingChannel: Existing sound channel to update (default: None)
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: Sound channel for updating position/volume,
|
|
or None if sound should stop
|
|
"""
|
|
# Calculate horizontal positioning
|
|
volume, left, right = self.calculate_volume_and_pan(playerX, objectX)
|
|
|
|
# Calculate vertical fall volume multiplier (0 at maxY, 1 at y=0)
|
|
fallMultiplier = 1 - (currentY / maxY)
|
|
|
|
# Adjust final volumes
|
|
finalVolume = volume * fallMultiplier
|
|
finalLeft = left * finalVolume
|
|
finalRight = right * finalVolume
|
|
|
|
if existingChannel is not None:
|
|
if volume == 0: # Out of audible range
|
|
existingChannel.stop()
|
|
return None
|
|
existingChannel.set_volume(
|
|
finalLeft * self.volumeService.sfxVolume,
|
|
finalRight * self.volumeService.sfxVolume
|
|
)
|
|
return existingChannel
|
|
else: # Need to create new channel
|
|
if volume == 0: # Don't start if out of range
|
|
return None
|
|
|
|
# Find matching sound files
|
|
keys = [k for k in self.sounds.keys() if k.startswith(soundPrefix)]
|
|
if not keys:
|
|
return None
|
|
|
|
randomKey = random.choice(keys)
|
|
channel = self.sounds[randomKey].play()
|
|
if channel:
|
|
channel.set_volume(
|
|
finalLeft * self.volumeService.sfxVolume,
|
|
finalRight * self.volumeService.sfxVolume
|
|
)
|
|
return channel
|
|
|
|
|
|
# Global functions for backward compatibility
|
|
|
|
def play_bgm(musicFile):
|
|
"""Play background music with proper volume settings.
|
|
|
|
Args:
|
|
musicFile (str): Path to the music file to play
|
|
"""
|
|
try:
|
|
pygame.mixer.music.stop()
|
|
pygame.mixer.music.load(musicFile)
|
|
pygame.mixer.music.set_volume(volumeService.get_bgm_volume())
|
|
pygame.mixer.music.play(-1) # Loop indefinitely
|
|
except Exception as e:
|
|
pass
|
|
|
|
def adjust_master_volume(change):
|
|
"""Adjust the master volume for all sounds.
|
|
|
|
Args:
|
|
change (float): Amount to change volume by (positive or negative)
|
|
"""
|
|
volumeService.adjust_master_volume(change, pygame.mixer)
|
|
|
|
def adjust_bgm_volume(change):
|
|
"""Adjust only the background music volume.
|
|
|
|
Args:
|
|
change (float): Amount to change volume by (positive or negative)
|
|
"""
|
|
volumeService.adjust_bgm_volume(change, pygame.mixer)
|
|
|
|
def adjust_sfx_volume(change):
|
|
"""Adjust volume for sound effects only.
|
|
|
|
Args:
|
|
change (float): Amount to change volume by (positive or negative)
|
|
"""
|
|
volumeService.adjust_sfx_volume(change, pygame.mixer)
|
|
|
|
def calculate_volume_and_pan(playerPos, objPos):
|
|
"""Calculate volume and stereo panning based on relative positions.
|
|
|
|
Args:
|
|
playerPos (float): Player's position on x-axis
|
|
objPos (float): Object's position on x-axis
|
|
|
|
Returns:
|
|
tuple: (volume, left_vol, right_vol) values between 0 and 1
|
|
"""
|
|
distance = abs(playerPos - objPos)
|
|
maxDistance = 12 # Maximum audible distance
|
|
|
|
if distance > maxDistance:
|
|
return 0, 0, 0 # No sound if out of range
|
|
|
|
# Calculate volume (non-linear scaling for more noticeable changes)
|
|
# Apply masterVolume as the maximum possible volume
|
|
volume = (((maxDistance - distance) / maxDistance) ** 1.5) * volumeService.masterVolume
|
|
|
|
# Determine left/right based on relative position
|
|
if playerPos < objPos:
|
|
# Object is to the right
|
|
left = max(0, 1 - (objPos - playerPos) / maxDistance)
|
|
right = 1
|
|
elif playerPos > objPos:
|
|
# Object is to the left
|
|
left = 1
|
|
right = max(0, 1 - (playerPos - objPos) / maxDistance)
|
|
else:
|
|
# Player is on the object
|
|
left = right = 1
|
|
|
|
return volume, left, right
|
|
|
|
def play_sound(sound, volume=1.0, loop=False):
|
|
"""Play a sound with current volume settings applied.
|
|
|
|
Args:
|
|
sound: pygame Sound object to play
|
|
volume: base volume for the sound (0.0-1.0, default: 1.0)
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: The channel the sound is playing on
|
|
"""
|
|
if loop:
|
|
channel = sound.play(-1)
|
|
else:
|
|
channel = sound.play()
|
|
if channel:
|
|
channel.set_volume(volume * volumeService.get_sfx_volume())
|
|
return channel
|
|
|
|
def obj_play(sounds, soundName, playerPos, objPos, loop=True):
|
|
"""Play a sound with positional audio.
|
|
|
|
Args:
|
|
sounds (dict): Dictionary of sound objects
|
|
soundName (str): Name of sound to play
|
|
playerPos (float): Player's position for audio panning
|
|
objPos (float): Object's position for audio panning
|
|
loop (bool): Whether to loop the sound (default: True)
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: Sound channel object, or None if out of range
|
|
"""
|
|
volume, left, right = calculate_volume_and_pan(playerPos, objPos)
|
|
if volume == 0:
|
|
return None # Don't play if out of range
|
|
|
|
# Play the sound on a new channel
|
|
channel = sounds[soundName].play(-1 if loop else 0)
|
|
if channel:
|
|
channel.set_volume(volume * left * volumeService.sfxVolume,
|
|
volume * right * volumeService.sfxVolume)
|
|
return channel
|
|
|
|
def obj_update(channel, playerPos, objPos):
|
|
"""Update positional audio for a playing sound.
|
|
|
|
Args:
|
|
channel: Sound channel to update
|
|
playerPos (float): New player position
|
|
objPos (float): New object position
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: Updated channel, or None if sound should stop
|
|
"""
|
|
if channel is None:
|
|
return None
|
|
|
|
volume, left, right = calculate_volume_and_pan(playerPos, objPos)
|
|
if volume == 0:
|
|
channel.stop()
|
|
return None
|
|
|
|
# Apply the volume and pan
|
|
channel.set_volume(volume * left * volumeService.sfxVolume,
|
|
volume * right * volumeService.sfxVolume)
|
|
return channel
|
|
|
|
def obj_stop(channel):
|
|
"""Stop a playing sound channel.
|
|
|
|
Args:
|
|
channel: Sound channel to stop
|
|
|
|
Returns:
|
|
None if stopped successfully, otherwise returns original channel
|
|
"""
|
|
try:
|
|
channel.stop()
|
|
return None
|
|
except:
|
|
return channel
|
|
|
|
def play_ambiance(sounds, soundNames, probability, randomLocation=False):
|
|
"""Play random ambient sounds with optional positional audio.
|
|
|
|
Args:
|
|
sounds (dict): Dictionary of sound objects
|
|
soundNames (list): List of possible sound names to choose from
|
|
probability (int): Chance to play (1-100)
|
|
randomLocation (bool): Whether to randomize stereo position
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: Sound channel if played, None otherwise
|
|
"""
|
|
# Check if any of the sounds in the list is already playing
|
|
for soundName in soundNames:
|
|
if pygame.mixer.find_channel(True) and pygame.mixer.find_channel(True).get_busy():
|
|
return None
|
|
|
|
if random.randint(1, 100) > probability:
|
|
return None
|
|
|
|
# Choose a random sound from the list
|
|
ambianceSound = random.choice(soundNames)
|
|
channel = sounds[ambianceSound].play()
|
|
|
|
if randomLocation and channel:
|
|
leftVolume = random.random() * volumeService.get_sfx_volume()
|
|
rightVolume = random.random() * volumeService.get_sfx_volume()
|
|
channel.set_volume(leftVolume, rightVolume)
|
|
|
|
return channel
|
|
|
|
def play_random(sounds, soundName, pause=False, interrupt=False):
|
|
"""Play a random variation of a sound.
|
|
|
|
Args:
|
|
sounds (dict): Dictionary of sound objects
|
|
soundName (str): Base name of sound (will match all starting with this)
|
|
pause (bool): Whether to pause execution until sound finishes
|
|
interrupt (bool): Whether to interrupt other sounds
|
|
"""
|
|
key = []
|
|
for i in sounds.keys():
|
|
if re.match("^" + soundName + ".*", i):
|
|
key.append(i)
|
|
|
|
if not key: # No matching sounds found
|
|
return
|
|
|
|
randomKey = random.choice(key)
|
|
|
|
if interrupt:
|
|
cut_scene(sounds, randomKey)
|
|
return
|
|
|
|
channel = sounds[randomKey].play()
|
|
if channel:
|
|
sfxVolume = volumeService.get_sfx_volume()
|
|
channel.set_volume(sfxVolume, sfxVolume)
|
|
|
|
if pause:
|
|
time.sleep(sounds[randomKey].get_length())
|
|
|
|
def play_random_positional(sounds, soundName, playerX, objectX):
|
|
"""Play a random variation of a sound with positional audio.
|
|
|
|
Args:
|
|
sounds (dict): Dictionary of sound objects
|
|
soundName (str): Base name of sound to match
|
|
playerX (float): Player's x position
|
|
objectX (float): Object's x position
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: Sound channel if played, None otherwise
|
|
"""
|
|
keys = [k for k in sounds.keys() if k.startswith(soundName)]
|
|
if not keys:
|
|
return None
|
|
|
|
randomKey = random.choice(keys)
|
|
volume, left, right = calculate_volume_and_pan(playerX, objectX)
|
|
|
|
if volume == 0:
|
|
return None
|
|
|
|
channel = sounds[randomKey].play()
|
|
if channel:
|
|
channel.set_volume(volume * left * volumeService.sfxVolume,
|
|
volume * right * volumeService.sfxVolume)
|
|
return channel
|
|
|
|
def play_directional_sound(sounds, soundName, playerPos, objPos, centerDistance=3, volume=1.0):
|
|
"""Play a sound with simplified directional audio.
|
|
|
|
For sounds that need to be heard clearly regardless of distance, but still provide
|
|
directional feedback. Sound plays at full volume but pans left/right based on relative position.
|
|
|
|
Args:
|
|
sounds (dict): Dictionary of sound objects
|
|
soundName (str): Name of sound to play
|
|
playerPos (float): Player's x position
|
|
objPos (float): Object's x position
|
|
centerDistance (float): Distance within which sound plays center (default: 3)
|
|
volume (float): Base volume multiplier (0.0-1.0, default: 1.0)
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: The channel the sound is playing on
|
|
"""
|
|
channel = sounds[soundName].play()
|
|
if channel:
|
|
# Apply volume settings
|
|
finalVolume = volume * volumeService.get_sfx_volume()
|
|
|
|
# If player is within centerDistance tiles of object, play in center
|
|
if abs(playerPos - objPos) <= centerDistance:
|
|
# Equal volume in both speakers (center)
|
|
channel.set_volume(finalVolume, finalVolume)
|
|
elif playerPos > objPos:
|
|
# Object is to the left of player
|
|
channel.set_volume(finalVolume, (finalVolume + 0.01) / 2)
|
|
else:
|
|
# Object is to the right of player
|
|
channel.set_volume((finalVolume + 0.01) / 2, finalVolume)
|
|
return channel
|
|
|
|
def cut_scene(sounds, soundName):
|
|
"""Play a sound as a cut scene, stopping other sounds.
|
|
|
|
Args:
|
|
sounds (dict): Dictionary of sound objects
|
|
soundName (str): Name of sound to play
|
|
"""
|
|
pygame.event.clear()
|
|
pygame.mixer.stop()
|
|
|
|
# Get the reserved channel (0) for cut scenes
|
|
channel = pygame.mixer.Channel(0)
|
|
|
|
# Apply the appropriate volume settings
|
|
sfxVolume = volumeService.get_sfx_volume()
|
|
channel.set_volume(sfxVolume, sfxVolume)
|
|
|
|
# Play the sound
|
|
channel.play(sounds[soundName])
|
|
|
|
while pygame.mixer.get_busy():
|
|
for event in pygame.event.get():
|
|
if event.type == pygame.KEYDOWN and event.key in [pygame.K_ESCAPE, pygame.K_RETURN, pygame.K_SPACE]:
|
|
pygame.mixer.stop()
|
|
return
|
|
pygame.time.delay(10)
|
|
|
|
def play_random_falling(sounds, soundName, playerX, objectX, startY,
|
|
currentY=0, maxY=20, existingChannel=None):
|
|
"""Play or update a falling sound with positional audio and volume based on height.
|
|
|
|
Args:
|
|
sounds (dict): Dictionary of sound objects
|
|
soundName (str): Base name of sound to match
|
|
playerX (float): Player's x position
|
|
objectX (float): Object's x position
|
|
startY (float): Starting Y position (0-20, higher = quieter start)
|
|
currentY (float): Current Y position (0 = ground level) (default: 0)
|
|
maxY (float): Maximum Y value (default: 20)
|
|
existingChannel: Existing sound channel to update (default: None)
|
|
|
|
Returns:
|
|
pygame.mixer.Channel: Sound channel for updating position/volume,
|
|
or None if sound should stop
|
|
"""
|
|
# Calculate horizontal positioning
|
|
volume, left, right = calculate_volume_and_pan(playerX, objectX)
|
|
|
|
# Calculate vertical fall volume multiplier (0 at maxY, 1 at y=0)
|
|
fallMultiplier = 1 - (currentY / maxY)
|
|
|
|
# Adjust final volumes
|
|
finalVolume = volume * fallMultiplier
|
|
finalLeft = left * finalVolume
|
|
finalRight = right * finalVolume
|
|
|
|
if existingChannel is not None:
|
|
if volume == 0: # Out of audible range
|
|
existingChannel.stop()
|
|
return None
|
|
existingChannel.set_volume(finalLeft * volumeService.sfxVolume,
|
|
finalRight * volumeService.sfxVolume)
|
|
return existingChannel
|
|
else: # Need to create new channel
|
|
if volume == 0: # Don't start if out of range
|
|
return None
|
|
|
|
# Find matching sound files
|
|
keys = [k for k in sounds.keys() if k.startswith(soundName)]
|
|
if not keys:
|
|
return None
|
|
|
|
randomKey = random.choice(keys)
|
|
channel = sounds[randomKey].play()
|
|
if channel:
|
|
channel.set_volume(finalLeft * volumeService.sfxVolume,
|
|
finalRight * volumeService.sfxVolume)
|
|
return channel
|