Merge pull request #87 from Preponderous-Software/copilot/fix-23cdbfde-e934-442b-a458-2d5a2e1c718c

Implement comprehensive Options Menu Screen with enhanced button feedback and ESC key navigation

Author: dmccoystephenson

src/audio/__init__.py

@@ -0,0 +1 @@
+# Audio package

src/audio/audio_manager.py

@@ -0,0 +1,105 @@
+import pygame
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class AudioManager:
+    """Manages audio playback and volume controls"""
+    
+    def __init__(self, config):
+        self.config = config
+        self.initialized = False
+        
+        try:
+            # Initialize pygame mixer for audio
+            pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=512)
+            self.initialized = True
+            logger.info("Audio system initialized successfully")
+        except pygame.error as e:
+            logger.warning(f"Failed to initialize audio system: {e}")
+            self.initialized = False
+    
+    def play_sound_effect(self, sound_name: str = "default"):
+        """Play a sound effect with SFX volume"""
+        if not self.initialized:
+            return
+            
+        try:
+            # Create a simple beep sound programmatically since we don't have audio files
+            # This is a placeholder that demonstrates volume control
+            effective_volume = self.config.master_volume * self.config.sfx_volume
+            
+            if effective_volume > 0:
+                # Generate a simple tone for demonstration
+                duration = 0.1  # seconds
+                sample_rate = 22050
+                frames = int(duration * sample_rate)
+                
+                # Create a simple sine wave (beep)
+                import numpy as np
+                frequency = 440  # A note
+                arr = np.sin(2 * np.pi * frequency * np.linspace(0, duration, frames))
+                arr = (arr * 32767 * effective_volume).astype(np.int16)
+                
+                # Convert to stereo
+                stereo_arr = np.zeros((frames, 2), np.int16)
+                stereo_arr[:, 0] = arr
+                stereo_arr[:, 1] = arr
+                
+                sound = pygame.sndarray.make_sound(stereo_arr)
+                sound.play()
+                logger.debug(f"Played sound effect '{sound_name}' at volume {effective_volume:.2f}")
+        except Exception as e:
+            logger.debug(f"Could not play sound effect: {e}")
+    
+    def play_music(self, music_name: str = "background"):
+        """Play background music with music volume"""
+        if not self.initialized:
+            return
+            
+        try:
+            # Set music volume
+            effective_volume = self.config.master_volume * self.config.music_volume
+            pygame.mixer.music.set_volume(effective_volume)
+            logger.debug(f"Set music volume to {effective_volume:.2f}")
+            
+            # In a real implementation, you would load and play music files here
+            # pygame.mixer.music.load("path/to/music/file.ogg")
+            # pygame.mixer.music.play(-1)  # Loop indefinitely
+            
+        except Exception as e:
+            logger.debug(f"Could not play music: {e}")
+    
+    def stop_music(self):
+        """Stop background music"""
+        if not self.initialized:
+            return
+            
+        try:
+            pygame.mixer.music.stop()
+        except Exception as e:
+            logger.debug(f"Could not stop music: {e}")
+    
+    def update_volumes(self):
+        """Update all audio volumes based on current config"""
+        if not self.initialized:
+            return
+            
+        # Update music volume if music is playing
+        try:
+            effective_volume = self.config.master_volume * self.config.music_volume
+            pygame.mixer.music.set_volume(effective_volume)
+            logger.debug(f"Updated music volume to {effective_volume:.2f}")
+        except Exception as e:
+            logger.debug(f"Could not update music volume: {e}")
+    
+    def cleanup(self):
+        """Clean up audio resources"""
+        if self.initialized:
+            try:
+                pygame.mixer.quit()
+                logger.info("Audio system cleaned up")
+            except Exception as e:
+                logger.warning(f"Error during audio cleanup: {e}")

src/config/config.py

@@ -1,6 +1,9 @@
 # @author Daniel McCoy Stephenson
 # @since August 6th, 2022
 
+import json
+import os
+import pygame
 
 # @author Daniel McCoy Stephenson
 # @since August 6th, 2022
@@ -15,16 +18,105 @@ def __init__(self):
         self.green = (0, 255, 0)
         self.red = (255, 0, 0)
         self.yellow = (255, 255, 0)
+        self.blue = (0, 0, 255)
+        self.gray = (128, 128, 128)
         self.text_size = 50
 
+        # audio settings
+        self.master_volume = 0.7
+        self.music_volume = 0.5
+        self.sfx_volume = 0.8
+
         # grid size
         self.initial_grid_size = 5
 
         # tick speed
         self.limit_tick_speed = True
         self.tick_speed = 0.1
 
