diff --git a/__pycache__/bird_manager.cpython-310.pyc b/__pycache__/bird_manager.cpython-310.pyc
new file mode 100644
index 0000000..21b9b1d
Binary files /dev/null and b/__pycache__/bird_manager.cpython-310.pyc differ
diff --git a/__pycache__/test_bird_manager.cpython-310.pyc b/__pycache__/test_bird_manager.cpython-310.pyc
new file mode 100644
index 0000000..2ba1a9b
Binary files /dev/null and b/__pycache__/test_bird_manager.cpython-310.pyc differ
diff --git a/bird_manager.py b/bird_manager.py
index 2bf52dc..ee851ad 100644
--- a/bird_manager.py
+++ b/bird_manager.py
@@ -4,7 +4,8 @@
 class BirdManager:
     def __init__(self):
         self.progress_file = 'bird_progress.json'
-        self.unlocked_birds = {'red', 'yellow', 'blue'}
+        # Initialize unlocked_birds with 'blue' unlocked by default
+        self.unlocked_birds = {'blue': True, 'red': False, 'yellow': False}
         self.achievements = {
             'red': {'name': 'Speed Demon', 'requirement': 50, 'description': 'Moves faster horizontally.'},
             'yellow': {'name': 'Heavy Lifter', 'requirement': 30, 'description': 'Stronger flap, falls faster.'},
@@ -14,47 +15,97 @@ def __init__(self):
             'red': 0,
             'yellow': 0,
             'blue': 0,
-            'default': 0
+            'default': 0  # Keep a default score, though bird types are specific
         }
         self.load_progress()
 
     def load_progress(self):
+        # Default state for unlocked_birds, ensuring all achievement birds are present
+        default_unlocked_birds = {bird: False for bird in self.achievements.keys()}
+        default_unlocked_birds['blue'] = True # Blue is unlocked by default
+
         try:
-            if os.path.exists('bird_progress.json'):
-                with open('bird_progress.json', 'r') as f:
+            if os.path.exists(self.progress_file):
+                with open(self.progress_file, 'r') as f:
                     data = json.load(f)
-                    self.unlocked_birds = data.get('unlocked_birds', {'default': True})
+                    # Load unlocked_birds if present
+                    # Start with a copy of the default unlocked birds state.
+                    # This ensures all known birds are present and 'blue' defaults to True.
+                    self.unlocked_birds = default_unlocked_birds.copy()
+                    
+                    loaded_saved_unlocked_birds = data.get('unlocked_birds')
+                    if loaded_saved_unlocked_birds is not None:
+                        # If there's saved data for unlocked_birds, update self.unlocked_birds.
+                        # This will override defaults for birds found in the save file.
+                        for bird_type, is_unlocked in loaded_saved_unlocked_birds.items():
+                            if bird_type in self.unlocked_birds: # Only process known bird types
+                                self.unlocked_birds[bird_type] = is_unlocked
+                    
                     self.high_scores = data.get('high_scores', self.high_scores)
-        except Exception as e:
-            print(f"Error loading progress: {e}")
+            else:
+                # File doesn't exist, so initialize with a copy of the default state.
+                print(f"Progress file '{self.progress_file}' not found. Using default progress.")
+                self.unlocked_birds = default_unlocked_birds.copy()
+                # high_scores are already initialized in __init__ and potentially updated by data.get if file existed but was empty
+                # If file truly doesn't exist, self.high_scores retains its __init__ state, which is the desired default.
+
+        except FileNotFoundError: # Explicitly handle if os.path.exists was bypassed or failed (though unlikely with current check)
+            print(f"Progress file '{self.progress_file}' not found. Initializing with default progress.")
+            self.unlocked_birds = default_unlocked_birds.copy()
+            self.high_scores = {bird: 0 for bird in self.achievements.keys()}
+            self.high_scores['default'] = 0
+        except json.JSONDecodeError as e:
+            print(f"Error decoding JSON from '{self.progress_file}': {e}. Initializing with default progress.")
+            self.unlocked_birds = default_unlocked_birds.copy()
+            self.high_scores = {bird: 0 for bird in self.achievements.keys()}
+            self.high_scores['default'] = 0
+        except IOError as e:
+            print(f"IOError loading progress from '{self.progress_file}': {e}. Initializing with default progress.")
+            self.unlocked_birds = default_unlocked_birds.copy()
+            self.high_scores = {bird: 0 for bird in self.achievements.keys()}
+            self.high_scores['default'] = 0
+        except Exception as e: # Catch any other unexpected errors
+            print(f"An unexpected error occurred while loading progress: {e}. Initializing with default progress.")
+            self.unlocked_birds = default_unlocked_birds.copy()
+            self.high_scores = {bird: 0 for bird in self.achievements.keys()}
+            self.high_scores['default'] = 0
+
 
     def save_progress(self):
         try:
-            with open('bird_progress.json', 'w') as f:
+            with open(self.progress_file, 'w') as f: # Use self.progress_file
                 json.dump({
                     'unlocked_birds': self.unlocked_birds,
                     'high_scores': self.high_scores
                 }, f)
-        except Exception as e:
-            print(f"Error saving progress: {e}")
+        except IOError as e:
+            print(f"IOError: Could not save progress to '{self.progress_file}': {e}")
+        except Exception as e: # Catch any other unexpected errors during save
+            print(f"An unexpected error occurred while saving progress: {e}")
 
     def update_score(self, bird_type, score):
+        # Ensure high_scores dictionary has the bird_type key
+        if bird_type not in self.high_scores:
+            self.high_scores[bird_type] = 0
+            
         if score > self.high_scores[bird_type]:
             self.high_scores[bird_type] = score
-            self.check_achievements(bird_type, score)
-            self.save_progress()
+            self.check_achievements(bird_type, score) # save_progress is called in check_achievements
 
     def check_achievements(self, bird_type, score):
         if bird_type in self.achievements:
-            if score >= self.achievements[bird_type]['requirement']:
+            # Unlock the bird if the score meets the requirement and it's not already unlocked
+            if not self.unlocked_birds.get(bird_type, False) and score >= self.achievements[bird_type]['requirement']:
                 self.unlocked_birds[bird_type] = True
-                self.save_progress()
+                self.save_progress() # Save progress when an achievement is unlocked
 
     def is_bird_unlocked(self, bird_type):
-        return bird_type in self.unlocked_birds
+        # Returns true if bird_type is in unlocked_birds and its value is True
+        return self.unlocked_birds.get(bird_type, False)
 
     def get_available_birds(self):
