storm/libstormgames
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Attempt to fix traceback on game exit with some older games.

Browse Source
This commit is contained in:
Storm Dragon 2025-03-14 23:10:14 -04:00
parent 2ad22ff1ae
commit be6dfdf53a
9 changed files with 483 additions and 457 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
__init__.py
View File

@ -126,42 +126,42 @@ __all__ = [
] ]
# Create global instances for backward compatibility # Create global instances for backward compatibility
config_service = ConfigService.get_instance() configService = ConfigService.get_instance()
volume_service = VolumeService.get_instance() volumeService = VolumeService.get_instance()
path_service = PathService.get_instance() pathService = PathService.get_instance()
# Set up backward compatibility hooks for initialize_gui # Set up backward compatibility hooks for initialize_gui
_original_initialize_gui = initialize_gui _originalInitializeGui = initialize_gui
def initialize_gui_with_services(game_title): def initialize_gui_with_services(gameTitle):
"""Wrapper around initialize_gui that initializes services.""" """Wrapper around initialize_gui that initializes services."""
# Initialize path service # Initialize path service
path_service.initialize(game_title) pathService.initialize(gameTitle)
# Connect config service to path service # Connect config service to path service
config_service.set_game_info(game_title, path_service) configService.set_game_info(gameTitle, pathService)
# Call original initialize_gui # Call original initialize_gui
return _original_initialize_gui(game_title) return _originalInitializeGui(gameTitle)
# Replace initialize_gui with the wrapped version # Replace initialize_gui with the wrapped version
initialize_gui = initialize_gui_with_services initialize_gui = initialize_gui_with_services
# Initialize global scoreboard constructor # Initialize global scoreboard constructor
_original_scoreboard_init = Scoreboard.__init__ _originalScoreboardInit = Scoreboard.__init__
def scoreboard_init_with_services(self, score=0, config_service=None, speech=None): def scoreboard_init_with_services(self, score=0, configService=None, speech=None):
"""Wrapper around Scoreboard.__init__ that ensures services are initialized.""" """Wrapper around Scoreboard.__init__ that ensures services are initialized."""
# Use global services if not specified # Use global services if not specified
if config_service is None: if configService is None:
config_service = ConfigService.get_instance() configService = ConfigService.get_instance()
# Ensure path_service is connected if using defaults # Ensure pathService is connected if using defaults
if not hasattr(config_service, 'path_service') and path_service.game_path is not None: if not hasattr(configService, 'pathService') and pathService.game_path is not None:
config_service.path_service = path_service configService.pathService = pathService
# Call original init with services # Call original init with services
_original_scoreboard_init(self, score, config_service, speech) _originalScoreboardInit(self, score, configService, speech)
# Replace Scoreboard.__init__ with the wrapped version # Replace Scoreboard.__init__ with the wrapped version
Scoreboard.__init__ = scoreboard_init_with_services Scoreboard.__init__ = scoreboard_init_with_services

64
config.py
View File

@ -14,24 +14,24 @@ from xdg import BaseDirectory
class Config: class Config:
"""Configuration management class for Storm Games.""" """Configuration management class for Storm Games."""
def __init__(self, game_title): def __init__(self, gameTitle):
"""Initialize configuration system for a game. """Initialize configuration system for a game.
Args: Args:
game_title (str): Title of the game gameTitle (str): Title of the game
""" """
self.game_title = game_title self.gameTitle = gameTitle
self.global_path = os.path.join(BaseDirectory.xdg_config_home, "storm-games") self.globalPath = os.path.join(BaseDirectory.xdg_config_home, "storm-games")
self.game_path = os.path.join(self.global_path, self.gamePath = os.path.join(self.globalPath,
str.lower(str.replace(game_title, " ", "-"))) str.lower(str.replace(gameTitle, " ", "-")))
# Create game directory if it doesn't exist # Create game directory if it doesn't exist
if not os.path.exists(self.game_path): if not os.path.exists(self.gamePath):
os.makedirs(self.game_path) os.makedirs(self.gamePath)
# Initialize config parsers # Initialize config parsers
self.local_config = configparser.ConfigParser() self.localConfig = configparser.ConfigParser()
self.global_config = configparser.ConfigParser() self.globalConfig = configparser.ConfigParser()
# Load existing configurations # Load existing configurations
self.read_local_config() self.read_local_config()
@ -40,28 +40,28 @@ class Config:
def read_local_config(self): def read_local_config(self):
"""Read local configuration from file.""" """Read local configuration from file."""
try: try:
with open(os.path.join(self.game_path, "config.ini"), 'r') as configfile: with open(os.path.join(self.gamePath, "config.ini"), 'r') as configFile:
self.local_config.read_file(configfile) self.localConfig.read_file(configFile)
except: except:
pass pass
def read_global_config(self): def read_global_config(self):
"""Read global configuration from file.""" """Read global configuration from file."""
try: try:
with open(os.path.join(self.global_path, "config.ini"), 'r') as configfile: with open(os.path.join(self.globalPath, "config.ini"), 'r') as configFile:
self.global_config.read_file(configfile) self.globalConfig.read_file(configFile)
except: except:
pass pass
def write_local_config(self): def write_local_config(self):
"""Write local configuration to file.""" """Write local configuration to file."""
with open(os.path.join(self.game_path, "config.ini"), 'w') as configfile: with open(os.path.join(self.gamePath, "config.ini"), 'w') as configFile:
self.local_config.write(configfile) self.localConfig.write(configFile)
def write_global_config(self): def write_global_config(self):
"""Write global configuration to file.""" """Write global configuration to file."""
with open(os.path.join(self.global_path, "config.ini"), 'w') as configfile: with open(os.path.join(self.globalPath, "config.ini"), 'w') as configFile:
self.global_config.write(configfile) self.globalConfig.write(configFile)
# Global variables for backward compatibility # Global variables for backward compatibility
localConfig = configparser.ConfigParser() localConfig = configparser.ConfigParser()
@ -69,34 +69,34 @@ globalConfig = configparser.ConfigParser()
gamePath = "" gamePath = ""
globalPath = "" globalPath = ""
def write_config(write_global=False): def write_config(writeGlobal=False):
"""Write configuration to file. """Write configuration to file.
Args: Args:
write_global (bool): If True, write to global config, otherwise local (default: False) writeGlobal (bool): If True, write to global config, otherwise local (default: False)
""" """
if not write_global: if not writeGlobal:
with open(gamePath + "/config.ini", 'w') as configfile: with open(gamePath + "/config.ini", 'w') as configFile:
localConfig.write(configfile) localConfig.write(configFile)
else: else:
with open(globalPath + "/config.ini", 'w') as configfile: with open(globalPath + "/config.ini", 'w') as configFile:
globalConfig.write(configfile) globalConfig.write(configFile)
def read_config(read_global=False): def read_config(readGlobal=False):
"""Read configuration from file. """Read configuration from file.
Args: Args:
read_global (bool): If True, read global config, otherwise local (default: False) readGlobal (bool): If True, read global config, otherwise local (default: False)
""" """
if not read_global: if not readGlobal:
try: try:
with open(gamePath + "/config.ini", 'r') as configfile: with open(gamePath + "/config.ini", 'r') as configFile:
localConfig.read_file(configfile) localConfig.read_file(configFile)
except: except:
pass pass
else: else:
try: try:
with open(globalPath + "/config.ini", 'r') as configfile: with open(globalPath + "/config.ini", 'r') as configFile:
globalConfig.read_file(configfile) globalConfig.read_file(configFile)
except: except:
pass pass

20
display.py
View File

@ -31,7 +31,7 @@ def initialize_gui(gameTitle):
dict: Dictionary of loaded sound objects dict: Dictionary of loaded sound objects
""" """
# Initialize path service with game title # Initialize path service with game title
path_service = PathService.get_instance().initialize(gameTitle) pathService = PathService.get_instance().initialize(gameTitle)
# Seed the random generator to the clock # Seed the random generator to the clock
random.seed() random.seed()
@ -95,7 +95,7 @@ def display_text(text):
""" """
# Get service instances # Get service instances
speech = Speech.get_instance() speech = Speech.get_instance()
volume_service = VolumeService.get_instance() volumeService = VolumeService.get_instance()
# Store original text with blank lines for copying # Store original text with blank lines for copying
originalText = text.copy() originalText = text.copy()
@ -123,22 +123,22 @@ def display_text(text):
if event.type == pygame.KEYDOWN: if event.type == pygame.KEYDOWN:
# Check for Alt modifier # Check for Alt modifier
mods = pygame.key.get_mods() mods = pygame.key.get_mods()
alt_pressed = mods & pygame.KMOD_ALT altPressed = mods & pygame.KMOD_ALT
# Volume controls (require Alt) # Volume controls (require Alt)
if alt_pressed: if altPressed:
if event.key == pygame.K_PAGEUP: if event.key == pygame.K_PAGEUP:
volume_service.adjust_master_volume(0.1, pygame.mixer) volumeService.adjust_master_volume(0.1, pygame.mixer)
elif event.key == pygame.K_PAGEDOWN: elif event.key == pygame.K_PAGEDOWN:
volume_service.adjust_master_volume(-0.1, pygame.mixer) volumeService.adjust_master_volume(-0.1, pygame.mixer)
elif event.key == pygame.K_HOME: elif event.key == pygame.K_HOME:
volume_service.adjust_bgm_volume(0.1, pygame.mixer) volumeService.adjust_bgm_volume(0.1, pygame.mixer)
elif event.key == pygame.K_END: elif event.key == pygame.K_END:
volume_service.adjust_bgm_volume(-0.1, pygame.mixer) volumeService.adjust_bgm_volume(-0.1, pygame.mixer)
elif event.key == pygame.K_INSERT: elif event.key == pygame.K_INSERT:
volume_service.adjust_sfx_volume(0.1, pygame.mixer) volumeService.adjust_sfx_volume(0.1, pygame.mixer)
elif event.key == pygame.K_DELETE: elif event.key == pygame.K_DELETE:
volume_service.adjust_sfx_volume(-0.1, pygame.mixer) volumeService.adjust_sfx_volume(-0.1, pygame.mixer)
else: else:
if event.key in (pygame.K_ESCAPE, pygame.K_RETURN): if event.key in (pygame.K_ESCAPE, pygame.K_RETURN):
return return

50
menu.py
View File

