Fix(clippy): Resolve compiler errors and clippy warnings

- Fix E0412: Define VolumeSliderInteractionQuery in audio.rs

- Fix E0277: Correct system configuration in settings plugin

- Fix clippy::unused_unit in tests/common.rs

- Fix clippy::collapsible_if in mtgjson/mod.rs

- Fix clippy::collapsible_else_if in save/load.rs and visual_testing/examples.rs

- Refactor save/load.rs to use apply_game_state util

- Fix pattern matching errors in save/utils.rs

- Address various import errors and unused imports

Author: tyler274

src/cards/mtgjson/mod.rs

@@ -19,6 +19,7 @@ use crate::cards::{
 use crate::mana::{Mana, ManaColor};
 use async_trait::async_trait;
 use lazy_static::lazy_static;
+use log::info;
 use regex;
 use reqwest;
 use serde::{Deserialize, Serialize};
@@ -438,7 +439,6 @@ impl MTGService {
     }
 
     /// Gets the path for set version information
-
     fn get_set_version_path(&self, set_code: &str) -> std::path::PathBuf {
         std::path::PathBuf::from("sets").join(format!("{}.json.bz2.version", set_code))
     }
@@ -447,7 +447,6 @@ impl MTGService {
     ///
     /// This includes the current version number and update date.
     /// Results are cached to avoid unnecessary API calls.
-
     pub async fn fetch_meta(&self) -> Result<MTGJSONMeta, Error> {
         let mut meta = self.meta.lock().await;
         if meta.is_some() {
@@ -472,7 +471,6 @@ impl MTGService {
     ///
     /// Checks both the version and checksum of the file against
     /// the current MTGJSON version.
-
     pub async fn verify_file_checksum(&self, set_code: &str, path: &Path) -> Result<bool, Error> {
         // First check if we have a version file and if it matches current version
         let version_path = self.get_set_version_path(set_code);
@@ -550,30 +548,35 @@ impl MTGService {
         }
         drop(memory_cache);
 
-        // Check if we have a cached version and its checksum is valid
+        // Check if set archive already exists and is valid
         let set_archive_path = self.get_set_archive_path(set_code);
-        if set_archive_path.exists() {
-            if self
+
+        if set_archive_path.exists()
+            && self
                 .verify_file_checksum(set_code, &set_archive_path)
                 .await?
-            {
-                let compressed_data = fs::read(&set_archive_path)?;
-                let decompressed = bzip2::read::BzDecoder::new(&compressed_data[..]);
-                let set: MTGJSONSetResponse = serde_json::from_reader(decompressed)?;
-                let cards: Vec<Card> = set
-                    .data
-                    .cards
-                    .into_iter()
-                    .filter_map(convert_mtgjson_to_card)
-                    .map(|(card, _, _, _, _, _, _)| card)
-                    .collect();
-
-                // Update memory cache
-                let mut memory_cache = self.cache.lock().await;
-                memory_cache.insert(set_code.to_string(), cards.clone());
-
-                return Ok(cards);
-            }
+        {
+            // Load from existing archive
+            info!(
+                "Loading set data for {} from existing archive: {:?}",
+                set_code, set_archive_path
+            );
+            let compressed_data = fs::read(&set_archive_path)?;
+            let decompressed = bzip2::read::BzDecoder::new(&compressed_data[..]);
+            let set: MTGJSONSetResponse = serde_json::from_reader(decompressed)?;
+            let cards: Vec<Card> = set
+                .data
+                .cards
+                .into_iter()
+                .filter_map(convert_mtgjson_to_card)
+                .map(|(card, _, _, _, _, _, _)| card)
+                .collect();
+
+            // Update memory cache
+            let mut memory_cache = self.cache.lock().await;
+            memory_cache.insert(set_code.to_string(), cards.clone());
+
+            return Ok(cards);
         }
 
         // Get the set data from the client

src/game_engine/card/render/cost.rs

@@ -0,0 +1,30 @@
+use bevy::prelude::*;
+
+/// Converts a mana symbol string (e.g., "{W}") to its corresponding color.
+pub fn symbol_to_color(mana_symbol: &str) -> Color {
+    let clean_symbol = mana_symbol.trim();
+    match clean_symbol {
+        "{W}" => Color::srgb(0.95, 0.95, 0.85), // White mana (off-white)
+        "{U}" => Color::srgb(0.0, 0.4, 0.8),    // Blue mana - more vibrant
+        "{B}" => Color::srgb(0.0, 0.0, 0.0),    // Black mana - true black
+        "{R}" => Color::srgb(0.9, 0.1, 0.1),    // Red mana - more vivid red
+        "{G}" => Color::srgb(0.0, 0.6, 0.0),    // Green mana - brighter green
+        "{C}" => Color::srgb(0.7, 0.7, 0.8),    // Colorless mana - slight blue tint
+        _ => {
+            // Generic/numeric mana or other symbols
+            if clean_symbol.starts_with('{') && clean_symbol.ends_with('}') {
+                let inner = &clean_symbol[1..clean_symbol.len() - 1];
+                if inner.parse::<u32>().is_ok() || inner == "X" {
+                    // Generic mana is light gray with a slight brown tint
+                    Color::srgb(0.75, 0.73, 0.71)
+                } else {
+                    // Other symbols like tap
+                    Color::srgb(0.3, 0.3, 0.3)
+                }
+            } else {
+                // Default to black for other text
+                Color::srgb(0.0, 0.0, 0.0)
+            }
+        }
+    }
+}

src/game_engine/save/systems/load.rs

@@ -1,10 +1,9 @@
 use bevy::prelude::*;
 use bevy_persistent::prelude::*;
-use std::collections::{HashMap, VecDeque};
 
 use crate::game_engine::commander::CommandZoneManager;
-use crate::game_engine::save::data::*;
-use crate::game_engine::save::events::*;
+use crate::game_engine::save::data::GameSaveData;
+use crate::game_engine::save::events::LoadGameEvent;
 use crate::game_engine::save::resources::*;
 use crate::game_engine::state::GameState;
 use crate::game_engine::zones::ZoneManager;
@@ -44,115 +43,17 @@ pub fn handle_load_game(
 
         match persistent_save {
             Ok(save) => {
-                // Get the loaded data
                 let save_data = save.clone();
 
-                // Rebuild entity mapping
-                let mut index_to_entity = Vec::new();
-                let mut existing_player_entities = HashMap::new();
-
-                // Map existing players if possible
-                for (entity, player) in query_players.iter() {
-                    for saved_player in &save_data.players {
-                        if player.name == saved_player.name {
-                            existing_player_entities.insert(saved_player.id, entity);
-                            break;
-                        }
-                    }
-                }
-
-                // Recreate player entities
-                for player_data in &save_data.players {
-                    if let Some(&entity) = existing_player_entities.get(&player_data.id) {
-                        index_to_entity.push(entity);
-
-                        // Update existing player data
-                        if let Ok((_, mut player)) = query_players.get_mut(entity) {
-                            player.life = player_data.life;
-                            player.mana_pool = player_data.mana_pool.clone();
-                        }
-                    } else {
-                        // Create new player entity
-                        let player_entity = commands
-                            .spawn((Player {
-                                name: player_data.name.clone(),
-                                life: player_data.life,
-                                mana_pool: player_data.mana_pool.clone(),
-                                ..Default::default()
-                            },))
-                            .id();
-
-                        index_to_entity.push(player_entity);
-                    }
-                }
-
-                // Handle empty player list case gracefully
-                if save_data.players.is_empty() {
-                    debug!("Loading a save with no players");
-                    // Add a placeholder to index_to_entity for GameState to reference safely
-                    if index_to_entity.is_empty() {
-                        index_to_entity.push(Entity::PLACEHOLDER);
-                    }
-                }
-
-                // Restore game state - always attempt to restore basic properties even with empty players
-                if let Some(game_state) = &mut game_state {
-                    // If there's a corrupted mapping, fall back to basic properties
-                    if index_to_entity.is_empty() || index_to_entity.contains(&Entity::PLACEHOLDER)
-                    {
-                        // Always restore turn number first
-                        game_state.turn_number = save_data.game_state.turn_number;
-
-                        // Handle empty turn order case
-                        if save_data.game_state.turn_order_indices.is_empty() {
-                            debug!("Empty turn order detected, keeping turn order unchanged");
-                            // Keep the existing turn order
-                        } else {
-                            // Create a fallback turn order based on indices
-                            let mut turn_order = VecDeque::new();
-                            for &idx in &save_data.game_state.turn_order_indices {
-                                turn_order.push_back(Entity::from_raw(idx as u32));
-                            }
-                            game_state.turn_order = turn_order;
-                        }
-                    } else {
-                        // Full restore with valid player entities
-                        **game_state = save_data.to_game_state(&index_to_entity);
-                    }
-                } else {
-                    if !index_to_entity.is_empty() {
-                        commands.insert_resource(save_data.to_game_state(&index_to_entity));
-                    } else {
-                        // Even with empty index, we should still restore basic properties
-                        let mut default_state = GameState::default();
-
-                        // Only update turn number if turn order is not empty
-                        if !save_data.game_state.turn_order_indices.is_empty() {
-                            default_state.turn_number = save_data.game_state.turn_number;
-                        } else {
-                            debug!(
-                                "Empty turn order detected when creating default state, keeping turn number unchanged"
-                            );
-                        }
-
-                        commands.insert_resource(default_state);
-                        warn!(
-                            "No player entities found when loading game, using modified default state"
-                        );
-                    }
-                }
-
-                // Restore zone contents
-                if let Some(zone_manager) = &mut zones {
-                    // Use the GameSaveData method to restore ZoneManager
-                    **zone_manager = save_data.to_zone_manager(&index_to_entity);
-                }
-
-                // Restore commander zone contents
-                if let Some(commander_manager) = &mut commanders {
-                    // Use the GameSaveData method to restore CommandZoneManager
-                    **commander_manager = save_data.to_commander_manager(&index_to_entity);
-                }
+                // Apply the loaded state using the fully qualified path
+                crate::game_engine::save::systems::utils::apply_game_state(
+                    &save_data,
+                    &mut game_state,
+                    &mut commands,
+                    &mut query_players,
+                    &mut zones,
+                    &mut commanders,
+                );
 
                 info!("Game loaded successfully from slot {}", event.slot_name);
             }

src/game_engine/save/systems/utils.rs

@@ -63,23 +63,22 @@ pub fn apply_game_state(
     }
 
     // Restore game state
-    if let Some(game_state) = game_state {
+    if let Some(gs) = game_state {
         if index_to_entity.is_empty() || index_to_entity.contains(&Entity::PLACEHOLDER) {
             // At minimum, restore basic properties not tied to player entities
-            game_state.turn_number = save_data.game_state.turn_number;
+            gs.turn_number = save_data.game_state.turn_number;
         } else {
             // Full restore with valid player entities
-            **game_state = save_data.to_game_state(&index_to_entity);
+            **gs = save_data.to_game_state(&index_to_entity);
         }
+    } else if index_to_entity.is_empty() || index_to_entity.contains(&Entity::PLACEHOLDER) {
+        // Create a new game state with basic properties if mapping failed or is empty
+        let mut new_state = GameState::default();
+        new_state.turn_number = save_data.game_state.turn_number;
+        commands.insert_resource(new_state);
     } else {
-        if index_to_entity.is_empty() || index_to_entity.contains(&Entity::PLACEHOLDER) {
-            // Create a new game state with basic properties
-            let mut new_state = GameState::default();
-            new_state.turn_number = save_data.game_state.turn_number;
-            commands.insert_resource(new_state);
-        } else {
-            commands.insert_resource(save_data.to_game_state(&index_to_entity));
-        }
+        // Create a new game state from save data
+        commands.insert_resource(save_data.to_game_state(&index_to_entity));
     }
 
     // Restore zone contents if a valid ZoneManager exists and we have player entities

src/game_engine/tests/assertions.rs

@@ -1,13 +1,13 @@
+// use crate::game_engine::state::Zone;
 use bevy::prelude::*;
 
 /// Game state assertions for testing
-
 /// Asserts that an entity is in a specific zone
 #[allow(dead_code)]
 pub fn assert_in_zone(
     _app: &App,
     _entity: Entity,
-    _zone_type: crate::game_engine::zones::Zone,
+    _zone_type: crate::game_engine::zones::types::Zone,
     _owner: Option<Entity>,
 ) {
     // Placeholder implementation

src/game_engine/tests/common.rs

@@ -5,7 +5,7 @@ use bevy::prelude::*;
 
 /// Setup test logger
 #[allow(dead_code)]
-pub fn setup_test_logger() -> () {
+pub fn setup_test_logger() {
     // Placeholder for test logger setup
     // Usually sets up a test-specific logger configuration
 }

src/menu/camera/setup.rs

@@ -4,6 +4,9 @@ use bevy::prelude::*;
 #[derive(Component, Debug)]
 pub struct MenuCamera;
 
+#[derive(Resource)]
+pub struct MenuCameraEntity(pub Entity);
+
 /// Sets up a dedicated camera for the menu
 pub fn setup_menu_camera(
     mut commands: Commands,
@@ -52,7 +55,7 @@ pub fn setup_menu_camera(
     let new_order = highest_order + 1;
     let camera_entity = commands
         .spawn((
-            Camera2d::default(),
+            Camera2d,
             Camera {
                 order: new_order,
                 ..default()
@@ -92,3 +95,27 @@ pub fn cleanup_menu_camera(mut commands: Commands, cameras: Query<Entity, With<M
         }
     }
 }
+
+/// Ensure this camera renders above all other cameras.
+pub fn setup_main_menu_camera(
+    mut commands: Commands,
+    camera_query: Query<Entity, With<MenuCamera>>,
+) {
+    let camera_entity = camera_query.single();
+    commands.entity(camera_entity).insert(Camera {
+        order: isize::MAX - 1,
+        ..default()
+    });
+    commands.insert_resource(MenuCameraEntity(camera_entity));
+
+    info!("Main Menu Camera setup complete");
+}
+
+/// System to despawn the main menu camera
+pub fn despawn_menu_camera(mut commands: Commands, camera_query: Query<Entity, With<MenuCamera>>) {
+    for entity in camera_query.iter() {
+        commands.entity(entity).despawn_recursive();
+    }
+    commands.remove_resource::<MenuCameraEntity>();
+    info!("Main Menu Camera despawned");
+}

src/menu/logo/plugin.rs

@@ -69,7 +69,7 @@ fn setup_startup_logo(
             info!("No menu camera found - creating one before logo setup");
             let camera_entity = commands
                 .spawn((
-                    Camera2d::default(),
+                    Camera2d,
                     Camera {
                         order: 100, // Use a much higher order to avoid conflicts with default cameras
                         ..default()

src/menu/main_menu/systems/interactions.rs

@@ -4,12 +4,21 @@ use crate::menu::{
 };
 use bevy::prelude::*;
 
+/// Type alias for the query used in `handle_main_menu_interactions`.
+type MainMenuButtonInteractionQuery<'w, 's> = Query<
+    'w,
+    's,
+    (
+        &'static Interaction,
+        &'static MenuButtonAction,
+        &'static mut BackgroundColor,
+    ),
+    (Changed<Interaction>, With<Button>),
+>;
+
 /// Handles button interactions for the main menu
 pub fn handle_main_menu_interactions(
-    mut interaction_query: Query<
-        (&Interaction, &MenuButtonAction, &mut BackgroundColor),
-        (Changed<Interaction>, With<Button>),
-    >,
+    mut interaction_query: MainMenuButtonInteractionQuery,
     mut next_state: ResMut<NextState<GameMenuState>>,
     mut settings_state: ResMut<NextState<SettingsMenuState>>,
     mut context: ResMut<StateTransitionContext>,