-        return ['red', 'yellow', 'blue']
+        # Returns a list of all bird types defined in achievements
+        return list(self.achievements.keys())
 
     def get_bird_achievement_info(self, bird_type):
         if bird_type in self.achievements:
diff --git a/main.py b/main.py
index 665956d..4c8b578 100644
--- a/main.py
+++ b/main.py
@@ -27,57 +27,22 @@ def resource_path(relative_path):
 clock = pygame.time.Clock()
 
 # Game Difficulty Settings
-pipe_move_speed = 2         # Reduced from 3 to 2 for better pacing
-pipe_spawn_interval = 1800  # Increased from 1500 to 1800 for more spacing
-pipe_gap_size = 150         # Keep the same gap size
+# pipe_move_speed, pipe_spawn_interval are managed by Game instance or are constants.
+# pipe_gap_size is an instance variable in Game class.
 
 # High Score File
-high_score_file = "highscore.txt"
+# high_score_file is an instance variable in Game class.
 
 # Initialize bird manager
-bird_manager = BirdManager()
+# bird_manager is an instance variable in Game class.
 
-# Game state
-game_state = 'start_screen'  # 'start_screen', 'bird_select', 'game_active', 'game_over'
-selected_bird_type = 'blue'
-score = 0
-high_score = 0
-coin_count = 0 # Initialize coin count
-pipes_passed_count = 0 # Track pipes passed for difficulty
+# Game state variables are managed by Game instance.
 
-# UI Settings
-UI_PADDING = 20
-UI_SPACING = 30
+# UI Settings, Font setup, Background scroll speed, PIPE_SPAWN_EVENT
+# All these are now instance variables in the Game class.
 
-# Font setup
-font = pygame.font.Font(None, 36)
-small_font = pygame.font.Font(None, 24)
 
-# Background scroll speed (keep global as it's a constant)
-background_scroll_speed = 0.5
-
-# Timer for spawning pipes (defined globally)
-PIPE_SPAWN_EVENT = pygame.USEREVENT # Define PIPE_SPAWN_EVENT globally
-
-# Function to load high score
-def load_high_score():
-    try:
-        with open(high_score_file, 'r') as f:
-            score_val = int(f.read())
-            return score_val
-    except (IOError, ValueError):
-        return 0
-
-# Function to save high score
-def save_high_score(score_val):
-    try:
-        with open(high_score_file, 'w') as f:
-            f.write(str(score_val))
-    except IOError:
-        print("Error saving high score")
-
-# Load high score
-high_score = load_high_score()
+# Global high_score loading is removed; Game class handles this.
 
 # Load Sounds
 try:
@@ -273,9 +238,9 @@ def draw(self, surface):
 
 # Pipe class
 class Pipe(pygame.sprite.Sprite):
-    def __init__(self, x, y, position, inverted=False):
+    def __init__(self, x, y, position, inverted=False, pipe_gap_size=150): # Added pipe_gap_size arg
         super().__init__()
-        self.image = pipe_image
+        self.image = pipe_image # pipe_image is a global asset, acceptable
         self.pipe_type = position
         pipe_width = 52
         pipe_height = 320
@@ -290,13 +255,12 @@ def __init__(self, x, y, position, inverted=False):
         self.passed = False
         self.rect = self.image.get_rect()
 