+        # difficulty settings
+        self.difficulty = "Normal"  # Easy, Normal, Hard
+        
+        # key bindings
+        self.key_bindings = {
+            'move_up': pygame.K_w,
+            'move_down': pygame.K_s,
+            'move_left': pygame.K_a,
+            'move_right': pygame.K_d,
+            'fullscreen': pygame.K_F11,
+            'restart': pygame.K_r,
+            'quit': pygame.K_q
+        }
+
         # misc
         self.debug = False
         self.restart_upon_collision = True
         self.level_progress_percentage_required = 0.25
+        
+        # Load saved settings
+        self.load_settings()
+
+    def get_available_resolutions(self):
+        """Get available display resolutions"""
+        return [
+            (500, 500),
+            (800, 600),
+            (1024, 768),
+            (1280, 720),
+            (1920, 1080)
+        ]
+    
+    def get_difficulty_levels(self):
+        """Get available difficulty levels"""
+        return ["Easy", "Normal", "Hard"]
+    
+    def save_settings(self):
+        """Save current settings to file"""
+        settings = {
+            'display_width': self.display_width,
+            'display_height': self.display_height,
+            'fullscreen': self.fullscreen,
+            'master_volume': self.master_volume,
+            'music_volume': self.music_volume,
+            'sfx_volume': self.sfx_volume,
+            'limit_tick_speed': self.limit_tick_speed,
+            'tick_speed': self.tick_speed,
+            'difficulty': self.difficulty,
+            'initial_grid_size': self.initial_grid_size,
+            'level_progress_percentage_required': self.level_progress_percentage_required,
+            'key_bindings': self.key_bindings
+        }
+        
+        try:
+            os.makedirs('config', exist_ok=True)
+            with open('config/settings.json', 'w') as f:
+                json.dump(settings, f, indent=2)
+        except Exception as e:
+            print(f"Warning: Could not save settings: {e}")
+    
+    def load_settings(self):
+        """Load settings from file"""
+        try:
+            with open('config/settings.json', 'r') as f:
+                settings = json.load(f)
+                
+            self.display_width = settings.get('display_width', self.display_width)
+            self.display_height = settings.get('display_height', self.display_height)
+            self.fullscreen = settings.get('fullscreen', self.fullscreen)
+            self.master_volume = settings.get('master_volume', self.master_volume)
+            self.music_volume = settings.get('music_volume', self.music_volume)
+            self.sfx_volume = settings.get('sfx_volume', self.sfx_volume)
+            self.limit_tick_speed = settings.get('limit_tick_speed', self.limit_tick_speed)
+            self.tick_speed = settings.get('tick_speed', self.tick_speed)
+            self.difficulty = settings.get('difficulty', self.difficulty)
+            self.initial_grid_size = settings.get('initial_grid_size', self.initial_grid_size)
+            self.level_progress_percentage_required = settings.get('level_progress_percentage_required', self.level_progress_percentage_required)
+            
+            # Load key bindings, ensuring they are valid pygame key constants
+            saved_bindings = settings.get('key_bindings', {})
+            for key, value in saved_bindings.items():
+                if key in self.key_bindings and isinstance(value, int):
+                    self.key_bindings[key] = value
+        except (FileNotFoundError, json.JSONDecodeError):
+            # File doesn't exist or is invalid, use defaults
+            pass

src/environment/pyEnvLibEnvironmentRepositoryImpl.py

@@ -25,11 +25,24 @@ def __init__(self, level: int, config: Config, snake_part_repository: SnakePartR
         self.level = level
         self.config = config
         self.snake_part_repository = snake_part_repository
+        
+        # Adjust game parameters based on difficulty
+        base_grid_size = config.initial_grid_size
         if level == 1:
-            grid_size = config.initial_grid_size
+            grid_size = base_grid_size
         else:
-            grid_size = config.initial_grid_size + level
-        logging.info("Initializing environment repository for level " + str(level) + " with grid size " + str(grid_size))
+            grid_size = base_grid_size + level
+            
+        # Apply difficulty modifiers
+        if config.difficulty == "Easy":
+            # Larger grid = easier game
+            grid_size = max(5, int(grid_size * 1.3))
+        elif config.difficulty == "Hard":
+            # Smaller grid = harder game (but ensure minimum of 4 for Hard)
+            grid_size = max(4, int(grid_size * 0.7))
+        # Normal difficulty uses default grid size
+        
+        logging.info(f"Initializing environment repository for level {level} with grid size {grid_size} (difficulty: {config.difficulty})")
         self.environment = Environment(
             "Level " + str(level), grid_size
         )