@ -69,10 +69,10 @@ def game_menu(sounds, *options):
if event.type == pygame.KEYDOWN: if event.type == pygame.KEYDOWN:
# Check for Alt modifier # Check for Alt modifier
mods = pygame.key.get_mods() mods = pygame.key.get_mods()
alt_pressed = mods & pygame.KMOD_ALT altPressed = mods & pygame.KMOD_ALT
# Volume controls (require Alt) # Volume controls (require Alt)
if alt_pressed: if altPressed:
if event.key == pygame.K_PAGEUP: if event.key == pygame.K_PAGEUP:
adjust_master_volume(0.1) adjust_master_volume(0.1)
elif event.key == pygame.K_PAGEDOWN: elif event.key == pygame.K_PAGEDOWN:
@ -88,7 +88,8 @@ def game_menu(sounds, *options):
# Regular menu navigation (no Alt required) # Regular menu navigation (no Alt required)
else: else:
if event.key == pygame.K_ESCAPE: if event.key == pygame.K_ESCAPE:
exit_game() # Exit with fade if music is playing
exit_game(500 if pygame.mixer.music.get_busy() else 0)
elif event.key == pygame.K_HOME: elif event.key == pygame.K_HOME:
if currentIndex != 0: if currentIndex != 0:
currentIndex = 0 currentIndex = 0
@ -131,13 +132,17 @@ def game_menu(sounds, *options):
time.sleep(sounds['menu-select'].get_length()) time.sleep(sounds['menu-select'].get_length())
except: except:
pass pass
eval(options[currentIndex] + "()")
# Special case for exit_game with fade
if options[currentIndex] == "exit_game":
exit_game(500 if pygame.mixer.music.get_busy() else 0)
else:
eval(options[currentIndex] + "()")
except: except:
lastSpoken = -1 lastSpoken = -1
pygame.mixer.music.fadeout(500)
try: try:
pygame.mixer.music.fadeout(750) pygame.mixer.music.fadeout(500)
time.sleep(1.0) time.sleep(0.5)
except: except:
pass pass
@ -274,13 +279,34 @@ def donate():
pygame.mixer.music.pause() pygame.mixer.music.pause()
webbrowser.open('https://ko-fi.com/stormux') webbrowser.open('https://ko-fi.com/stormux')
def exit_game(): def exit_game(fade=0):
"""Clean up and exit the game.""" """Clean up and exit the game.
Args:
fade (int): Milliseconds to fade out music before exiting.
0 means stop immediately (default)
"""
# Get speech instance and check provider type # Get speech instance and check provider type
speech = Speech.get_instance() speech = Speech.get_instance()
if speech.provider_name == "speechd": if speech.providerName == "speechd":
speech.close() speech.close()
pygame.mixer.music.stop() # Handle music based on fade parameter
pygame.quit() try:
if fade > 0:
pygame.mixer.music.fadeout(fade)
# Brief pause to allow fade to start, but not complete
pygame.time.wait(min(fade // 4, 200)) # Wait up to 200ms maximum
else:
pygame.mixer.music.stop()
except Exception as e:
print(f"Warning: Could not handle music during exit: {e}")
# Clean up pygame
try:
pygame.quit()
except Exception as e:
print(f"Warning: Error during pygame.quit(): {e}")
# Exit the program
exit() exit()

66
scoreboard.py
View File

@ -17,25 +17,25 @@ from .config import localConfig, write_config, read_config
class Scoreboard: class Scoreboard:
"""Handles high score tracking with player names.""" """Handles high score tracking with player names."""
def __init__(self, score=0, config_service=None, speech=None): def __init__(self, score=0, configService=None, speech=None):
"""Initialize scoreboard. """Initialize scoreboard.
Args: Args:
score (int): Initial score (default: 0) score (int): Initial score (default: 0)
config_service (ConfigService): Config service (default: global instance) configService (ConfigService): Config service (default: global instance)
speech (Speech): Speech system (default: global instance) speech (Speech): Speech system (default: global instance)
""" """
self.config_service = config_service or ConfigService.get_instance() self.configService = configService or ConfigService.get_instance()
self.speech = speech or Speech.get_instance() self.speech = speech or Speech.get_instance()
self.current_score = score self.currentScore = score
self.high_scores = [] self.highScores = []
# For backward compatibility # For backward compatibility
read_config() read_config()
try: try:
# Try to use config_service # Try to use configService
self.config_service.local_config.add_section("scoreboard") self.configService.local_config.add_section("scoreboard")
except: except:
# Fallback to old method # Fallback to old method
try: try:
@ -46,10 +46,10 @@ class Scoreboard:
# Load existing high scores # Load existing high scores
for i in range(1, 11): for i in range(1, 11):
try: try:
# Try to use config_service # Try to use configService
score = self.config_service.local_config.getint("scoreboard", f"score_{i}") score = self.configService.local_config.getint("scoreboard", f"score_{i}")
name = self.config_service.local_config.get("scoreboard", f"name_{i}") name = self.configService.local_config.get("scoreboard", f"name_{i}")
self.high_scores.append({ self.highScores.append({
'name': name, 'name': name,
'score': score 'score': score
}) })
@ -58,45 +58,45 @@ class Scoreboard:
try: try:
score = localConfig.getint("scoreboard", f"score_{i}") score = localConfig.getint("scoreboard", f"score_{i}")
name = localConfig.get("scoreboard", f"name_{i}") name = localConfig.get("scoreboard", f"name_{i}")
self.high_scores.append({ self.highScores.append({
'name': name, 'name': name,
'score': score 'score': score
}) })
except: except:
self.high_scores.append({ self.highScores.append({
'name': "Player", 'name': "Player",
'score': 0 'score': 0
}) })
# Sort high scores by score value in descending order # Sort high scores by score value in descending order
self.high_scores.sort(key=lambda x: x['score'], reverse=True) self.highScores.sort(key=lambda x: x['score'], reverse=True)
def get_score(self): def get_score(self):
"""Get current score.""" """Get current score."""
return self.current_score return self.currentScore
def get_high_scores(self): def get_high_scores(self):
"""Get list of high scores.""" """Get list of high scores."""
return self.high_scores return self.highScores
def decrease_score(self, points=1): def decrease_score(self, points=1):
"""Decrease the current score.""" """Decrease the current score."""
self.current_score -= int(points) self.currentScore -= int(points)
return self return self
def increase_score(self, points=1): def increase_score(self, points=1):
"""Increase the current score.""" """Increase the current score."""
self.current_score += int(points) self.currentScore += int(points)
return self return self
def set_score(self, score): def set_score(self, score):
"""Set the current score to a specific value.""" """Set the current score to a specific value."""
self.current_score = int(score) self.currentScore = int(score)
return self return self
def reset_score(self): def reset_score(self):
"""Reset the current score to zero.""" """Reset the current score to zero."""
self.current_score = 0 self.currentScore = 0
return self return self
def check_high_score(self): def check_high_score(self):
@ -105,8 +105,8 @@ class Scoreboard:
Returns: Returns:
int: Position (1-10) if high score, None if not int: Position (1-10) if high score, None if not
""" """
for i, entry in enumerate(self.high_scores): for i, entry in enumerate(self.highScores):
if self.current_score > entry['score']: if self.currentScore > entry['score']:
return i + 1 return i + 1
return None return None
@ -132,34 +132,34 @@ class Scoreboard:
name = "Player" name = "Player"
# Insert new score at correct position # Insert new score at correct position
self.high_scores.insert(position - 1, { self.highScores.insert(position - 1, {
'name': name, 'name': name,
'score': self.current_score 'score': self.currentScore
}) })
# Keep only top 10 # Keep only top 10
self.high_scores = self.high_scores[:10] self.highScores = self.highScores[:10]
# Save to config - try both methods for maximum compatibility # Save to config - try both methods for maximum compatibility
try: try:
# Try new method first # Try new method first
for i, entry in enumerate(self.high_scores): for i, entry in enumerate(self.highScores):
self.config_service.local_config.set("scoreboard", f"score_{i+1}", str(entry['score'])) self.configService.local_config.set("scoreboard", f"score_{i+1}", str(entry['score']))
self.config_service.local_config.set("scoreboard", f"name_{i+1}", entry['name']) self.configService.local_config.set("scoreboard", f"name_{i+1}", entry['name'])
# Try to write with config_service # Try to write with configService
try: try:
self.config_service.write_local_config() self.configService.write_local_config()
except Exception as e: except Exception as e:
# Fallback to old method if config_service fails # Fallback to old method if configService fails
for i, entry in enumerate(self.high_scores): for i, entry in enumerate(self.highScores):
localConfig.set("scoreboard", f"score_{i+1}", str(entry['score'])) localConfig.set("scoreboard", f"score_{i+1}", str(entry['score']))
localConfig.set("scoreboard", f"name_{i+1}", entry['name']) localConfig.set("scoreboard", f"name_{i+1}", entry['name'])
write_config() write_config()
except Exception as e: except Exception as e:
# If all else fails, try direct old method # If all else fails, try direct old method
for i, entry in enumerate(self.high_scores): for i, entry in enumerate(self.highScores):
localConfig.set("scoreboard", f"score_{i+1}", str(entry['score'])) localConfig.set("scoreboard", f"score_{i+1}", str(entry['score']))
localConfig.set("scoreboard", f"name_{i+1}", entry['name']) localConfig.set("scoreboard", f"name_{i+1}", entry['name'])
write_config() write_config()

178
services.py
View File

@ -29,20 +29,20 @@ class ConfigService:
def __init__(self): def __init__(self):
"""Initialize configuration parsers.""" """Initialize configuration parsers."""
self.local_config = configparser.ConfigParser() self.localConfig = configparser.ConfigParser()
self.global_config = configparser.ConfigParser() self.globalConfig = configparser.ConfigParser()
self.game_title = None self.gameTitle = None
self.path_service = None self.pathService = None
def set_game_info(self, game_title, path_service): def set_game_info(self, gameTitle, pathService):
"""Set game information and initialize configs. """Set game information and initialize configs.
Args: Args:
game_title (str): Title of the game gameTitle (str): Title of the game
path_service (PathService): Path service instance pathService (PathService): Path service instance
""" """
self.game_title = game_title self.gameTitle = gameTitle
self.path_service = path_service self.pathService = pathService
# Load existing configurations # Load existing configurations
self.read_local_config() self.read_local_config()
@ -51,56 +51,56 @@ class ConfigService:
def read_local_config(self): def read_local_config(self):
"""Read local configuration from file.""" """Read local configuration from file."""
try: try:
# Try to use path_service if available # Try to use pathService if available
if self.path_service and self.path_service.game_path: if self.pathService and self.pathService.gamePath:
with open(os.path.join(self.path_service.game_path, "config.ini"), 'r') as configfile: with open(os.path.join(self.pathService.gamePath, "config.ini"), 'r') as configFile:
self.local_config.read_file(configfile) self.localConfig.read_file(configFile)
# Fallback to global gamePath # Fallback to global gamePath
elif gamePath: elif gamePath:
with open(os.path.join(gamePath, "config.ini"), 'r') as configfile: with open(os.path.join(gamePath, "config.ini"), 'r') as configFile:
self.local_config.read_file(configfile) self.localConfig.read_file(configFile)
# Delegate to old function as last resort # Delegate to old function as last resort
else: else:
read_config(False) read_config(False)
self.local_config = configparser.ConfigParser() self.localConfig = configparser.ConfigParser()
self.local_config.read_dict(globals().get('localConfig', {})) self.localConfig.read_dict(globals().get('localConfig', {}))
except: except:
pass pass
def read_global_config(self): def read_global_config(self):
"""Read global configuration from file.""" """Read global configuration from file."""
try: try:
# Try to use path_service if available # Try to use pathService if available
if self.path_service and self.path_service.global_path: if self.pathService and self.pathService.globalPath:
with open(os.path.join(self.path_service.global_path, "config.ini"), 'r') as configfile: with open(os.path.join(self.pathService.globalPath, "config.ini"), 'r') as configFile:
self.global_config.read_file(configfile) self.globalConfig.read_file(configFile)
# Fallback to global globalPath # Fallback to global globalPath
elif globalPath: elif globalPath:
with open(os.path.join(globalPath, "config.ini"), 'r') as configfile: with open(os.path.join(globalPath, "config.ini"), 'r') as configFile:
self.global_config.read_file(configfile) self.globalConfig.read_file(configFile)
# Delegate to old function as last resort # Delegate to old function as last resort
else: else:
read_config(True) read_config(True)
self.global_config = configparser.ConfigParser() self.globalConfig = configparser.ConfigParser()
self.global_config.read_dict(globals().get('globalConfig', {})) self.globalConfig.read_dict(globals().get('globalConfig', {}))
except: except:
pass pass
def write_local_config(self): def write_local_config(self):
"""Write local configuration to file.""" """Write local configuration to file."""
try: try:
# Try to use path_service if available # Try to use pathService if available
if self.path_service and self.path_service.game_path: if self.pathService and self.pathService.gamePath:
with open(os.path.join(self.path_service.game_path, "config.ini"), 'w') as configfile: with open(os.path.join(self.pathService.gamePath, "config.ini"), 'w') as configFile:
self.local_config.write(configfile) self.localConfig.write(configFile)
# Fallback to global gamePath # Fallback to global gamePath
elif gamePath: elif gamePath:
with open(os.path.join(gamePath, "config.ini"), 'w') as configfile: with open(os.path.join(gamePath, "config.ini"), 'w') as configFile:
self.local_config.write(configfile) self.localConfig.write(configFile)
# Delegate to old function as last resort # Delegate to old function as last resort
else: else:
# Update old global config # Update old global config
globals()['localConfig'] = self.local_config globals()['localConfig'] = self.localConfig
write_config(False) write_config(False)
except Exception as e: except Exception as e:
print(f"Warning: Failed to write local config: {e}") print(f"Warning: Failed to write local config: {e}")
@ -108,18 +108,18 @@ class ConfigService:
def write_global_config(self): def write_global_config(self):
"""Write global configuration to file.""" """Write global configuration to file."""
try: try:
# Try to use path_service if available # Try to use pathService if available
if self.path_service and self.path_service.global_path: if self.pathService and self.pathService.globalPath:
with open(os.path.join(self.path_service.global_path, "config.ini"), 'w') as configfile: with open(os.path.join(self.pathService.globalPath, "config.ini"), 'w') as configFile:
self.global_config.write(configfile) self.globalConfig.write(configFile)
# Fallback to global globalPath # Fallback to global globalPath
elif globalPath: elif globalPath:
with open(os.path.join(globalPath, "config.ini"), 'w') as configfile: with open(os.path.join(globalPath, "config.ini"), 'w') as configFile:
self.global_config.write(configfile) self.globalConfig.write(configFile)
# Delegate to old function as last resort # Delegate to old function as last resort
else: else:
# Update old global config # Update old global config
globals()['globalConfig'] = self.global_config globals()['globalConfig'] = self.globalConfig
write_config(True) write_config(True)
except Exception as e: except Exception as e:
print(f"Warning: Failed to write global config: {e}") print(f"Warning: Failed to write global config: {e}")
@ -139,75 +139,75 @@ class VolumeService:
def __init__(self): def __init__(self):
"""Initialize volume settings.""" """Initialize volume settings."""
self.bgm_volume = 0.75 # Default background music volume self.bgmVolume = 0.75 # Default background music volume
self.sfx_volume = 1.0 # Default sound effects volume self.sfxVolume = 1.0 # Default sound effects volume
self.master_volume = 1.0 # Default master volume self.masterVolume = 1.0 # Default master volume
def adjust_master_volume(self, change, pygame_mixer=None): def adjust_master_volume(self, change, pygameMixer=None):
"""Adjust the master volume for all sounds. """Adjust the master volume for all sounds.
Args: Args:
change (float): Amount to change volume by (positive or negative) change (float): Amount to change volume by (positive or negative)
pygame_mixer: Optional pygame.mixer module for real-time updates pygameMixer: Optional pygame.mixer module for real-time updates
""" """
self.master_volume = max(0.0, min(1.0, self.master_volume + change)) self.masterVolume = max(0.0, min(1.0, self.masterVolume + change))
# Update real-time audio if pygame mixer is provided # Update real-time audio if pygame mixer is provided
if pygame_mixer: if pygameMixer:
# Update music volume # Update music volume
if pygame_mixer.music.get_busy(): if pygameMixer.music.get_busy():
pygame_mixer.music.set_volume(self.bgm_volume * self.master_volume) pygameMixer.music.set_volume(self.bgmVolume * self.masterVolume)
# Update all sound channels # Update all sound channels
for i in range(pygame_mixer.get_num_channels()): for i in range(pygameMixer.get_num_channels()):
channel = pygame_mixer.Channel(i) channel = pygameMixer.Channel(i)
if channel.get_busy(): if channel.get_busy():
current_volume = channel.get_volume() currentVolume = channel.get_volume()
if isinstance(current_volume, (int, float)): if isinstance(currentVolume, (int, float)):
# Mono audio # Mono audio
channel.set_volume(current_volume * self.master_volume) channel.set_volume(currentVolume * self.masterVolume)
else: else:
# Stereo audio # Stereo audio
left, right = current_volume left, right = currentVolume
channel.set_volume(left * self.master_volume, right * self.master_volume) channel.set_volume(left * self.masterVolume, right * self.masterVolume)
def adjust_bgm_volume(self, change, pygame_mixer=None): def adjust_bgm_volume(self, change, pygameMixer=None):
"""Adjust only the background music volume. """Adjust only the background music volume.
Args: Args:
change (float): Amount to change volume by (positive or negative) change (float): Amount to change volume by (positive or negative)
pygame_mixer: Optional pygame.mixer module for real-time updates pygameMixer: Optional pygame.mixer module for real-time updates
""" """
self.bgm_volume = max(0.0, min(1.0, self.bgm_volume + change)) self.bgmVolume = max(0.0, min(1.0, self.bgmVolume + change))
# Update real-time audio if pygame mixer is provided # Update real-time audio if pygame mixer is provided
if pygame_mixer and pygame_mixer.music.get_busy(): if pygameMixer and pygameMixer.music.get_busy():
pygame_mixer.music.set_volume(self.bgm_volume * self.master_volume) pygameMixer.music.set_volume(self.bgmVolume * self.masterVolume)
def adjust_sfx_volume(self, change, pygame_mixer=None): def adjust_sfx_volume(self, change, pygameMixer=None):
"""Adjust volume for sound effects only. """Adjust volume for sound effects only.
Args: Args:
change (float): Amount to change volume by (positive or negative) change (float): Amount to change volume by (positive or negative)
pygame_mixer: Optional pygame.mixer module for real-time updates pygameMixer: Optional pygame.mixer module for real-time updates
""" """
self.sfx_volume = max(0.0, min(1.0, self.sfx_volume + change)) self.sfxVolume = max(0.0, min(1.0, self.sfxVolume + change))
# Update real-time audio if pygame mixer is provided # Update real-time audio if pygame mixer is provided
if pygame_mixer: if pygameMixer:
# Update all sound channels except reserved ones # Update all sound channels except reserved ones
for i in range(pygame_mixer.get_num_channels()): for i in range(pygameMixer.get_num_channels()):
channel = pygame_mixer.Channel(i) channel = pygameMixer.Channel(i)
if channel.get_busy(): if channel.get_busy():
current_volume = channel.get_volume() currentVolume = channel.get_volume()
if isinstance(current_volume, (int, float)): if isinstance(currentVolume, (int, float)):
# Mono audio # Mono audio
channel.set_volume(current_volume * self.sfx_volume * self.master_volume) channel.set_volume(currentVolume * self.sfxVolume * self.masterVolume)
else: else:
# Stereo audio # Stereo audio
left, right = current_volume left, right = currentVolume
channel.set_volume(left * self.sfx_volume * self.master_volume, channel.set_volume(left * self.sfxVolume * self.masterVolume,
right * self.sfx_volume * self.master_volume) right * self.sfxVolume * self.masterVolume)
def get_bgm_volume(self): def get_bgm_volume(self):
"""Get the current BGM volume with master adjustment. """Get the current BGM volume with master adjustment.
@ -215,7 +215,7 @@ class VolumeService:
Returns: Returns:
float: Current adjusted BGM volume float: Current adjusted BGM volume
""" """
return self.bgm_volume * self.master_volume return self.bgmVolume * self.masterVolume
def get_sfx_volume(self): def get_sfx_volume(self):
"""Get the current SFX volume with master adjustment. """Get the current SFX volume with master adjustment.
@ -223,7 +223,7 @@ class VolumeService:
Returns: Returns:
float: Current adjusted SFX volume float: Current adjusted SFX volume
""" """
return self.sfx_volume * self.master_volume return self.sfxVolume * self.masterVolume
class PathService: class PathService:
@ -240,35 +240,35 @@ class PathService:
def __init__(self): def __init__(self):
"""Initialize path variables.""" """Initialize path variables."""
self.global_path = None self.globalPath = None
self.game_path = None self.gamePath = None
self.game_name = None self.gameName = None
# Try to initialize from global variables for backward compatibility # Try to initialize from global variables for backward compatibility
global gamePath, globalPath global gamePath, globalPath
if gamePath: if gamePath:
self.game_path = gamePath self.gamePath = gamePath
if globalPath: if globalPath:
self.global_path = globalPath self.globalPath = globalPath
def initialize(self, game_title): def initialize(self, gameTitle):
"""Initialize paths for a game. """Initialize paths for a game.
Args: Args:
game_title (str): Title of the game gameTitle (str): Title of the game
""" """
self.game_name = game_title self.gameName = gameTitle
self.global_path = os.path.join(BaseDirectory.xdg_config_home, "storm-games") self.globalPath = os.path.join(BaseDirectory.xdg_config_home, "storm-games")
self.game_path = os.path.join(self.global_path, self.gamePath = os.path.join(self.globalPath,
str.lower(str.replace(game_title, " ", "-"))) str.lower(str.replace(gameTitle, " ", "-")))
# Create game directory if it doesn't exist # Create game directory if it doesn't exist
if not os.path.exists(self.game_path): if not os.path.exists(self.gamePath):
os.makedirs(self.game_path) os.makedirs(self.gamePath)
# Update global variables for backward compatibility # Update global variables for backward compatibility
global gamePath, globalPath global gamePath, globalPath
gamePath = self.game_path gamePath = self.gamePath
globalPath = self.global_path globalPath = self.globalPath
return self return self

362
sound.py
View File

@ -17,21 +17,21 @@ from os.path import isfile, join
from .services import VolumeService from .services import VolumeService
# Global instance for backward compatibility # Global instance for backward compatibility
volume_service = VolumeService.get_instance() volumeService = VolumeService.get_instance()
class Sound: class Sound:
"""Handles sound loading and playback.""" """Handles sound loading and playback."""
def __init__(self, sound_dir="sounds/", volume_service=None): def __init__(self, soundDir="sounds/", volumeService=None):
"""Initialize sound system. """Initialize sound system.
Args: Args:
sound_dir (str): Directory containing sound files (default: "sounds/") soundDir (str): Directory containing sound files (default: "sounds/")
volume_service (VolumeService): Volume service (default: global instance) volumeService (VolumeService): Volume service (default: global instance)
""" """
self.sound_dir = sound_dir self.soundDir = soundDir
self.sounds = {} self.sounds = {}
self.volume_service = volume_service or VolumeService.get_instance() self.volumeService = volumeService or VolumeService.get_instance()
# Initialize pygame mixer if not already done # Initialize pygame mixer if not already done
if not pygame.mixer.get_init(): if not pygame.mixer.get_init():
@ -46,13 +46,13 @@ class Sound:
def load_sounds(self): def load_sounds(self):
"""Load all sound files from the sound directory.""" """Load all sound files from the sound directory."""
try: try:
sound_files = [f for f in listdir(self.sound_dir) soundFiles = [f for f in listdir(self.soundDir)
if isfile(join(self.sound_dir, f)) if isfile(join(self.soundDir, f))
and (f.split('.')[1].lower() in ["ogg", "wav"])] and (f.split('.')[1].lower() in ["ogg", "wav"])]
# Create dictionary of sound objects # Create dictionary of sound objects
for f in sound_files: for f in soundFiles:
self.sounds[f.split('.')[0]] = pygame.mixer.Sound(join(self.sound_dir, f)) self.sounds[f.split('.')[0]] = pygame.mixer.Sound(join(self.soundDir, f))
except Exception as e: except Exception as e:
print(f"Error loading sounds: {e}") print(f"Error loading sounds: {e}")
@ -70,109 +70,109 @@ class Sound:
""" """
return self.sounds return self.sounds
def play_bgm(self, music_file): def play_bgm(self, musicFile):
"""Play background music with proper volume settings. """Play background music with proper volume settings.
Args: Args:
music_file (str): Path to the music file to play musicFile (str): Path to the music file to play
""" """
try: try:
pygame.mixer.music.stop() pygame.mixer.music.stop()
pygame.mixer.music.load(music_file) pygame.mixer.music.load(musicFile)
pygame.mixer.music.set_volume(self.volume_service.get_bgm_volume()) pygame.mixer.music.set_volume(self.volumeService.get_bgm_volume())
pygame.mixer.music.play(-1) # Loop indefinitely pygame.mixer.music.play(-1) # Loop indefinitely
except Exception as e: except Exception as e:
pass pass
def play_sound(self, sound_name, volume=1.0): def play_sound(self, soundName, volume=1.0):
"""Play a sound with current volume settings applied. """Play a sound with current volume settings applied.
Args: Args:
sound_name (str): Name of sound to play soundName (str): Name of sound to play
volume (float): Base volume for the sound (0.0-1.0, default: 1.0) volume (float): Base volume for the sound (0.0-1.0, default: 1.0)
Returns: Returns:
pygame.mixer.Channel: The channel the sound is playing on pygame.mixer.Channel: The channel the sound is playing on
""" """
if sound_name not in self.sounds: if soundName not in self.sounds:
return None return None
sound = self.sounds[sound_name] sound = self.sounds[soundName]
channel = sound.play() channel = sound.play()
if channel: if channel:
channel.set_volume(volume * self.volume_service.get_sfx_volume()) channel.set_volume(volume * self.volumeService.get_sfx_volume())
return channel return channel
def calculate_volume_and_pan(self, player_pos, obj_pos, max_distance=12): def calculate_volume_and_pan(self, playerPos, objPos, maxDistance=12):
"""Calculate volume and stereo panning based on relative positions. """Calculate volume and stereo panning based on relative positions.
Args: Args:
player_pos (float): Player's position on x-axis playerPos (float): Player's position on x-axis
obj_pos (float): Object's position on x-axis objPos (float): Object's position on x-axis
max_distance (float): Maximum audible distance (default: 12) maxDistance (float): Maximum audible distance (default: 12)
Returns: Returns:
tuple: (volume, left_vol, right_vol) values between 0 and 1 tuple: (volume, left_vol, right_vol) values between 0 and 1
""" """
distance = abs(player_pos - obj_pos) distance = abs(playerPos - objPos)
if distance > max_distance: if distance > maxDistance:
return 0, 0, 0 # No sound if out of range return 0, 0, 0 # No sound if out of range
# Calculate volume (non-linear scaling for more noticeable changes) # Calculate volume (non-linear scaling for more noticeable changes)
# Apply masterVolume as the maximum possible volume # Apply masterVolume as the maximum possible volume
volume = (((max_distance - distance) / max_distance) ** 1.5) * self.volume_service.master_volume volume = (((maxDistance - distance) / maxDistance) ** 1.5) * self.volumeService.masterVolume
# Determine left/right based on relative position # Determine left/right based on relative position
if player_pos < obj_pos: if playerPos < objPos:
# Object is to the right # Object is to the right
left = max(0, 1 - (obj_pos - player_pos) / max_distance) left = max(0, 1 - (objPos - playerPos) / maxDistance)
right = 1 right = 1
elif player_pos > obj_pos: elif playerPos > objPos:
# Object is to the left # Object is to the left
left = 1 left = 1
right = max(0, 1 - (player_pos - obj_pos) / max_distance) right = max(0, 1 - (playerPos - objPos) / maxDistance)
else: else:
# Player is on the object # Player is on the object
left = right = 1 left = right = 1
return volume, left, right return volume, left, right
def obj_play(self, sound_name, player_pos, obj_pos, loop=True): def obj_play(self, soundName, playerPos, objPos, loop=True):
"""Play a sound with positional audio. """Play a sound with positional audio.
Args: Args:
sound_name (str): Name of sound to play soundName (str): Name of sound to play
player_pos (float): Player's position for audio panning playerPos (float): Player's position for audio panning
obj_pos (float): Object's position for audio panning objPos (float): Object's position for audio panning
loop (bool): Whether to loop the sound (default: True) loop (bool): Whether to loop the sound (default: True)
Returns: Returns:
pygame.mixer.Channel: Sound channel object, or None if out of range pygame.mixer.Channel: Sound channel object, or None if out of range
""" """
if sound_name not in self.sounds: if soundName not in self.sounds:
return None return None
volume, left, right = self.calculate_volume_and_pan(player_pos, obj_pos) volume, left, right = self.calculate_volume_and_pan(playerPos, objPos)
if volume == 0: if volume == 0:
return None # Don't play if out of range return None # Don't play if out of range
# Play the sound on a new channel # Play the sound on a new channel
channel = self.sounds[sound_name].play(-1 if loop else 0) channel = self.sounds[soundName].play(-1 if loop else 0)
if channel: if channel:
channel.set_volume( channel.set_volume(
volume * left * self.volume_service.sfx_volume, volume * left * self.volumeService.sfxVolume,
volume * right * self.volume_service.sfx_volume volume * right * self.volumeService.sfxVolume
) )
return channel return channel
def obj_update(self, channel, player_pos, obj_pos): def obj_update(self, channel, playerPos, objPos):
"""Update positional audio for a playing sound. """Update positional audio for a playing sound.
Args: Args:
channel: Sound channel to update channel: Sound channel to update
player_pos (float): New player position playerPos (float): New player position
obj_pos (float): New object position objPos (float): New object position
Returns: Returns:
pygame.mixer.Channel: Updated channel, or None if sound should stop pygame.mixer.Channel: Updated channel, or None if sound should stop
@ -180,15 +180,15 @@ class Sound:
if channel is None: if channel is None:
return None return None
volume, left, right = self.calculate_volume_and_pan(player_pos, obj_pos) volume, left, right = self.calculate_volume_and_pan(playerPos, objPos)
if volume == 0: if volume == 0:
channel.stop() channel.stop()
return None return None
# Apply the volume and pan # Apply the volume and pan
channel.set_volume( channel.set_volume(
volume * left * self.volume_service.sfx_volume, volume * left * self.volumeService.sfxVolume,
volume * right * self.volume_service.sfx_volume volume * right * self.volumeService.sfxVolume
) )
return channel return channel
@ -207,19 +207,19 @@ class Sound:
except: except:
return channel return channel
def play_ambiance(self, sound_names, probability, random_location=False): def play_ambiance(self, soundNames, probability, randomLocation=False):
"""Play random ambient sounds with optional positional audio. """Play random ambient sounds with optional positional audio.
Args: Args:
sound_names (list): List of possible sound names to choose from soundNames (list): List of possible sound names to choose from
probability (int): Chance to play (1-100) probability (int): Chance to play (1-100)
random_location (bool): Whether to randomize stereo position randomLocation (bool): Whether to randomize stereo position
Returns: Returns:
pygame.mixer.Channel: Sound channel if played, None otherwise pygame.mixer.Channel: Sound channel if played, None otherwise
""" """
# Check if any of the sounds in the list is already playing # Check if any of the sounds in the list is already playing
for sound_name in sound_names: for soundName in soundNames:
if pygame.mixer.find_channel(True) and pygame.mixer.find_channel(True).get_busy(): if pygame.mixer.find_channel(True) and pygame.mixer.find_channel(True).get_busy():
return None return None
@ -227,124 +227,124 @@ class Sound:
return None return None
# Choose a random sound from the list # Choose a random sound from the list
ambiance_sound = random.choice(sound_names) ambianceSound = random.choice(soundNames)
if ambiance_sound not in self.sounds: if ambianceSound not in self.sounds:
return None return None
channel = self.sounds[ambiance_sound].play() channel = self.sounds[ambianceSound].play()
if random_location and channel: if randomLocation and channel:
left_volume = random.random() * self.volume_service.get_sfx_volume() leftVolume = random.random() * self.volumeService.get_sfx_volume()
right_volume = random.random() * self.volume_service.get_sfx_volume() rightVolume = random.random() * self.volumeService.get_sfx_volume()
channel.set_volume(left_volume, right_volume) channel.set_volume(leftVolume, rightVolume)
return channel return channel
def play_random(self, sound_prefix, pause=False, interrupt=False): def play_random(self, soundPrefix, pause=False, interrupt=False):
"""Play a random variation of a sound. """Play a random variation of a sound.
Args: Args:
sound_prefix (str): Base name of sound (will match all starting with this) soundPrefix (str): Base name of sound (will match all starting with this)
pause (bool): Whether to pause execution until sound finishes pause (bool): Whether to pause execution until sound finishes
interrupt (bool): Whether to interrupt other sounds interrupt (bool): Whether to interrupt other sounds
""" """
keys = [] keys = []
for i in self.sounds.keys(): for i in self.sounds.keys():
if re.match("^" + sound_prefix + ".*", i): if re.match("^" + soundPrefix + ".*", i):
keys.append(i) keys.append(i)
if not keys: # No matching sounds found if not keys: # No matching sounds found
return None return None
random_key = random.choice(keys) randomKey = random.choice(keys)
if interrupt: if interrupt:
self.cut_scene(random_key) self.cut_scene(randomKey)
return return
channel = self.sounds[random_key].play() channel = self.sounds[randomKey].play()
sfx_volume = self.volume_service.get_sfx_volume() sfxVolume = self.volumeService.get_sfx_volume()
if channel: if channel:
channel.set_volume(sfx_volume, sfx_volume) channel.set_volume(sfxVolume, sfxVolume)
if pause: if pause:
time.sleep(self.sounds[random_key].get_length()) time.sleep(self.sounds[randomKey].get_length())
return channel return channel
def play_random_positional(self, sound_prefix, player_x, object_x): def play_random_positional(self, soundPrefix, playerX, objectX):
"""Play a random variation of a sound with positional audio. """Play a random variation of a sound with positional audio.
Args: Args:
sound_prefix (str): Base name of sound to match soundPrefix (str): Base name of sound to match
player_x (float): Player's x position playerX (float): Player's x position
object_x (float): Object's x position objectX (float): Object's x position
Returns: Returns:
pygame.mixer.Channel: Sound channel if played, None otherwise pygame.mixer.Channel: Sound channel if played, None otherwise
""" """
keys = [k for k in self.sounds.keys() if k.startswith(sound_prefix)] keys = [k for k in self.sounds.keys() if k.startswith(soundPrefix)]
if not keys: if not keys:
return None return None
random_key = random.choice(keys) randomKey = random.choice(keys)
volume, left, right = self.calculate_volume_and_pan(player_x, object_x) volume, left, right = self.calculate_volume_and_pan(playerX, objectX)
if volume == 0: if volume == 0:
return None return None
channel = self.sounds[random_key].play() channel = self.sounds[randomKey].play()
if channel: if channel:
channel.set_volume( channel.set_volume(
volume * left * self.volume_service.sfx_volume, volume * left * self.volumeService.sfxVolume,
volume * right * self.volume_service.sfx_volume volume * right * self.volumeService.sfxVolume
) )
return channel return channel
def play_directional_sound(self, sound_name, player_pos, obj_pos, center_distance=3, volume=1.0): def play_directional_sound(self, soundName, playerPos, objPos, centerDistance=3, volume=1.0):
"""Play a sound with simplified directional audio. """Play a sound with simplified directional audio.
For sounds that need to be heard clearly regardless of distance, but still provide 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. directional feedback. Sound plays at full volume but pans left/right based on relative position.
Args: Args:
sound_name (str): Name of sound to play soundName (str): Name of sound to play
player_pos (float): Player's x position playerPos (float): Player's x position
obj_pos (float): Object's x position objPos (float): Object's x position
center_distance (float): Distance within which sound plays center (default: 3) centerDistance (float): Distance within which sound plays center (default: 3)
volume (float): Base volume multiplier (0.0-1.0, default: 1.0) volume (float): Base volume multiplier (0.0-1.0, default: 1.0)
Returns: Returns:
pygame.mixer.Channel: The channel the sound is playing on pygame.mixer.Channel: The channel the sound is playing on
""" """
if sound_name not in self.sounds: if soundName not in self.sounds:
return None return None
channel = self.sounds[sound_name].play() channel = self.sounds[soundName].play()
if channel: if channel:
# Apply volume settings # Apply volume settings
final_volume = volume * self.volume_service.get_sfx_volume() finalVolume = volume * self.volumeService.get_sfx_volume()
# If player is within centerDistance tiles of object, play in center # If player is within centerDistance tiles of object, play in center
if abs(player_pos - obj_pos) <= center_distance: if abs(playerPos - objPos) <= centerDistance:
# Equal volume in both speakers (center) # Equal volume in both speakers (center)
channel.set_volume(final_volume, final_volume) channel.set_volume(finalVolume, finalVolume)
elif player_pos > obj_pos: elif playerPos > objPos:
# Object is to the left of player # Object is to the left of player
channel.set_volume(final_volume, (final_volume + 0.01) / 2) channel.set_volume(finalVolume, (finalVolume + 0.01) / 2)
else: else:
# Object is to the right of player # Object is to the right of player
channel.set_volume((final_volume + 0.01) / 2, final_volume) channel.set_volume((finalVolume + 0.01) / 2, finalVolume)
return channel return channel
def cut_scene(self, sound_name): def cut_scene(self, soundName):
"""Play a sound as a cut scene, stopping other sounds. """Play a sound as a cut scene, stopping other sounds.
Args: Args:
sound_name (str): Name of sound to play soundName (str): Name of sound to play
""" """
if sound_name not in self.sounds: if soundName not in self.sounds:
return return
pygame.event.clear() pygame.event.clear()
@ -354,11 +354,11 @@ class Sound:
channel = pygame.mixer.Channel(0) channel = pygame.mixer.Channel(0)
# Apply the appropriate volume settings # Apply the appropriate volume settings
sfx_volume = self.volume_service.get_sfx_volume() sfxVolume = self.volumeService.get_sfx_volume()
channel.set_volume(sfx_volume, sfx_volume) channel.set_volume(sfxVolume, sfxVolume)
# Play the sound # Play the sound
channel.play(self.sounds[sound_name]) channel.play(self.sounds[soundName])
while pygame.mixer.get_busy(): while pygame.mixer.get_busy():
for event in pygame.event.get(): for event in pygame.event.get():
@ -367,74 +367,74 @@ class Sound:
return return
pygame.time.delay(10) pygame.time.delay(10)
def play_random_falling(self, sound_prefix, player_x, object_x, start_y, def play_random_falling(self, soundPrefix, playerX, objectX, startY,
current_y=0, max_y=20, existing_channel=None): currentY=0, maxY=20, existingChannel=None):
"""Play or update a falling sound with positional audio and volume based on height. """Play or update a falling sound with positional audio and volume based on height.
Args: Args:
sound_prefix (str): Base name of sound to match soundPrefix (str): Base name of sound to match
player_x (float): Player's x position playerX (float): Player's x position
object_x (float): Object's x position objectX (float): Object's x position
start_y (float): Starting Y position (0-20, higher = quieter start) startY (float): Starting Y position (0-20, higher = quieter start)
current_y (float): Current Y position (0 = ground level) (default: 0) currentY (float): Current Y position (0 = ground level) (default: 0)
max_y (float): Maximum Y value (default: 20) maxY (float): Maximum Y value (default: 20)
existing_channel: Existing sound channel to update (default: None) existingChannel: Existing sound channel to update (default: None)
Returns: Returns:
pygame.mixer.Channel: Sound channel for updating position/volume, pygame.mixer.Channel: Sound channel for updating position/volume,
or None if sound should stop or None if sound should stop
""" """
# Calculate horizontal positioning # Calculate horizontal positioning
volume, left, right = self.calculate_volume_and_pan(player_x, object_x) volume, left, right = self.calculate_volume_and_pan(playerX, objectX)
# Calculate vertical fall volume multiplier (0 at max_y, 1 at y=0) # Calculate vertical fall volume multiplier (0 at maxY, 1 at y=0)
fall_multiplier = 1 - (current_y / max_y) fallMultiplier = 1 - (currentY / maxY)
# Adjust final volumes # Adjust final volumes
final_volume = volume * fall_multiplier finalVolume = volume * fallMultiplier
final_left = left * final_volume finalLeft = left * finalVolume
final_right = right * final_volume finalRight = right * finalVolume
if existing_channel is not None: if existingChannel is not None:
if volume == 0: # Out of audible range if volume == 0: # Out of audible range
existing_channel.stop() existingChannel.stop()
return None return None
existing_channel.set_volume( existingChannel.set_volume(
final_left * self.volume_service.sfx_volume, finalLeft * self.volumeService.sfxVolume,
final_right * self.volume_service.sfx_volume finalRight * self.volumeService.sfxVolume
) )
return existing_channel return existingChannel
else: # Need to create new channel else: # Need to create new channel
if volume == 0: # Don't start if out of range if volume == 0: # Don't start if out of range
return None return None
# Find matching sound files # Find matching sound files
keys = [k for k in self.sounds.keys() if k.startswith(sound_prefix)] keys = [k for k in self.sounds.keys() if k.startswith(soundPrefix)]
if not keys: if not keys:
return None return None
random_key = random.choice(keys) randomKey = random.choice(keys)
channel = self.sounds[random_key].play() channel = self.sounds[randomKey].play()
if channel: if channel:
channel.set_volume( channel.set_volume(
final_left * self.volume_service.sfx_volume, finalLeft * self.volumeService.sfxVolume,
final_right * self.volume_service.sfx_volume finalRight * self.volumeService.sfxVolume
) )
return channel return channel
# Global functions for backward compatibility # Global functions for backward compatibility
def play_bgm(music_file): def play_bgm(musicFile):
"""Play background music with proper volume settings. """Play background music with proper volume settings.
Args: Args:
music_file (str): Path to the music file to play musicFile (str): Path to the music file to play
""" """
try: try:
pygame.mixer.music.stop() pygame.mixer.music.stop()
pygame.mixer.music.load(music_file) pygame.mixer.music.load(musicFile)
pygame.mixer.music.set_volume(volume_service.get_bgm_volume()) pygame.mixer.music.set_volume(volumeService.get_bgm_volume())
pygame.mixer.music.play(-1) # Loop indefinitely pygame.mixer.music.play(-1) # Loop indefinitely
except Exception as e: except Exception as e:
pass pass
@ -445,7 +445,7 @@ def adjust_master_volume(change):
Args: Args:
change (float): Amount to change volume by (positive or negative) change (float): Amount to change volume by (positive or negative)
""" """
volume_service.adjust_master_volume(change, pygame.mixer) volumeService.adjust_master_volume(change, pygame.mixer)
def adjust_bgm_volume(change): def adjust_bgm_volume(change):
"""Adjust only the background music volume. """Adjust only the background music volume.
@ -453,7 +453,7 @@ def adjust_bgm_volume(change):
Args: Args:
change (float): Amount to change volume by (positive or negative) change (float): Amount to change volume by (positive or negative)
""" """
volume_service.adjust_bgm_volume(change, pygame.mixer) volumeService.adjust_bgm_volume(change, pygame.mixer)
def adjust_sfx_volume(change): def adjust_sfx_volume(change):
"""Adjust volume for sound effects only. """Adjust volume for sound effects only.
@ -461,37 +461,37 @@ def adjust_sfx_volume(change):
Args: Args:
change (float): Amount to change volume by (positive or negative) change (float): Amount to change volume by (positive or negative)
""" """
volume_service.adjust_sfx_volume(change, pygame.mixer) volumeService.adjust_sfx_volume(change, pygame.mixer)
def calculate_volume_and_pan(player_pos, obj_pos): def calculate_volume_and_pan(playerPos, objPos):
"""Calculate volume and stereo panning based on relative positions. """Calculate volume and stereo panning based on relative positions.
Args: Args:
player_pos (float): Player's position on x-axis playerPos (float): Player's position on x-axis
obj_pos (float): Object's position on x-axis objPos (float): Object's position on x-axis
Returns: Returns:
tuple: (volume, left_vol, right_vol) values between 0 and 1 tuple: (volume, left_vol, right_vol) values between 0 and 1
""" """
distance = abs(player_pos - obj_pos) distance = abs(playerPos - objPos)
max_distance = 12 # Maximum audible distance maxDistance = 12 # Maximum audible distance
if distance > max_distance: if distance > maxDistance:
return 0, 0, 0 # No sound if out of range return 0, 0, 0 # No sound if out of range
# Calculate volume (non-linear scaling for more noticeable changes) # Calculate volume (non-linear scaling for more noticeable changes)
# Apply masterVolume as the maximum possible volume # Apply masterVolume as the maximum possible volume
volume = (((max_distance - distance) / max_distance) ** 1.5) * volume_service.master_volume volume = (((maxDistance - distance) / maxDistance) ** 1.5) * volumeService.masterVolume
# Determine left/right based on relative position # Determine left/right based on relative position
if player_pos < obj_pos: if playerPos < objPos:
# Object is to the right # Object is to the right
left = max(0, 1 - (obj_pos - player_pos) / max_distance) left = max(0, 1 - (objPos - playerPos) / maxDistance)
right = 1 right = 1
elif player_pos > obj_pos: elif playerPos > objPos:
# Object is to the left # Object is to the left
left = 1 left = 1
right = max(0, 1 - (player_pos - obj_pos) / max_distance) right = max(0, 1 - (playerPos - objPos) / maxDistance)
else: else:
# Player is on the object # Player is on the object
left = right = 1 left = right = 1
@ -510,40 +510,40 @@ def play_sound(sound, volume=1.0):
""" """
channel = sound.play() channel = sound.play()
if channel: if channel:
channel.set_volume(volume * volume_service.get_sfx_volume()) channel.set_volume(volume * volumeService.get_sfx_volume())
return channel return channel
def obj_play(sounds, soundName, player_pos, obj_pos, loop=True): def obj_play(sounds, soundName, playerPos, objPos, loop=True):
"""Play a sound with positional audio. """Play a sound with positional audio.
Args: Args:
sounds (dict): Dictionary of sound objects sounds (dict): Dictionary of sound objects
soundName (str): Name of sound to play soundName (str): Name of sound to play
player_pos (float): Player's position for audio panning playerPos (float): Player's position for audio panning
obj_pos (float): Object's position for audio panning objPos (float): Object's position for audio panning
loop (bool): Whether to loop the sound (default: True) loop (bool): Whether to loop the sound (default: True)
Returns: Returns:
pygame.mixer.Channel: Sound channel object, or None if out of range pygame.mixer.Channel: Sound channel object, or None if out of range
""" """
volume, left, right = calculate_volume_and_pan(player_pos, obj_pos) volume, left, right = calculate_volume_and_pan(playerPos, objPos)
if volume == 0: if volume == 0:
return None # Don't play if out of range return None # Don't play if out of range
# Play the sound on a new channel # Play the sound on a new channel
channel = sounds[soundName].play(-1 if loop else 0) channel = sounds[soundName].play(-1 if loop else 0)
if channel: if channel:
channel.set_volume(volume * left * volume_service.sfx_volume, channel.set_volume(volume * left * volumeService.sfxVolume,
volume * right * volume_service.sfx_volume) volume * right * volumeService.sfxVolume)
return channel return channel
def obj_update(channel, player_pos, obj_pos): def obj_update(channel, playerPos, objPos):
"""Update positional audio for a playing sound. """Update positional audio for a playing sound.
Args: Args:
channel: Sound channel to update channel: Sound channel to update
player_pos (float): New player position playerPos (float): New player position
obj_pos (float): New object position objPos (float): New object position
Returns: Returns:
pygame.mixer.Channel: Updated channel, or None if sound should stop pygame.mixer.Channel: Updated channel, or None if sound should stop
@ -551,14 +551,14 @@ def obj_update(channel, player_pos, obj_pos):
if channel is None: if channel is None:
return None return None
volume, left, right = calculate_volume_and_pan(player_pos, obj_pos) volume, left, right = calculate_volume_and_pan(playerPos, objPos)
if volume == 0: if volume == 0:
channel.stop() channel.stop()
return None return None
# Apply the volume and pan # Apply the volume and pan
channel.set_volume(volume * left * volume_service.sfx_volume, channel.set_volume(volume * left * volumeService.sfxVolume,
volume * right * volume_service.sfx_volume) volume * right * volumeService.sfxVolume)
return channel return channel
def obj_stop(channel): def obj_stop(channel):
@ -601,8 +601,8 @@ def play_ambiance(sounds, soundNames, probability, randomLocation=False):
channel = sounds[ambianceSound].play() channel = sounds[ambianceSound].play()
if randomLocation and channel: if randomLocation and channel:
leftVolume = random.random() * volume_service.get_sfx_volume() leftVolume = random.random() * volumeService.get_sfx_volume()
rightVolume = random.random() * volume_service.get_sfx_volume() rightVolume = random.random() * volumeService.get_sfx_volume()
channel.set_volume(leftVolume, rightVolume) channel.set_volume(leftVolume, rightVolume)
return channel return channel
@ -632,20 +632,20 @@ def play_random(sounds, soundName, pause=False, interrupt=False):
channel = sounds[randomKey].play() channel = sounds[randomKey].play()
if channel: if channel:
sfx_volume = volume_service.get_sfx_volume() sfxVolume = volumeService.get_sfx_volume()
channel.set_volume(sfx_volume, sfx_volume) channel.set_volume(sfxVolume, sfxVolume)
if pause: if pause:
time.sleep(sounds[randomKey].get_length()) time.sleep(sounds[randomKey].get_length())
def play_random_positional(sounds, soundName, player_x, object_x): def play_random_positional(sounds, soundName, playerX, objectX):
"""Play a random variation of a sound with positional audio. """Play a random variation of a sound with positional audio.
Args: Args:
sounds (dict): Dictionary of sound objects sounds (dict): Dictionary of sound objects
soundName (str): Base name of sound to match soundName (str): Base name of sound to match
player_x (float): Player's x position playerX (float): Player's x position
object_x (float): Object's x position objectX (float): Object's x position
Returns: Returns:
pygame.mixer.Channel: Sound channel if played, None otherwise pygame.mixer.Channel: Sound channel if played, None otherwise
@ -655,15 +655,15 @@ def play_random_positional(sounds, soundName, player_x, object_x):
return None return None
randomKey = random.choice(keys) randomKey = random.choice(keys)
volume, left, right = calculate_volume_and_pan(player_x, object_x) volume, left, right = calculate_volume_and_pan(playerX, objectX)
if volume == 0: if volume == 0:
return None return None
channel = sounds[randomKey].play() channel = sounds[randomKey].play()
if channel: if channel:
channel.set_volume(volume * left * volume_service.sfx_volume, channel.set_volume(volume * left * volumeService.sfxVolume,
volume * right * volume_service.sfx_volume) volume * right * volumeService.sfxVolume)
return channel return channel
def play_directional_sound(sounds, soundName, playerPos, objPos, centerDistance=3, volume=1.0): def play_directional_sound(sounds, soundName, playerPos, objPos, centerDistance=3, volume=1.0):
@ -686,7 +686,7 @@ def play_directional_sound(sounds, soundName, playerPos, objPos, centerDistance=
channel = sounds[soundName].play() channel = sounds[soundName].play()
if channel: if channel:
# Apply volume settings # Apply volume settings
finalVolume = volume * volume_service.get_sfx_volume() finalVolume = volume * volumeService.get_sfx_volume()
# If player is within centerDistance tiles of object, play in center # If player is within centerDistance tiles of object, play in center
if abs(playerPos - objPos) <= centerDistance: if abs(playerPos - objPos) <= centerDistance:
@ -714,8 +714,8 @@ def cut_scene(sounds, soundName):
channel = pygame.mixer.Channel(0) channel = pygame.mixer.Channel(0)
# Apply the appropriate volume settings # Apply the appropriate volume settings
sfx_volume = volume_service.get_sfx_volume() sfxVolume = volumeService.get_sfx_volume()
channel.set_volume(sfx_volume, sfx_volume) channel.set_volume(sfxVolume, sfxVolume)
# Play the sound # Play the sound
channel.play(sounds[soundName]) channel.play(sounds[soundName])
@ -727,42 +727,42 @@ def cut_scene(sounds, soundName):
return return
pygame.time.delay(10) pygame.time.delay(10)
def play_random_falling(sounds, soundName, player_x, object_x, start_y, def play_random_falling(sounds, soundName, playerX, objectX, startY,
currentY=0, max_y=20, existing_channel=None): currentY=0, maxY=20, existingChannel=None):
"""Play or update a falling sound with positional audio and volume based on height. """Play or update a falling sound with positional audio and volume based on height.
Args: Args:
sounds (dict): Dictionary of sound objects sounds (dict): Dictionary of sound objects
soundName (str): Base name of sound to match soundName (str): Base name of sound to match
player_x (float): Player's x position playerX (float): Player's x position
object_x (float): Object's x position objectX (float): Object's x position
start_y (float): Starting Y position (0-20, higher = quieter start) startY (float): Starting Y position (0-20, higher = quieter start)
currentY (float): Current Y position (0 = ground level) (default: 0) currentY (float): Current Y position (0 = ground level) (default: 0)
max_y (float): Maximum Y value (default: 20) maxY (float): Maximum Y value (default: 20)
existing_channel: Existing sound channel to update (default: None) existingChannel: Existing sound channel to update (default: None)
Returns: Returns:
pygame.mixer.Channel: Sound channel for updating position/volume, pygame.mixer.Channel: Sound channel for updating position/volume,
or None if sound should stop or None if sound should stop
""" """
# Calculate horizontal positioning # Calculate horizontal positioning
volume, left, right = calculate_volume_and_pan(player_x, object_x) volume, left, right = calculate_volume_and_pan(playerX, objectX)
# Calculate vertical fall volume multiplier (0 at max_y, 1 at y=0) # Calculate vertical fall volume multiplier (0 at maxY, 1 at y=0)
fallMultiplier = 1 - (currentY / max_y) fallMultiplier = 1 - (currentY / maxY)
# Adjust final volumes # Adjust final volumes
finalVolume = volume * fallMultiplier finalVolume = volume * fallMultiplier
finalLeft = left * finalVolume finalLeft = left * finalVolume
finalRight = right * finalVolume finalRight = right * finalVolume
if existing_channel is not None: if existingChannel is not None:
if volume == 0: # Out of audible range if volume == 0: # Out of audible range
existing_channel.stop() existingChannel.stop()
return None return None
existing_channel.set_volume(finalLeft * volume_service.sfx_volume, existingChannel.set_volume(finalLeft * volumeService.sfxVolume,
finalRight * volume_service.sfx_volume) finalRight * volumeService.sfxVolume)
return existing_channel return existingChannel
else: # Need to create new channel else: # Need to create new channel
if volume == 0: # Don't start if out of range if volume == 0: # Don't start if out of range
return None return None
@ -775,6 +775,6 @@ def play_random_falling(sounds, soundName, player_x, object_x, start_y,
randomKey = random.choice(keys) randomKey = random.choice(keys)
channel = sounds[randomKey].play() channel = sounds[randomKey].play()
if channel: if channel:
channel.set_volume(finalLeft * volume_service.sfx_volume, channel.set_volume(finalLeft * volumeService.sfxVolume,
finalRight * volume_service.sfx_volume) finalRight * volumeService.sfxVolume)
return channel return channel

54
speech.py
View File

@ -28,19 +28,19 @@ class Speech:
def __init__(self): def __init__(self):
"""Initialize speech system with available provider.""" """Initialize speech system with available provider."""
# Handle speech delays so we don't get stuttering # Handle speech delays so we don't get stuttering
self.last_spoken = {"text": None, "time": 0} self.lastSpoken = {"text": None, "time": 0}
self.speech_delay = 250 # ms self.speechDelay = 250 # ms
# Try to initialize a speech provider # Try to initialize a speech provider
self.provider = None self.provider = None
self.provider_name = None self.providerName = None
# Try speechd first # Try speechd first
try: try:
import speechd import speechd
self.spd = speechd.Client() self.spd = speechd.Client()
self.provider = self.spd self.provider = self.spd
self.provider_name = "speechd" self.providerName = "speechd"
return return
except ImportError: except ImportError:
pass pass
@ -50,7 +50,7 @@ class Speech:
import accessible_output2.outputs.auto import accessible_output2.outputs.auto
self.ao2 = accessible_output2.outputs.auto.Auto() self.ao2 = accessible_output2.outputs.auto.Auto()
self.provider = self.ao2 self.provider = self.ao2
self.provider_name = "accessible_output2" self.providerName = "accessible_output2"
return return
except ImportError: except ImportError:
pass pass
@ -68,23 +68,23 @@ class Speech:
if not self.provider: if not self.provider:
return return
current_time = pygame.time.get_ticks() currentTime = pygame.time.get_ticks()
# Check if this is the same text within the delay window # Check if this is the same text within the delay window
if (self.last_spoken["text"] == text and if (self.lastSpoken["text"] == text and
current_time - self.last_spoken["time"] < self.speech_delay): currentTime - self.lastSpoken["time"] < self.speechDelay):
return return
# Update last spoken tracking # Update last spoken tracking
self.last_spoken["text"] = text self.lastSpoken["text"] = text
self.last_spoken["time"] = current_time self.lastSpoken["time"] = currentTime
# Proceed with speech # Proceed with speech
if self.provider_name == "speechd": if self.providerName == "speechd":
if interrupt: if interrupt:
self.spd.cancel() self.spd.cancel()
self.spd.say(text) self.spd.say(text)
elif self.provider_name == "accessible_output2": elif self.providerName == "accessible_output2":
self.ao2.speak(text, interrupt=interrupt) self.ao2.speak(text, interrupt=interrupt)
# Display the text on screen # Display the text on screen
@ -94,29 +94,29 @@ class Speech:
font = pygame.font.Font(None, 36) font = pygame.font.Font(None, 36)
# Wrap the text # Wrap the text
max_width = screen.get_width() - 40 # Leave a 20-pixel margin on each side maxWidth = screen.get_width() - 40 # Leave a 20-pixel margin on each side
wrapped_text = textwrap.wrap(text, width=max_width // font.size('A')[0]) wrappedText = textwrap.wrap(text, width=maxWidth // font.size('A')[0])
# Render each line # Render each line
text_surfaces = [font.render(line, True, (255, 255, 255)) for line in wrapped_text] textSurfaces = [font.render(line, True, (255, 255, 255)) for line in wrappedText]
screen.fill((0, 0, 0)) # Clear screen with black screen.fill((0, 0, 0)) # Clear screen with black
# Calculate total height of text block # Calculate total height of text block
total_height = sum(surface.get_height() for surface in text_surfaces) totalHeight = sum(surface.get_height() for surface in textSurfaces)
# Start y-position (centered vertically) # Start y-position (centered vertically)
current_y = (screen.get_height() - total_height) // 2 currentY = (screen.get_height() - totalHeight) // 2
# Blit each line of text # Blit each line of text
for surface in text_surfaces: for surface in textSurfaces:
text_rect = surface.get_rect(center=(screen.get_width() // 2, current_y + surface.get_height() // 2)) textRect = surface.get_rect(center=(screen.get_width() // 2, currentY + surface.get_height() // 2))
screen.blit(surface, text_rect) screen.blit(surface, textRect)
current_y += surface.get_height() currentY += surface.get_height()
pygame.display.flip() pygame.display.flip()
def close(self): def close(self):
"""Clean up speech resources.""" """Clean up speech resources."""
if self.provider_name == "speechd": if self.providerName == "speechd":
self.spd.close() self.spd.close()
# Global instance for backward compatibility # Global instance for backward compatibility
_speech_instance = None _speechInstance = None
def speak(text, interrupt=True): def speak(text, interrupt=True):
"""Speak text using the global speech instance. """Speak text using the global speech instance.
@ -125,10 +125,10 @@ def speak(text, interrupt=True):
text (str): Text to speak and display text (str): Text to speak and display
interrupt (bool): Whether to interrupt current speech (default: True) interrupt (bool): Whether to interrupt current speech (default: True)
""" """
global _speech_instance global _speechInstance
if _speech_instance is None: if _speechInstance is None:
_speech_instance = Speech.get_instance() _speechInstance = Speech.get_instance()
_speech_instance.speak(text, interrupt) _speechInstance.speak(text, interrupt)
def messagebox(text): def messagebox(text):
"""Display a simple message box with text. """Display a simple message box with text.

114
utils.py
View File

@ -36,10 +36,10 @@ class Game:
self.title = title self.title = title
# Initialize services # Initialize services
self.path_service = PathService.get_instance().initialize(title) self.pathService = PathService.get_instance().initialize(title)
self.config_service = ConfigService.get_instance() self.configService = ConfigService.get_instance()
self.config_service.set_game_info(title, self.path_service) self.configService.set_game_info(title, self.pathService)
self.volume_service = VolumeService.get_instance() self.volumeService = VolumeService.get_instance()
# Initialize game components (lazy loaded) # Initialize game components (lazy loaded)
self._speech = None self._speech = None
@ -47,7 +47,7 @@ class Game:
self._scoreboard = None self._scoreboard = None
# Display text instructions flag # Display text instructions flag
self.display_text_usage_instructions = False self.displayTextUsageInstructions = False
@property @property
def speech(self): def speech(self):
@ -68,7 +68,7 @@ class Game:
Sound: Sound system instance Sound: Sound system instance
""" """
if not self._sound: if not self._sound:
self._sound = Sound("sounds/", self.volume_service) self._sound = Sound("sounds/", self.volumeService)
return self._sound return self._sound
@property @property
@ -79,7 +79,7 @@ class Game:
Scoreboard: Scoreboard instance Scoreboard: Scoreboard instance
""" """
if not self._scoreboard: if not self._scoreboard:
self._scoreboard = Scoreboard(self.config_service) self._scoreboard = Scoreboard(self.configService)
return self._scoreboard return self._scoreboard
def initialize(self): def initialize(self):
@ -130,89 +130,89 @@ class Game:
self.speech.speak(text, interrupt) self.speech.speak(text, interrupt)
return self return self
def play_bgm(self, music_file): def play_bgm(self, musicFile):
"""Play background music. """Play background music.
Args: Args:
music_file (str): Path to music file musicFile (str): Path to music file
Returns: Returns:
Game: Self for method chaining Game: Self for method chaining
""" """
self.sound.play_bgm(music_file) self.sound.play_bgm(musicFile)
return self return self
def display_text(self, text_lines): def display_text(self, textLines):
"""Display text with navigation controls. """Display text with navigation controls.
Args: Args:
text_lines (list): List of text lines textLines (list): List of text lines
Returns: Returns:
Game: Self for method chaining Game: Self for method chaining
""" """
# Store original text with blank lines for copying # Store original text with blank lines for copying
original_text = text_lines.copy() originalText = textLines.copy()
# Create navigation text by filtering out blank lines # Create navigation text by filtering out blank lines
nav_text = [line for line in text_lines if line.strip()] navText = [line for line in textLines if line.strip()]
# Add instructions at the start on the first display # Add instructions at the start on the first display
if not self.display_text_usage_instructions: if not self.displayTextUsageInstructions:
instructions = ("Press space to read the whole text. Use up and down arrows to navigate " instructions = ("Press space to read the whole text. Use up and down arrows to navigate "
"the text line by line. Press c to copy the current line to the clipboard " "the text line by line. Press c to copy the current line to the clipboard "
"or t to copy the entire text. Press enter or escape when you are done reading.") "or t to copy the entire text. Press enter or escape when you are done reading.")
nav_text.insert(0, instructions) navText.insert(0, instructions)
self.display_text_usage_instructions = True self.displayTextUsageInstructions = True
# Add end marker # Add end marker
nav_text.append("End of text.") navText.append("End of text.")
current_index = 0 currentIndex = 0
self.speech.speak(nav_text[current_index]) self.speech.speak(navText[currentIndex])
while True: while True:
event = pygame.event.wait() event = pygame.event.wait()
if event.type == pygame.KEYDOWN: if event.type == pygame.KEYDOWN:
# Check for Alt modifier # Check for Alt modifier
mods = pygame.key.get_mods() mods = pygame.key.get_mods()
alt_pressed = mods & pygame.KMOD_ALT altPressed = mods & pygame.KMOD_ALT
# Volume controls (require Alt) # Volume controls (require Alt)
if alt_pressed: if altPressed:
if event.key == pygame.K_PAGEUP: if event.key == pygame.K_PAGEUP:
self.volume_service.adjust_master_volume(0.1, pygame.mixer) self.volumeService.adjust_master_volume(0.1, pygame.mixer)
elif event.key == pygame.K_PAGEDOWN: elif event.key == pygame.K_PAGEDOWN:
self.volume_service.adjust_master_volume(-0.1, pygame.mixer) self.volumeService.adjust_master_volume(-0.1, pygame.mixer)
elif event.key == pygame.K_HOME: elif event.key == pygame.K_HOME:
self.volume_service.adjust_bgm_volume(0.1, pygame.mixer) self.volumeService.adjust_bgm_volume(0.1, pygame.mixer)
elif event.key == pygame.K_END: elif event.key == pygame.K_END:
self.volume_service.adjust_bgm_volume(-0.1, pygame.mixer) self.volumeService.adjust_bgm_volume(-0.1, pygame.mixer)
elif event.key == pygame.K_INSERT: elif event.key == pygame.K_INSERT:
self.volume_service.adjust_sfx_volume(0.1, pygame.mixer) self.volumeService.adjust_sfx_volume(0.1, pygame.mixer)
elif event.key == pygame.K_DELETE: elif event.key == pygame.K_DELETE:
self.volume_service.adjust_sfx_volume(-0.1, pygame.mixer) self.volumeService.adjust_sfx_volume(-0.1, pygame.mixer)
else: else:
if event.key in (pygame.K_ESCAPE, pygame.K_RETURN): if event.key in (pygame.K_ESCAPE, pygame.K_RETURN):
return self return self
if event.key in [pygame.K_DOWN, pygame.K_s] and current_index < len(nav_text) - 1: if event.key in [pygame.K_DOWN, pygame.K_s] and currentIndex < len(navText) - 1:
current_index += 1 currentIndex += 1
self.speech.speak(nav_text[current_index]) self.speech.speak(navText[currentIndex])
if event.key in [pygame.K_UP, pygame.K_w] and current_index > 0: if event.key in [pygame.K_UP, pygame.K_w] and currentIndex > 0:
current_index -= 1 currentIndex -= 1
self.speech.speak(nav_text[current_index]) self.speech.speak(navText[currentIndex])
if event.key == pygame.K_SPACE: if event.key == pygame.K_SPACE:
# Join with newlines to preserve spacing in speech # Join with newlines to preserve spacing in speech
self.speech.speak('\n'.join(original_text[1:-1])) self.speech.speak('\n'.join(originalText[1:-1]))
if event.key == pygame.K_c: if event.key == pygame.K_c:
try: try:
import pyperclip import pyperclip
pyperclip.copy(nav_text[current_index]) pyperclip.copy(navText[currentIndex])
self.speech.speak("Copied " + nav_text[current_index] + " to the clipboard.") self.speech.speak("Copied " + navText[currentIndex] + " to the clipboard.")
except: except:
self.speech.speak("Failed to copy the text to the clipboard.") self.speech.speak("Failed to copy the text to the clipboard.")
@ -220,7 +220,7 @@ class Game:
try: try:
import pyperclip import pyperclip
# Join with newlines to preserve blank lines in full text # Join with newlines to preserve blank lines in full text
pyperclip.copy(''.join(original_text[2:-1])) pyperclip.copy(''.join(originalText[2:-1]))
self.speech.speak("Copied entire message to the clipboard.") self.speech.speak("Copied entire message to the clipboard.")
except: except:
self.speech.speak("Failed to copy the text to the clipboard.") self.speech.speak("Failed to copy the text to the clipboard.")
@ -239,12 +239,12 @@ class Game:
# Utility functions # Utility functions
def check_for_updates(current_version, game_name, url): def check_for_updates(currentVersion, gameName, url):
"""Check for game updates. """Check for game updates.
Args: Args:
current_version (str): Current version string (e.g. "1.0.0") currentVersion (str): Current version string (e.g. "1.0.0")
game_name (str): Name of the game gameName (str): Name of the game
url (str): URL to check for updates url (str): URL to check for updates
Returns: Returns:
@ -254,7 +254,7 @@ def check_for_updates(current_version, game_name, url):
response = requests.get(url, timeout=5) response = requests.get(url, timeout=5)
if response.status_code == 200: if response.status_code == 200:
data = response.json() data = response.json()
if 'version' in data and data['version'] > current_version: if 'version' in data and data['version'] > currentVersion:
return { return {
'version': data['version'], 'version': data['version'],
'url': data.get('url', ''), 'url': data.get('url', ''),
@ -264,29 +264,29 @@ def check_for_updates(current_version, game_name, url):
print(f"Error checking for updates: {e}") print(f"Error checking for updates: {e}")
return None return None
def get_version_tuple(version_str): def get_version_tuple(versionStr):
"""Convert version string to comparable tuple. """Convert version string to comparable tuple.
Args: Args:
version_str (str): Version string (e.g. "1.0.0") versionStr (str): Version string (e.g. "1.0.0")
Returns: Returns:
tuple: Version as tuple of integers tuple: Version as tuple of integers
""" """
return tuple(map(int, version_str.split('.'))) return tuple(map(int, versionStr.split('.')))
def check_compatibility(required_version, current_version): def check_compatibility(requiredVersion, currentVersion):
"""Check if current version meets minimum required version. """Check if current version meets minimum required version.
Args: Args:
required_version (str): Minimum required version string requiredVersion (str): Minimum required version string
current_version (str): Current version string currentVersion (str): Current version string
Returns: Returns:
bool: True if compatible, False otherwise bool: True if compatible, False otherwise
""" """
req = get_version_tuple(required_version) req = get_version_tuple(requiredVersion)
cur = get_version_tuple(current_version) cur = get_version_tuple(currentVersion)
return cur >= req return cur >= req
def sanitize_filename(filename): def sanitize_filename(filename):
@ -350,25 +350,25 @@ def distance_2d(x1, y1, x2, y2):
""" """
return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
def generate_tone(frequency, duration=0.1, sample_rate=44100, volume=0.2): def generate_tone(frequency, duration=0.1, sampleRate=44100, volume=0.2):
"""Generate a tone at the specified frequency. """Generate a tone at the specified frequency.
Args: Args:
frequency (float): Frequency in Hz frequency (float): Frequency in Hz
duration (float): Duration in seconds (default: 0.1) duration (float): Duration in seconds (default: 0.1)
sample_rate (int): Sample rate in Hz (default: 44100) sampleRate (int): Sample rate in Hz (default: 44100)
volume (float): Volume from 0.0 to 1.0 (default: 0.2) volume (float): Volume from 0.0 to 1.0 (default: 0.2)
Returns: Returns:
pygame.mixer.Sound: Sound object with the generated tone pygame.mixer.Sound: Sound object with the generated tone
""" """
t = np.linspace(0, duration, int(sample_rate * duration), False) t = np.linspace(0, duration, int(sampleRate * duration), False)
tone = np.sin(2 * np.pi * frequency * t) tone = np.sin(2 * np.pi * frequency * t)
stereo_tone = np.vstack((tone, tone)).T # Create a 2D array for stereo stereoTone = np.vstack((tone, tone)).T # Create a 2D array for stereo
stereo_tone = (stereo_tone * 32767 * volume).astype(np.int16) # Apply volume stereoTone = (stereoTone * 32767 * volume).astype(np.int16) # Apply volume
stereo_tone = np.ascontiguousarray(stereo_tone) # Ensure C-contiguous array stereoTone = np.ascontiguousarray(stereoTone) # Ensure C-contiguous array
return pygame.sndarray.make_sound(stereo_tone) return pygame.sndarray.make_sound(stereoTone)
def x_powerbar(): def x_powerbar():
"""Sound based horizontal power bar """Sound based horizontal power bar