-        if position == 1:
-            if inverted:
+        if position == 1: # Top pipe
+            if inverted: # Should always be true for top pipe as asset points down
                  self.image = pygame.transform.flip(self.image, False, True)
             self.rect.bottomleft = (x, y - pipe_gap_size // 2)
-        elif position == -1:
-            if not inverted:
-                pass
+        elif position == -1: # Bottom pipe
+            # Asset points down, so no flip needed for bottom pipe
             self.rect.topleft = (x, y + pipe_gap_size // 2)
 
     def update(self, current_speed):
@@ -334,125 +298,40 @@ def update(self, current_speed):
         if self.rect.right < 0:
             self.kill()
 
-# Background scroll
-background_x = 0
+# Background scroll - This is managed by self.background_x in Game class
+# background_x = 0
 
-def display_score(state):
-    if state == 'game_active':
-        score_surface = font.render(str(int(score)), True, (255, 255, 255))
-        score_rect = score_surface.get_rect(center=(screen_width // 2, UI_PADDING + 20))
-        screen.blit(score_surface, score_rect)
-        
-        coin_surface = small_font.render(f'Coins: {coin_count}', True, (255, 255, 0))
-        coin_rect = coin_surface.get_rect(topleft=(UI_PADDING, UI_PADDING))
-        screen.blit(coin_surface, coin_rect)
-    
-    elif state == 'game_over':
-        if game_over_image:
-            game_over_rect = game_over_image.get_rect(center=(screen_width // 2, screen_height // 2 - 80))
-            screen.blit(game_over_image, game_over_rect)
-
-        score_surface = font.render(f'Score: {int(score)}', True, (255, 255, 255))
-        score_rect = score_surface.get_rect(center=(screen_width // 2, screen_height // 2))
-        screen.blit(score_surface, score_rect)
-
-        high_score_surface = font.render(f'High Score: {int(high_score)}', True, (255, 255, 255))
-        high_score_rect = high_score_surface.get_rect(center=(screen_width // 2, screen_height // 2 + UI_SPACING))
-        screen.blit(high_score_surface, high_score_rect)
-
-        restart_surface = font.render('Press R to Restart', True, (255, 255, 255))
-        restart_rect = restart_surface.get_rect(center=(screen_width // 2, screen_height // 2 + UI_SPACING * 2))
-        screen.blit(restart_surface, restart_rect)
-
-        back_to_select_surface = font.render('Press B for Bird Select', True, (255, 255, 255))
-        back_to_select_rect = back_to_select_surface.get_rect(center=(screen_width // 2, screen_height // 2 + UI_SPACING * 3))
-        screen.blit(back_to_select_surface, back_to_select_rect)
-    
-    elif state == 'start_screen':
-        if message_image:
-            message_rect = message_image.get_rect(center=(screen_width // 2, screen_height // 2 - 50))
-            screen.blit(message_image, message_rect)
-        else:
-            start_surface = font.render('Press Space to Start', True, (255, 255, 255))
-            start_rect = start_surface.get_rect(center=(screen_width // 2, screen_height // 2))
-            screen.blit(start_surface, start_rect)
-
-        high_score_display_surface = font.render(f'High Score: {int(high_score)}', True, (255, 255, 255))
-        high_score_display_rect = high_score_display_surface.get_rect(center=(screen_width // 2, screen_height // 2 + UI_SPACING))
-        screen.blit(high_score_display_surface, high_score_display_rect)
-    
-    elif state == 'bird_select':
-        overlay = pygame.Surface((screen_width, screen_height))
-        overlay.fill((0, 0, 0))
-        overlay.set_alpha(128)
-        screen.blit(overlay, (0, 0))
-
-        title_surface = font.render('Select Bird', True, (255, 255, 0))
-        title_rect = title_surface.get_rect(center=(screen_width // 2, UI_PADDING + 20))
-        screen.blit(title_surface, title_rect)
-
-        y_offset = UI_PADDING + 80
-        available_birds = bird_manager.get_available_birds()
-        for i, bird_type in enumerate(available_birds):
-            box_height = 60
-            box_rect = pygame.Rect(UI_PADDING, y_offset + i * (box_height + 10) - (box_height // 2), screen_width - UI_PADDING * 2, box_height)
-            if bird_type == selected_bird_type:
-                pygame.draw.rect(screen, (255, 255, 0), box_rect, 2)
-            else:
-                pygame.draw.rect(screen, (255, 255, 255), box_rect, 1)
-
-            text_y_name = y_offset + i * (box_height + 10) - 10
-            text_y_desc = y_offset + i * (box_height + 10) + 10
-
-            if bird_manager.is_bird_unlocked(bird_type):
-                bird_text = f"{bird_type.capitalize()} Bird"
-                if bird_type == selected_bird_type:
-                    bird_text += " ✓"
-                bird_surface = small_font.render(bird_text, True, (255, 255, 255))
-                bird_rect = bird_surface.get_rect(center=(screen_width // 2, text_y_name))
-                screen.blit(bird_surface, bird_rect)
-
-                achievement_info = bird_manager.get_bird_achievement_info(bird_type)
-                if achievement_info and 'description' in achievement_info:
-                    desc_surface = small_font.render(achievement_info['description'], True, (180, 180, 180))
-                    desc_rect = desc_surface.get_rect(center=(screen_width // 2, text_y_desc))
-                    screen.blit(desc_surface, desc_rect)
-            else:
-                achievement = bird_manager.get_bird_achievement_info(bird_type)
-                if achievement:
-                    lock_text = f"Locked: {achievement['description']}"
-                    lock_surface = small_font.render(lock_text, True, (128, 128, 128))
-                    lock_rect = lock_surface.get_rect(center=(screen_width // 2, text_y_name))
-                    screen.blit(lock_surface, lock_rect)
-
-        preview_bird = Bird(selected_bird_type)
-        preview_bird.rect.center = (screen_width // 2, screen_height - 100)
-        preview_bird.draw(screen)
-
-        nav_surface = small_font.render('↑↓ to select, Space to choose', True, (200, 200, 200))
-        nav_rect = nav_surface.get_rect(center=(screen_width // 2, screen_height - UI_PADDING - 30))
-        screen.blit(nav_surface, nav_rect)
-
-        select_surface = small_font.render('Click to Play', True, (255, 255, 255))
-        select_rect = select_surface.get_rect(center=(screen_width // 2, screen_height - UI_PADDING))
-        screen.blit(select_surface, select_rect)
+# The global display_score function is removed. Game.display_score() is used instead.
+# The global load_high_score and save_high_score functions are also removed.
 
 # --- Game Class Refactor with Difficulty Modifier ---
 class Game:
     def __init__(self):
+        # Initialize Pygame specifics that were global
+        self.font = pygame.font.Font(None, 36)
+        self.small_font = pygame.font.Font(None, 24)
+        self.PIPE_SPAWN_EVENT = pygame.USEREVENT 
+        
+        # UI and Game settings
+        self.UI_PADDING = 20
+        self.UI_SPACING = 30
+        self.background_scroll_speed = 0.5
+        self.pipe_gap_size = 150 # Added from global
+        self.high_score_file = "highscore.txt" # Added from global
+
         # Game state variables
         self.game_state = 'start_screen'
-        self.selected_bird_type = 'blue'
+        self.selected_bird_type = 'blue' 
         self.score = 0
-        self.high_score = self.load_high_score()
+        self.high_score = self._load_high_score_internal() 
         self.coin_count = 0
         self.pipes_passed_count = 0
-        self.pipe_move_speed = 2.0 # Initial pipe move speed (use float for percentage increase)
-        self.pipe_spawn_interval = 1800 # Move pipe_spawn_interval to the class
+        self.pipe_move_speed = 2.0 
+        self.pipe_spawn_interval = 1800 
 
         # Game objects and groups
         self.bird_manager = BirdManager()
-        self.bird = Bird(self.selected_bird_type)
+        self.bird = Bird(self.selected_bird_type) 
         self.pipes = pygame.sprite.Group()
         self.coins = pygame.sprite.Group()
         self.all_sprites = pygame.sprite.Group()
@@ -460,126 +339,140 @@ def __init__(self):
 
         # Background scroll
         self.background_x = 0
+        
+        # Critical asset error flag and message
+        self.critical_asset_error = False
+        self.error_message_text = ""
+
+        # Check for critical assets after loading attempts (example: pipe_image)
+        # Note: pipe_image is loaded globally. We check its state here.
+        if pipe_image is None:
+            self.critical_asset_error = True
+            self.error_message_text = "Error: Pipe image missing. Please reinstall."
+            print("CRITICAL ERROR: Pipe image (pipe-green.png) failed to load.")
+
 
-    def load_high_score(self):
+    def _load_high_score_internal(self): # Renamed from global load_high_score
         try:
-            with open(high_score_file, 'r') as f:
+            # Use self.high_score_file which is now an instance attribute
+            with open(self.high_score_file, 'r') as f:
                 score_val = int(f.read())
                 return score_val
         except (IOError, ValueError):
             return 0
 
-    def save_high_score(self):
+    def _save_high_score_internal(self): # Renamed from global save_high_score
         try:
-            with open(high_score_file, 'w') as f:
+            # Use self.high_score_file which is now an instance attribute
+            with open(self.high_score_file, 'w') as f:
                 f.write(str(int(self.high_score)))
         except IOError:
             print("Error saving high score")
 
-    def display_score(self):
+    def display_score(self): # Uses self.font, self.small_font, self.UI_PADDING, self.UI_SPACING now
         if self.game_state == 'game_active':
-            score_surface = font.render(str(int(self.score)), True, (255, 255, 255))
-            score_rect = score_surface.get_rect(center=(screen_width // 2, UI_PADDING + 20))
+            score_surface = self.font.render(str(int(self.score)), True, (255, 255, 255))
+            score_rect = score_surface.get_rect(center=(screen_width // 2, self.UI_PADDING + 20))
             screen.blit(score_surface, score_rect)
             
-            coin_surface = small_font.render(f'Coins: {self.coin_count}', True, (255, 255, 0))
-            coin_rect = coin_surface.get_rect(topleft=(UI_PADDING, UI_PADDING))
+            coin_surface = self.small_font.render(f'Coins: {self.coin_count}', True, (255, 255, 0))
+            coin_rect = coin_surface.get_rect(topleft=(self.UI_PADDING, self.UI_PADDING))
             screen.blit(coin_surface, coin_rect)
         
         elif self.game_state == 'game_over':
-            if game_over_image:
+            if game_over_image: # Global asset
                 game_over_rect = game_over_image.get_rect(center=(screen_width // 2, screen_height // 2 - 80))
                 screen.blit(game_over_image, game_over_rect)
 
-            score_surface = font.render(f'Score: {int(self.score)}', True, (255, 255, 255))
+            score_surface = self.font.render(f'Score: {int(self.score)}', True, (255, 255, 255))
             score_rect = score_surface.get_rect(center=(screen_width // 2, screen_height // 2))
             screen.blit(score_surface, score_rect)
 
-            high_score_surface = font.render(f'High Score: {int(self.high_score)}', True, (255, 255, 255))
-            high_score_rect = high_score_surface.get_rect(center=(screen_width // 2, screen_height // 2 + UI_SPACING))
+            high_score_surface = self.font.render(f'High Score: {int(self.high_score)}', True, (255, 255, 255))
+            high_score_rect = high_score_surface.get_rect(center=(screen_width // 2, screen_height // 2 + self.UI_SPACING))
             screen.blit(high_score_surface, high_score_rect)
 
-            restart_surface = font.render('Press R to Restart', True, (255, 255, 255))
-            restart_rect = restart_surface.get_rect(center=(screen_width // 2, screen_height // 2 + UI_SPACING * 2))
+            restart_surface = self.font.render('Press R to Restart', True, (255, 255, 255))
+            restart_rect = restart_surface.get_rect(center=(screen_width // 2, screen_height // 2 + self.UI_SPACING * 2))
             screen.blit(restart_surface, restart_rect)
 
-            back_to_select_surface = font.render('Press B for Bird Select', True, (255, 255, 255))
-            back_to_select_rect = back_to_select_surface.get_rect(center=(screen_width // 2, screen_height // 2 + UI_SPACING * 3))
+            back_to_select_surface = self.font.render('Press B for Bird Select', True, (255, 255, 255))
+            back_to_select_rect = back_to_select_surface.get_rect(center=(screen_width // 2, screen_height // 2 + self.UI_SPACING * 3))
             screen.blit(back_to_select_surface, back_to_select_rect)
         
         elif self.game_state == 'start_screen':
-            if message_image:
+            if message_image: # Global asset
                 message_rect = message_image.get_rect(center=(screen_width // 2, screen_height // 2 - 50))
                 screen.blit(message_image, message_rect)
             else:
-                start_surface = font.render('Press Space to Start', True, (255, 255, 255))
+                start_surface = self.font.render('Press Space to Start', True, (255, 255, 255))
                 start_rect = start_surface.get_rect(center=(screen_width // 2, screen_height // 2))
                 screen.blit(start_surface, start_rect)
 
-            high_score_display_surface = font.render(f'High Score: {int(self.high_score)}', True, (255, 255, 255))
-            high_score_display_rect = high_score_display_surface.get_rect(center=(screen_width // 2, screen_height // 2 + UI_SPACING))
+            high_score_display_surface = self.font.render(f'High Score: {int(self.high_score)}', True, (255, 255, 255))
+            high_score_display_rect = high_score_display_surface.get_rect(center=(screen_width // 2, screen_height // 2 + self.UI_SPACING))
             screen.blit(high_score_display_surface, high_score_display_rect)
         
         elif self.game_state == 'bird_select':
             overlay = pygame.Surface((screen_width, screen_height))
             overlay.fill((0, 0, 0))
-            overlay.set_alpha(128)
-            screen.blit(overlay, (0, 0))
+            overlay.set_alpha(128) 
+            screen.blit(overlay, (0,0))
 
-            title_surface = font.render('Select Bird', True, (255, 255, 0))
-            title_rect = title_surface.get_rect(center=(screen_width // 2, UI_PADDING + 20))
+            title_surface = self.font.render('Select Bird', True, (255, 255, 0)) 
+            title_rect = title_surface.get_rect(center=(screen_width // 2, self.UI_PADDING + 20))
             screen.blit(title_surface, title_rect)
 
-            y_offset = UI_PADDING + 80
+            y_offset = self.UI_PADDING + 80 
             available_birds = self.bird_manager.get_available_birds()
-            for i, bird_type in enumerate(available_birds):
-                box_height = 60
-                box_rect = pygame.Rect(UI_PADDING, y_offset + i * (box_height + 10) - (box_height // 2), screen_width - UI_PADDING * 2, box_height)
-                if bird_type == self.selected_bird_type:
-                    pygame.draw.rect(screen, (255, 255, 0), box_rect, 2)
+            for i, bird_type_iter in enumerate(available_birds):
+                box_height = 60 
+                box_rect = pygame.Rect(self.UI_PADDING, y_offset + i * (box_height + 10) - (box_height // 2) , screen_width - self.UI_PADDING*2, box_height)
+                if bird_type_iter == self.selected_bird_type:
+                    pygame.draw.rect(screen, (255,255,0), box_rect, 2) 
                 else:
-                    pygame.draw.rect(screen, (255, 255, 255), box_rect, 1)
-
-                text_y_name = y_offset + i * (box_height + 10) - 10
-                text_y_desc = y_offset + i * (box_height + 10) + 10
-
-                if self.bird_manager.is_bird_unlocked(bird_type):
-                    bird_text = f"{bird_type.capitalize()} Bird"
-                    if bird_type == self.selected_bird_type:
-                        bird_text += " ✓"
-                    bird_surface = small_font.render(bird_text, True, (255, 255, 255))
+                    pygame.draw.rect(screen, (255,255,255), box_rect, 1) 
+                
+                text_y_name = y_offset + i * (box_height + 10) -10
+                text_y_desc = y_offset + i * (box_height + 10) +10
+
+                if self.bird_manager.is_bird_unlocked(bird_type_iter):
+                    bird_text = f"{bird_type_iter.capitalize()} Bird"
+                    if bird_type_iter == self.selected_bird_type:
+                        bird_text += " ✓" 
+                    bird_surface = self.small_font.render(bird_text, True, (255, 255, 255))
                     bird_rect = bird_surface.get_rect(center=(screen_width // 2, text_y_name))
                     screen.blit(bird_surface, bird_rect)
 
-                    achievement_info = self.bird_manager.get_bird_achievement_info(bird_type)
+                    achievement_info = self.bird_manager.get_bird_achievement_info(bird_type_iter)
                     if achievement_info and 'description' in achievement_info:
-                        desc_surface = small_font.render(achievement_info['description'], True, (180, 180, 180))
+                        desc_surface = self.small_font.render(achievement_info['description'], True, (180, 180, 180)) 
                         desc_rect = desc_surface.get_rect(center=(screen_width // 2, text_y_desc))
                         screen.blit(desc_surface, desc_rect)
-                else:
-                    achievement = self.bird_manager.get_bird_achievement_info(bird_type)
+                else: 
+                    achievement = self.bird_manager.get_bird_achievement_info(bird_type_iter)
                     if achievement:
                         lock_text = f"Locked: {achievement['description']}"
-                        lock_surface = small_font.render(lock_text, True, (128, 128, 128))
+                        lock_surface = self.small_font.render(lock_text, True, (128,128,128)) 
                         lock_rect = lock_surface.get_rect(center=(screen_width // 2, text_y_name))
                         screen.blit(lock_surface, lock_rect)
 
-            preview_bird = Bird(self.selected_bird_type)
+            preview_bird = Bird(self.selected_bird_type) 
             preview_bird.rect.center = (screen_width // 2, screen_height - 100)
-            preview_bird.draw(screen)
+            preview_bird.draw(screen) 
 
-            nav_surface = small_font.render('↑↓ to select, Space to choose', True, (200, 200, 200))
-            nav_rect = nav_surface.get_rect(center=(screen_width // 2, screen_height - UI_PADDING - 30))
+            nav_surface = self.small_font.render('↑↓ to select, Space to choose', True, (200, 200, 200))
+            nav_rect = nav_surface.get_rect(center=(screen_width // 2, screen_height - self.UI_PADDING - 30))
             screen.blit(nav_surface, nav_rect)
 
-            select_surface = small_font.render('Click to Play', True, (255, 255, 255))
-            select_rect = select_surface.get_rect(center=(screen_width // 2, screen_height - UI_PADDING))
+            select_surface = self.small_font.render('Click to Play', True, (255, 255, 255))
+            select_rect = select_surface.get_rect(center=(screen_width // 2, screen_height - self.UI_PADDING))
             screen.blit(select_surface, select_rect)
 
     def reset_game(self):
         if self.score > self.high_score:
             self.high_score = self.score
-            self.save_high_score()
+            self._save_high_score_internal() # Use internal method
             self.bird_manager.update_score(self.selected_bird_type, self.score)
         
         self.score = 0
@@ -594,27 +487,99 @@ def reset_game(self):
         self.coins.empty()
         self.all_sprites.empty()
         self.all_sprites.add(self.bird)
-        self.game_state = 'game_active'
-        self.create_pipe_pair()
+        # self.game_state = 'game_active' # This will be set in _start_game_session
+        # self.create_pipe_pair() # This will be called in _start_game_session
         
-        if 'pygame' in sys.modules and hasattr(pygame.mixer, 'music'):
+        # Start music if needed, will be handled in _start_game_session
+        # if 'pygame' in sys.modules and hasattr(pygame.mixer, 'music'):
+        #     pygame.mixer.music.play(-1)
+
+    def _start_game_session(self):
+        """Initializes and starts a new game session."""
+        self.game_state = 'game_active'
+        sound_swoosh.play()
+
+        if 'pygame' in sys.modules and hasattr(pygame.mixer, 'music') and not pygame.mixer.music.get_busy():
             pygame.mixer.music.play(-1)
 
+        self.score = 0
+        self.coin_count = 0
+        self.pipes_passed_count = 0
+        self.pipe_move_speed = 2.0  # Initial pipe move speed
+        self.pipe_spawn_interval = 1800 # Initial pipe spawn interval
+        pygame.time.set_timer(self.PIPE_SPAWN_EVENT, self.pipe_spawn_interval) # Use self.PIPE_SPAWN_EVENT
+
+        self.pipes.empty()
+        self.coins.empty()
+        
+        self.bird = Bird(self.selected_bird_type)
+        self.bird.rect.center = (50, screen_height // 2)
+        self.bird.velocity = 0
+        
+        self.all_sprites.empty()
+        self.all_sprites.add(self.bird)
+        
+        self.create_pipe_pair()
+
+    def _draw_screen(self):
+        """Handles all drawing operations for the current game state."""
+
+        if self.critical_asset_error:
+            screen.fill((50, 0, 0)) # Dark red screen for critical error
+            error_surface = self.font.render(self.error_message_text, True, (255, 255, 255))
+            error_rect = error_surface.get_rect(center=(screen_width // 2, screen_height // 2))
+            screen.blit(error_surface, error_rect)
+            # Additional instructions for the user could be added here
+            instructions_surface = self.small_font.render("Please check console for details or reinstall.", True, (200, 200, 200))
+            instructions_rect = instructions_surface.get_rect(center=(screen_width // 2, screen_height // 2 + 40))
+            screen.blit(instructions_surface, instructions_rect)
+            return # Skip other drawing if critical error
+
+        # Draw background
+        if background_image: # Global asset
+            self.background_x -= self.background_scroll_speed
+            if self.background_x <= -screen_width:
+                self.background_x = 0
+            screen.blit(background_image, (self.background_x, 0))
+            screen.blit(background_image, (self.background_x + screen_width, 0))
+        elif self.game_state == 'game_over': # Specific background for game_over if no image
+            screen.fill((0, 0, 0)) # Black screen
+        else:
+            screen.fill((135, 206, 235)) # Default sky color for other states
+
+        # Draw game-specific sprites based on state
+        if self.game_state == 'game_active':
+            self.all_sprites.draw(screen)
+        elif self.game_state == 'start_screen':
+            if hasattr(self, 'bird'): # Ensure bird exists (it's created in __init__)
+                self.bird.draw(screen) # Draw the main bird
+        # Note: 'bird_select' preview bird is handled within display_score.
+        # 'game_over' doesn't typically draw active game sprites beyond what display_score might show.
+
+        # Draw UI elements (scores, messages, etc.) on top
+        self.display_score()
+
     def create_pipe_pair(self):
-        min_y = 100
-        max_y = screen_height - 100 - pipe_gap_size
+        # min_y and max_y define the vertical range for the center of the pipe gap.
+        # The padding of 100 ensures the gap isn't too close to the screen edges.
+        min_y = 100 
+        max_y = screen_height - 100 - self.pipe_gap_size # Use self.pipe_gap_size
+
+        # If the valid range for the gap center is invalid (e.g., due to extreme pipe_gap_size or small screen_height),
+        # default to placing the gap in the middle of the screen.
         if min_y >= max_y:
             pipe_gap_center_y = screen_height // 2
         else:
             pipe_gap_center_y = random.randint(min_y, max_y)
 
-        if pipe_image:
+        if pipe_image: # Global asset
             current_pipe_width = pipe_image.get_width()
         else:
             current_pipe_width = 52
 
-        top_pipe = Pipe(screen_width, pipe_gap_center_y, 1, inverted=True)
-        bottom_pipe = Pipe(screen_width, pipe_gap_center_y, -1)
+        # Pass self.pipe_gap_size to the Pipe constructor
+        top_pipe = Pipe(screen_width, pipe_gap_center_y, 1, inverted=True, pipe_gap_size=self.pipe_gap_size)
+        bottom_pipe = Pipe(screen_width, pipe_gap_center_y, -1, pipe_gap_size=self.pipe_gap_size)
         self.pipes.add(top_pipe)
         self.pipes.add(bottom_pipe)
         self.all_sprites.add(top_pipe)
@@ -629,7 +594,8 @@ def create_pipe_pair(self):
 
     def run(self):
         running = True
-        pygame.time.set_timer(PIPE_SPAWN_EVENT, self.pipe_spawn_interval)
+        # Use self.PIPE_SPAWN_EVENT and self.pipe_spawn_interval
+        pygame.time.set_timer(self.PIPE_SPAWN_EVENT, self.pipe_spawn_interval)
 
         while running:
             for event in pygame.event.get():
@@ -640,25 +606,12 @@ def run(self):
                         if self.game_state == 'start_screen':
                             self.game_state = 'bird_select'
                         elif self.game_state == 'bird_select':
-                            self.game_state = 'game_active'
-                            sound_swoosh.play()
-                            if 'pygame' in sys.modules and hasattr(pygame.mixer, 'music') and not pygame.mixer.music.get_busy():
-                                pygame.mixer.music.play(-1)
-                            self.score = 0
-                            self.coin_count = 0
-                            self.pipes.empty()
-                            self.coins.empty()
-                            self.bird = Bird(self.selected_bird_type)
-                            self.bird.rect.center = (50, screen_height // 2)
-                            self.bird.velocity = 0
-                            self.all_sprites.empty()
-                            self.all_sprites.add(self.bird)
-                            self.create_pipe_pair()
+                            self._start_game_session() 
                         elif self.game_state == 'game_active':
                             self.bird.flap(self.game_state)
                     elif event.key == pygame.K_r and self.game_state == 'game_over':
                         self.reset_game()
-                        sound_swoosh.play()
+                        # sound_swoosh is played in _start_game_session via reset_game
                     elif event.key == pygame.K_b and self.game_state == 'game_over':
                         self.game_state = 'bird_select'
                         self.bird = Bird(self.selected_bird_type)
@@ -677,32 +630,20 @@ def run(self):
                          self.game_state = 'bird_select'
                     elif self.game_state == 'bird_select':
                         mouse_pos = pygame.mouse.get_pos()
-                        y_offset_start = UI_PADDING + 80
+                        y_offset_start = self.UI_PADDING + 80 # Use self.UI_PADDING
                         box_height = 60
                         available_birds = self.bird_manager.get_available_birds()
-                        for i, bird_type in enumerate(available_birds):
+                        for i, bird_type_iter in enumerate(available_birds):
                             box_y_start = y_offset_start + i * (box_height + 10) - (box_height // 2)
                             box_y_end = box_y_start + box_height
-                            if self.bird_manager.is_bird_unlocked(bird_type):
-                                if box_y_start <= mouse_pos[1] <= box_y_end:
-                                    self.selected_bird_type = bird_type
-                                    self.game_state = 'game_active'
-                                    sound_swoosh.play()
-                                    if 'pygame' in sys.modules and hasattr(pygame.mixer, 'music') and not pygame.mixer.music.get_busy():
-                                        pygame.mixer.music.play(-1)
-                                    self.score = 0
-                                    self.coin_count = 0
-                                    self.pipes.empty()
-                                    self.coins.empty()
-                                    self.bird = Bird(self.selected_bird_type)
-                                    self.bird.rect.center = (50, screen_height // 2)
-                                    self.bird.velocity = 0
-                                    self.all_sprites.empty()
-                                    self.all_sprites.add(self.bird)
-                                    self.create_pipe_pair()
+                            if self.UI_PADDING <= mouse_pos[0] <= screen_width - self.UI_PADDING and \
+                               box_y_start <= mouse_pos[1] <= box_y_end: # Use self.UI_PADDING
+                                if self.bird_manager.is_bird_unlocked(bird_type_iter):
+                                    self.selected_bird_type = bird_type_iter
+                                    self._start_game_session() 
                                     break
 
-                if event.type == PIPE_SPAWN_EVENT and self.game_state == 'game_active':
+                if event.type == self.PIPE_SPAWN_EVENT and self.game_state == 'game_active': # Use self.PIPE_SPAWN_EVENT
                     self.create_pipe_pair()
 
             if self.game_state == 'game_active':
@@ -723,21 +664,21 @@ def run(self):
                         pygame.mixer.music.stop()
                     if self.score > self.high_score:
                         self.high_score = self.score
-                        self.save_high_score()
+                        self._save_high_score_internal() # Use internal method
                         self.bird_manager.update_score(self.selected_bird_type, self.score)
 
-                for pipe in self.pipes:
-                    if not pipe.passed and pipe.rect.right < self.bird.rect.left:
-                        pipe.passed = True
-                        if pipe.pipe_type == -1:
+                for pipe_obj in self.pipes: # Renamed pipe to pipe_obj
+                    if not pipe_obj.passed and pipe_obj.rect.right < self.bird.rect.left:
+                        pipe_obj.passed = True
+                        if pipe_obj.pipe_type == -1:
                             self.score += 1
                             self.pipes_passed_count += 1
                             if self.pipes_passed_count > 0 and self.pipes_passed_count % 20 == 0:
-                                self.pipe_move_speed *= 1.05
-                                print(f"Pipe speed increased to: {self.pipe_move_speed}")
+                                self.pipe_move_speed *= 1.05 
+                                # print(f"Pipe speed increased to: {self.pipe_move_speed}") # Debug print removed
 
-                if background_image:
-                    self.background_x -= background_scroll_speed
+                if background_image: # Global asset
+                    self.background_x -= self.background_scroll_speed # Use self.background_scroll_speed
                     if self.background_x <= -screen_width:
                         self.background_x = 0
                     screen.blit(background_image, (self.background_x, 0))
@@ -745,45 +686,23 @@ def run(self):
                 else:
                     screen.fill((135, 206, 235))
 
-                self.all_sprites.draw(screen)
-                self.display_score()
+                # Drawing is now handled by _draw_screen
+                pass
 
             elif self.game_state == 'game_over':
-                screen.fill((0, 0, 0))
-                self.pipes.update(self.pipe_move_speed)
-                self.coins.update(self.pipe_move_speed)
-                self.display_score()
+                # Drawing is now handled by _draw_screen
+                pass
             
             elif self.game_state == 'start_screen':
-                if background_image:
-                    self.background_x -= background_scroll_speed
-                    if self.background_x <= -screen_width:
-                        self.background_x = 0
-                    screen.blit(background_image, (self.background_x, 0))
-                    screen.blit(background_image, (self.background_x + screen_width, 0))
-                else:
-                    screen.fill((135, 206, 235))
-                
-                if hasattr(self, 'bird'):
-                    self.bird.draw(screen)
-                self.display_score()
+                # Drawing is now handled by _draw_screen
+                pass
 
             elif self.game_state == 'bird_select':
-                if background_image:
-                    self.background_x -= background_scroll_speed
-                    if self.background_x <= -screen_width:
-                        self.background_x = 0
-                    screen.blit(background_image, (self.background_x, 0))
-                    screen.blit(background_image, (self.background_x + screen_width, 0))
-                else:
-                    screen.fill((135, 206, 235))
-                
-                self.display_score()
-
-                preview_bird = Bird(self.selected_bird_type)
-                preview_bird.rect.center = (screen_width // 2, screen_height - 100)
-                preview_bird.draw(screen)
-
+                # Drawing is now handled by _draw_screen
+                pass
+            
+            # Centralized drawing call
+            self._draw_screen() 
             pygame.display.flip()
             clock.tick(60)
 
diff --git a/test_bird_manager.py b/test_bird_manager.py
new file mode 100644
index 0000000..82d67db
--- /dev/null
+++ b/test_bird_manager.py
@@ -0,0 +1,208 @@
+import unittest
+import os
+import json
+from bird_manager import BirdManager
+
+class TestBirdManager(unittest.TestCase):
+
+    def setUp(self):
+        """Set up for test methods."""
+        # Ensure a clean state for tests that might create the progress file
+        self.progress_file = 'bird_progress.json'
+        if os.path.exists(self.progress_file):
+            os.remove(self.progress_file)
+        self.bird_manager = BirdManager()
+
+    def tearDown(self):
+        """Tear down after test methods."""
+        # Clean up the progress file if it was created by a test
+        if os.path.exists(self.progress_file):
+            os.remove(self.progress_file)
+
+    def test_initialization_unlocked_birds(self):
+        """Test initial state of unlocked_birds."""
+        expected_unlocked = {'blue': True, 'red': False, 'yellow': False}
+        self.assertEqual(self.bird_manager.unlocked_birds, expected_unlocked)
+
+    def test_initialization_high_scores(self):
+        """Test initial state of high_scores."""
+        expected_scores = {'red': 0, 'yellow': 0, 'blue': 0, 'default': 0}
+        self.assertEqual(self.bird_manager.high_scores, expected_scores)
+
+    def test_initialization_achievements(self):
+        """Test that achievements are populated."""
+        self.assertTrue(self.bird_manager.achievements)
+        self.assertIn('red', self.bird_manager.achievements)
+        self.assertIn('yellow', self.bird_manager.achievements)
+        self.assertIn('blue', self.bird_manager.achievements)
+        self.assertEqual(self.bird_manager.achievements['blue']['name'], 'Graceful Glider')
+
+    def test_get_available_birds(self):
+        """Test get_available_birds method."""
+        expected_birds = ['red', 'yellow', 'blue'] # Order matters if it's based on dict keys pre Python 3.7
+        # Sorting to make the test order-independent for dict keys
+        self.assertEqual(sorted(self.bird_manager.get_available_birds()), sorted(expected_birds))
+
+    def test_get_bird_achievement_info_valid(self):
+        """Test get_bird_achievement_info for a valid bird type."""
+        info = self.bird_manager.get_bird_achievement_info('red')
+        self.assertIsNotNone(info)
+        self.assertEqual(info['name'], 'Speed Demon')
+
+    def test_get_bird_achievement_info_invalid(self):
+        """Test get_bird_achievement_info for an invalid bird type."""
+        info = self.bird_manager.get_bird_achievement_info('green')
+        self.assertIsNone(info)
+
+    def test_is_bird_unlocked_initial(self):
+        """Test is_bird_unlocked for initially locked and unlocked birds."""
+        self.assertTrue(self.bird_manager.is_bird_unlocked('blue'))
+        self.assertFalse(self.bird_manager.is_bird_unlocked('red'))
+        self.assertFalse(self.bird_manager.is_bird_unlocked('yellow'))
+        self.assertFalse(self.bird_manager.is_bird_unlocked('unknown_bird'))
+
+    def test_load_progress_non_existent_file(self):
+        """Test loading progress when the file does not exist."""
+        # setUp already ensures the file doesn't exist initially
+        # Re-instantiate to trigger load_progress in a controlled way for this test
+        if os.path.exists(self.progress_file): # Should not exist, but defensive
+            os.remove(self.progress_file)
+        
+        manager = BirdManager() # load_progress is called in __init__
+        
+        expected_unlocked = {'blue': True, 'red': False, 'yellow': False}
+        expected_scores = {'red': 0, 'yellow': 0, 'blue': 0, 'default': 0}
+        self.assertEqual(manager.unlocked_birds, expected_unlocked)
+        self.assertEqual(manager.high_scores, expected_scores)
+
+    def test_load_progress_valid_data(self):
+        """Test loading progress from a valid JSON file."""
+        valid_data = {
+            'unlocked_birds': {'blue': True, 'red': True, 'yellow': False},
+            'high_scores': {'blue': 10, 'red': 55, 'yellow': 5, 'default': 0}
+        }
+        with open(self.progress_file, 'w') as f:
+            json.dump(valid_data, f)
+        
+        manager = BirdManager() # load_progress is called in __init__
+        
+        self.assertEqual(manager.unlocked_birds, valid_data['unlocked_birds'])
+        self.assertEqual(manager.high_scores, valid_data['high_scores'])
+
+    def test_load_progress_corrupted_json(self):
+        """Test loading progress from a corrupted JSON file."""
+        with open(self.progress_file, 'w') as f:
+            f.write("{'unlocked_birds': {'blue': True, 'red': True") # Invalid JSON
+        
+        # Suppress print output during this test if desired, or check for it
+        manager = BirdManager()
+        
+        # Should revert to defaults
+        expected_unlocked = {'blue': True, 'red': False, 'yellow': False}
+        expected_scores = {'red': 0, 'yellow': 0, 'blue': 0, 'default': 0}
+        self.assertEqual(manager.unlocked_birds, expected_unlocked)
+        self.assertEqual(manager.high_scores, expected_scores)
+
+    def test_load_progress_missing_keys(self):
+        """Test loading progress from JSON with missing keys."""
+        # Case 1: missing 'unlocked_birds'
+        data_missing_unlocked = {
+            'high_scores': {'blue': 15, 'red': 2, 'yellow': 1, 'default': 0}
+        }
+        with open(self.progress_file, 'w') as f:
+            json.dump(data_missing_unlocked, f)
+        
+        manager1 = BirdManager()
+        expected_unlocked_default = {'blue': True, 'red': False, 'yellow': False}
+        self.assertEqual(manager1.unlocked_birds, expected_unlocked_default, "Unlocked birds should default")
+        self.assertEqual(manager1.high_scores, data_missing_unlocked['high_scores'], "High scores should load")
+
+        # Clean up for next sub-test
+        if os.path.exists(self.progress_file):
+            os.remove(self.progress_file)
+
+        # Case 2: missing 'high_scores'
+        data_missing_scores = {
+            'unlocked_birds': {'blue': True, 'red': True, 'yellow': False}
+        }
+        with open(self.progress_file, 'w') as f:
+            json.dump(data_missing_scores, f)
+
+        manager2 = BirdManager()
+        expected_scores_default = {'red': 0, 'yellow': 0, 'blue': 0, 'default': 0}
+        self.assertEqual(manager2.unlocked_birds, data_missing_scores['unlocked_birds'], "Unlocked birds should load")
+        self.assertEqual(manager2.high_scores, expected_scores_default, "High scores should default")
+
+    def test_save_progress(self):
+        """Test saving progress correctly writes to file."""
+        self.bird_manager.unlocked_birds['red'] = True
+        self.bird_manager.high_scores['red'] = 70
+        self.bird_manager.high_scores['blue'] = 20
+        
+        self.bird_manager.save_progress()
+        
+        self.assertTrue(os.path.exists(self.progress_file))
+        with open(self.progress_file, 'r') as f:
+            saved_data = json.load(f)
+        
+        self.assertEqual(saved_data['unlocked_birds'], self.bird_manager.unlocked_birds)
+        self.assertEqual(saved_data['high_scores'], self.bird_manager.high_scores)
+
+    def test_update_score_new_high_score_and_unlock(self):
+        """Test update_score with a new high score that also unlocks a bird."""
+        self.assertFalse(self.bird_manager.is_bird_unlocked('red')) # Initially locked
+        self.bird_manager.update_score('red', 55) # Requirement for red is 50
+        
+        self.assertEqual(self.bird_manager.high_scores['red'], 55)
+        self.assertTrue(self.bird_manager.is_bird_unlocked('red'))
+        
+        # Check if progress was saved (bird unlocked)
+        manager_new_instance = BirdManager() # loads from file
+        self.assertTrue(manager_new_instance.is_bird_unlocked('red'))
+        self.assertEqual(manager_new_instance.high_scores['red'], 55)
+
+
+    def test_update_score_lower_score(self):
+        """Test update_score with a score lower than current high score."""
+        self.bird_manager.high_scores['blue'] = 10
+        self.bird_manager.update_score('blue', 5) # Current high score is 10
+        
+        self.assertEqual(self.bird_manager.high_scores['blue'], 10) # Should not change
+
+    def test_update_score_no_unlock(self):
+        """Test update_score that sets a new high score but doesn't unlock."""
+        self.assertFalse(self.bird_manager.is_bird_unlocked('yellow')) # Initially locked
+        self.bird_manager.update_score('yellow', 25) # Requirement for yellow is 30
+        
+        self.assertEqual(self.bird_manager.high_scores['yellow'], 25)
+        self.assertFalse(self.bird_manager.is_bird_unlocked('yellow'))
+
+    def test_check_achievements_unlocks_bird(self):
+        """Test check_achievements directly (though usually called by update_score)."""
+        self.assertFalse(self.bird_manager.is_bird_unlocked('yellow'))
+        # Manually set score high enough and call check_achievements
+        self.bird_manager.high_scores['yellow'] = 35 
+        self.bird_manager.check_achievements('yellow', 35) # Requirement for yellow is 30
+        
+        self.assertTrue(self.bird_manager.is_bird_unlocked('yellow'))
+        
+        # Verify save
+        manager_new_instance = BirdManager()
+        self.assertTrue(manager_new_instance.is_bird_unlocked('yellow'))
+
+    def test_check_achievements_already_unlocked(self):
+        """Test check_achievements for an already unlocked bird."""
+        # Unlock 'red' first
+        self.bird_manager.update_score('red', 50)
+        self.assertTrue(self.bird_manager.is_bird_unlocked('red'))
+        
+        # Call check_achievements again with a higher score
+        self.bird_manager.high_scores['red'] = 60
+        self.bird_manager.check_achievements('red', 60)
+        
+        # Should still be unlocked, no error, and progress should reflect the unlock
+        self.assertTrue(self.bird_manager.is_bird_unlocked('red'))
+
+
+if __name__ == '__main__':
+    unittest.main()