宏 交互语法设计

[E72UJ]

story! {
    character Alice {
        name = "爱丽丝";
        sprite = "characters/alice.png";
    }
    
    character Bob {
        name = "鲍勃";
        sprite = "characters/bob.png";
    }
    
    background school {
        image = "backgrounds/school.png";
    }
    
    scene opening {
        play music "bgm/theme.mp3"
        show background school
        show character Alice
        Alice says "欢迎来到我们的学校！"
        show choices {
            "图书馆" -> library_scene
            "操场" -> playground_scene
        }
    }
    
    scene library_scene {
        show background library
        Alice says "这里是我们的图书馆，很棒吧？"
        player thinks "这确实是个不错的地方"
        jump to ending
    }
    
    scene ending {
        Alice says "希望你喜欢我们的学校！"
        player says "感谢游玩！"
    }
}

[E72UJ]

mod raven;
mod http;
use raven::prelude::*;
use http::*;  
fn main() {
    let alice = character!(Alice {
        name = "爱丽丝";
        sprite = "characters/alice.png";
    });
    println!("{:?}", alice);

    http::hello();
    
}

[aojiaoxiaolinlin]

mod raven;
mod http;
use raven::prelude::*;
use http::*;  
fn main() {
    let alice = character!(Alice {
        name = "爱丽丝";
        sprite = "characters/alice.png";
    });
    println!("{:?}", alice);

    http::hello();
    
}

这个没看懂诶！

[E72UJ]

错误判断

mod raven;
use raven::prelude::*;

fn main() {
    // 定义故事内容
    let my_story = story! {
        character Alice {
            name = "爱丽丝";
            sprite = "characters/alice.png";
        }
        
        character Bob {
            name = "鲍勃";
            sprite = "characters/bob.png";
        }
        
        background school {
            image = "backgrounds/school.png";
        }
        
        background library {
            image = "backgrounds/library.png";
        }
        
        background playground {
            image = "backgrounds/playground.png";
        }
        
        scene opening {
            play music "bgm/theme.mp3"
            show background school
            show character Alice
            Alice says "欢迎来到我们的学校！"
            show choices {
                "图书馆" -> library_scene,
                "操场" -> playground_scene
            }
        }
        
        scene library_scene {
            show background library
            Alice says "这里是我们的图书馆，很棒吧？"
            player thinks "这确实是个不错的地方"
            jump to ending
        }
        
        scene playground_scene {
            show background playground
            show character Bob as "happy"
            Bob says "来，一起玩游戏吧！"
            player thinks "操场看起来很有趣"
            jump to ending
        }
        
        scene ending {
            show background school
            Alice says "希望你喜欢我们的学校！"
            player says "感谢游玩！"
            end with "完美结局"
        }
    };
    
    // 启动游戏
    run_raven_game_with_story(Some(my_story));
    
    // 游戏结束后的处理
    let result = get_game_result();
    match result {
        GameResult::Ending(ending_name) => {
            println!("游戏结束，结局：{}", ending_name);
        }
        GameResult::Quit => {
            println!("用户退出游戏");
        }
        GameResult::Error(msg) => {
            println!("游戏出错：{}", msg);
        }
    }
    
    // 手动结束游戏资源
    end_raven_game();
}

[E72UJ]

// game/mod.rs

//! 游戏核心模块
//! 
//! 这个模块包含了游戏的主要逻辑，包括对话系统、输入处理、
//! UI管理、音频系统和状态管理等核心功能。

use bevy::prelude::*;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use anyhow::{Result, Context};

// ==================== 常量定义 ====================

/// 游戏配置常量
pub mod constants {
    pub const WINDOW_WIDTH: f32 = 1280.0;
    pub const WINDOW_HEIGHT: f32 = 720.0;
    pub const DIALOGUE_SPEED: f32 = 0.05;
    pub const AUDIO_VOLUME: f32 = 0.7;
    pub const UI_MARGIN: f32 = 20.0;
    
    // 资源路径
    pub const DIALOGUE_PATH: &str = "dialogues.yaml";
    pub const FONT_PATH: &str = "fonts/NotoSansSC-Regular.ttf";
    pub const BGM_PATH: &str = "audio/bgm/";
    pub const SFX_PATH: &str = "audio/sfx/";
}

// ==================== 类型别名 ====================

/// 游戏结果类型别名
pub type GameResult<T> = Result<T, GameError>;

/// 对话ID类型别名
pub type DialogueId = String;

/// 标签名类型别名
pub type LabelName = String;

// ==================== 错误处理 ====================

/// 游戏错误类型
#[derive(Debug, thiserror::Error)]
pub enum GameError {
    #[error("对话文件加载失败: {0}")]
    DialogueLoadError(String),
    
    #[error("音频文件加载失败: {0}")]
    AudioLoadError(String),
    
    #[error("资源未找到: {0}")]
    ResourceNotFound(String),
    
    #[error("序列化错误: {0}")]
    SerializationError(#[from] serde_yaml::Error),
    
    #[error("IO错误: {0}")]
    IoError(#[from] std::io::Error),
}

// ==================== 核心数据结构 ====================

/// 游戏状态
#[derive(Debug, Clone, PartialEq, Eq, Hash, States, Default)]
pub enum GameState {
    #[default]
    MainMenu,
    InGame,
    Dialogue,
    Settings,
    Paused,
}

/// 对话数据结构
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DialogueData {
    pub speaker: Option<String>,
    pub text: String,
    pub choices: Option<Vec<Choice>>,
    pub label: Option<String>,
    pub jump_to: Option<String>,
    pub audio: Option<String>,
    pub background: Option<String>,
    pub character: Option<String>,
    pub effects: Option<Vec<DialogueEffect>>,
}

/// 选择选项
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Choice {
    pub text: String,
    pub jump_to: String,
    pub condition: Option<String>,
}

/// 对话效果
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum DialogueEffect {
    FadeIn { duration: f32 },
    FadeOut { duration: f32 },
    Shake { intensity: f32, duration: f32 },
    TypeWriter { speed: f32 },
    PlaySound { path: String },
    SetFlag { name: String, value: bool },
}

// ==================== 资源定义 ====================

/// 对话资源
#[derive(Debug, Resource)]
pub struct DialogueResource {
    pub dialogues: HashMap<String, Vec<DialogueData>>,
    pub current_dialogue: Option<String>,
    pub current_line: usize,
    pub label_map: HashMap<String, (String, usize)>,
    pub flags: HashMap<String, bool>,
}

impl Default for DialogueResource {
    fn default() -> Self {
        Self {
            dialogues: HashMap::new(),
            current_dialogue: None,
            current_line: 0,
            label_map: HashMap::new(),
            flags: HashMap::new(),
        }
    }
}

/// 音频资源
#[derive(Debug, Resource)]
pub struct AudioResource {
    pub bgm_handles: HashMap<String, Handle<AudioSource>>,
    pub sfx_handles: HashMap<String, Handle<AudioSource>>,
    pub current_bgm: Option<String>,
    pub volumes: AudioVolumes,
}

#[derive(Debug, Clone)]
pub struct AudioVolumes {
    pub master: f32,
    pub bgm: f32,
    pub sfx: f32,
}

impl Default for AudioVolumes {
    fn default() -> Self {
        Self {
            master: 1.0,
            bgm: 0.7,
            sfx: 0.8,
        }
    }
}

/// UI状态资源
#[derive(Debug, Resource, Default)]
pub struct UiState {
    pub dialogue_box_visible: bool,
    pub choice_menu_visible: bool,
    pub settings_menu_visible: bool,
    pub text_speed: f32,
    pub auto_advance: bool,
    pub current_choices: Vec<Choice>,
}

// ==================== 组件定义 ====================

/// 对话框组件
#[derive(Component, Debug)]
pub struct DialogueBox {
    pub current_text: String,
    pub target_text: String,
    pub type_timer: Timer,
    pub is_typing: bool,
}

impl Default for DialogueBox {
    fn default() -> Self {
        Self {
            current_text: String::new(),
            target_text: String::new(),
            type_timer: Timer::from_seconds(constants::DIALOGUE_SPEED, TimerMode::Repeating),
            is_typing: false,
        }
    }
}

/// 选择按钮组件
#[derive(Component, Debug)]
pub struct ChoiceButton {
    pub choice_index: usize,
    pub jump_target: String,
}

/// 角色组件
#[derive(Component, Debug)]
pub struct Character {
    pub name: String,
    pub current_emotion: String,
    pub position: Vec2,
}

/// 背景组件
#[derive(Component, Debug)]
pub struct Background {
    pub current_image: String,
    pub transition_timer: Option<Timer>,
}

// ==================== 事件定义 ====================

/// 对话事件
#[derive(Event, Debug)]
pub enum DialogueEvent {
    StartDialogue { dialogue_id: String },
    NextLine,
    JumpToLabel { label: String },
    MakeChoice { choice_index: usize },
    EndDialogue,
    SetFlag { name: String, value: bool },
}

/// 音频事件
#[derive(Event, Debug)]
pub enum AudioEvent {
    PlayBgm { path: String, loop_audio: bool },
    PlaySfx { path: String },
    StopBgm,
    SetVolume { channel: AudioChannel, volume: f32 },
}

#[derive(Debug, Clone)]
pub enum AudioChannel {
    Master,
    Bgm,
    Sfx,
}

/// UI事件
#[derive(Event, Debug)]
pub enum UiEvent {
    ShowDialogueBox,
    HideDialogueBox,
    ShowChoiceMenu { choices: Vec<Choice> },
    HideChoiceMenu,
    ToggleSettings,
    UpdateTextSpeed { speed: f32 },
}

// ==================== 工具函数 ====================

/// 对话数据加载器
pub struct DialogueLoader;

impl DialogueLoader {
    /// 从文件加载对话数据
    pub fn load_from_file(path: &str) -> GameResult<HashMap<String, Vec<DialogueData>>> {
        let content = std::fs::read_to_string(path)
            .with_context(|| format!("无法读取对话文件: {}", path))?;
        
        let dialogues: HashMap<String, Vec<DialogueData>> = serde_yaml::from_str(&content)
            .with_context(|| "对话数据解析失败")?;
        
        Ok(dialogues)
    }
    
    /// 构建标签映射
    pub fn build_label_map(
        dialogues: &HashMap<String, Vec<DialogueData>>
    ) -> HashMap<String, (String, usize)> {
        let mut label_map = HashMap::new();
        
        for (dialogue_id, lines) in dialogues {
            for (index, line) in lines.iter().enumerate() {
                if let Some(label) = &line.label {
                    label_map.insert(label.clone(), (dialogue_id.clone(), index));
                }
            }
        }
        
        label_map
    }
}

/// 音频管理器
pub struct AudioManager;

impl AudioManager {
    /// 预加载音频资源
    pub fn preload_audio(
        asset_server: &AssetServer,
        audio_resource: &mut AudioResource,
        bgm_paths: &[&str],
        sfx_paths: &[&str],
    ) {
        // 加载BGM
        for path in bgm_paths {
            let handle = asset_server.load(*path);
            let key = Self::extract_filename(path);
            audio_resource.bgm_handles.insert(key, handle);
        }
        
        // 加载音效
        for path in sfx_paths {
            let handle = asset_server.load(*path);
            let key = Self::extract_filename(path);
            audio_resource.sfx_handles.insert(key, handle);
        }
    }
    
    /// 从路径提取文件名
    fn extract_filename(path: &str) -> String {
        std::path::Path::new(path)
            .file_stem()
            .unwrap_or_default()
            .to_string_lossy()
            .to_string()
    }
}

/// UI工具函数
pub mod ui_utils {
    use super::*;
    
    /// 创建文本样式
    pub fn create_text_style(
        font: Handle<Font>,
        size: f32,
        color: Color,
    ) -> TextStyle {
        TextStyle {
            font,
            font_size: size,
            color,
        }
    }
    
    /// 创建按钮样式
    pub fn create_button_style() -> Style {
        Style {
            width: Val::Px(200.0),
            height: Val::Px(50.0),
            margin: UiRect::all(Val::Px(5.0)),
            justify_content: JustifyContent::Center,
            align_items: AlignItems::Center,
            ..default()
        }
    }
    
    /// 计算文本换行
    pub fn wrap_text(text: &str, max_width: f32, font_size: f32) -> Vec<String> {
        // 简单的文本换行实现
        let chars_per_line = (max_width / (font_size * 0.6)) as usize;
        let mut lines = Vec::new();
        let mut current_line = String::new();
        
        for word in text.split_whitespace() {
            if current_line.len() + word.len() + 1 > chars_per_line {
                if !current_line.is_empty() {
                    lines.push(current_line.clone());
                    current_line.clear();
                }
            }
            
            if !current_line.is_empty() {
                current_line.push(' ');
            }
            current_line.push_str(word);
        }
        
        if !current_line.is_empty() {
            lines.push(current_line);
        }
        
        lines
    }
}

/// 验证器
pub mod validators {
    use super::*;
    
    /// 验证对话数据完整性
    pub fn validate_dialogue_data(
        dialogues: &HashMap<String, Vec<DialogueData>>
    ) -> GameResult<()> {
        for (dialogue_id, lines) in dialogues {
            for (index, line) in lines.iter().enumerate() {
                // 验证跳转目标
                if let Some(jump_to) = &line.jump_to {
                    if !Self::is_valid_jump_target(jump_to, dialogues) {
                        return Err(GameError::DialogueLoadError(
                            format!("无效的跳转目标 '{}' 在对话 '{}' 第 {} 行", 
                                   jump_to, dialogue_id, index + 1)
                        ));
                    }
                }
                
                // 验证选择选项
                if let Some(choices) = &line.choices {
                    for choice in choices {
                        if !Self::is_valid_jump_target(&choice.jump_to, dialogues) {
                            return Err(GameError::DialogueLoadError(
                                format!("选择选项中无效的跳转目标 '{}'", choice.jump_to)
                            ));
                        }
                    }
                }
            }
        }
        
        Ok(())
    }
    
    fn is_valid_jump_target(
        target: &str,
        dialogues: &HashMap<String, Vec<DialogueData>>
    ) -> bool {
        // 检查是否是对话ID
        if dialogues.contains_key(target) {
            return true;
        }
        
        // 检查是否是标签
        for lines in dialogues.values() {
            for line in lines {
                if let Some(label) = &line.label {
                    if label == target {
                        return true;
                    }
                }
            }
        }
        
        false
    }
}

// ==================== 插件定义 ====================

/// 游戏核心插件
pub struct GameCorePlugin;

impl Plugin for GameCorePlugin {
    fn build(&self, app: &mut App) {
        app
            // 添加状态
            .add_state::<GameState>()
            
            // 添加资源
            .init_resource::<DialogueResource>()
            .init_resource::<AudioResource>()
            .init_resource::<UiState>()
            
            // 添加事件
            .add_event::<DialogueEvent>()
            .add_event::<AudioEvent>()
            .add_event::<UiEvent>()
            
            // 添加启动系统
            .add_systems(Startup, (
                setup_game,
                load_dialogue_data,
                preload_audio_assets,
            ))
            
            // 添加更新系统
            .add_systems(Update, (
                handle_input.run_if(in_state(GameState::Dialogue)),
                update_dialogue_box.run_if(in_state(GameState::Dialogue)),
                handle_dialogue_events,
                handle_audio_events,
                handle_ui_events,
            ));
    }
}

// ==================== 系统函数 ====================

/// 游戏初始化系统
fn setup_game(mut commands: Commands) {
    commands.spawn(Camera2dBundle::default());
    info!("游戏初始化完成");
}

/// 加载对话数据系统
fn load_dialogue_data(mut dialogue_res: ResMut<DialogueResource>) {
    match DialogueLoader::load_from_file(constants::DIALOGUE_PATH) {
        Ok(dialogues) => {
            // 验证数据
            if let Err(e) = validators::validate_dialogue_data(&dialogues) {
                error!("对话数据验证失败: {}", e);
                return;
            }
            
            // 构建标签映射
            let label_map = DialogueLoader::build_label_map(&dialogues);
            
            dialogue_res.dialogues = dialogues;
            dialogue_res.label_map = label_map;
            
            info!("对话数据加载完成，共 {} 个对话", dialogue_res.dialogues.len());
        }
        Err(e) => {
            error!("加载对话数据失败: {}", e);
        }
    }
}

/// 预加载音频资源系统
fn preload_audio_assets(
    asset_server: Res<AssetServer>,
    mut audio_res: ResMut<AudioResource>,
) {
    let bgm_paths = vec![
        "audio/bgm/main_theme.ogg",
        "audio/bgm/battle_theme.ogg",
    ];
    
    let sfx_paths = vec![
        "audio/sfx/click.ogg",
        "audio/sfx/typing.ogg",
    ];
    
    AudioManager::preload_audio(&asset_server, &mut audio_res, &bgm_paths, &sfx_paths);
    info!("音频资源预加载完成");
}

/// 输入处理系统
fn handle_input(
    keys: Res<Input<KeyCode>>,
    mut dialogue_events: EventWriter<DialogueEvent>,
    dialogue_res: Res<DialogueResource>,
    ui_state: Res<UiState>,
) {
    if keys.just_pressed(KeyCode::Space) || keys.just_pressed(KeyCode::Return) {
        if ui_state.choice_menu_visible {
            // 如果选择菜单可见，不处理空格键
            return;
        }
        
        dialogue_events.send(DialogueEvent::NextLine);
    }
    
    if keys.just_pressed(KeyCode::Escape) {
        dialogue_events.send(DialogueEvent::EndDialogue);
    }
    
    // 选择处理
    if ui_state.choice_menu_visible {
        if keys.just_pressed(KeyCode::Key1) && ui_state.current_choices.len() >= 1 {
            dialogue_events.send(DialogueEvent::MakeChoice { choice_index: 0 });
        }
        if keys.just_pressed(KeyCode::Key2) && ui_state.current_choices.len() >= 2 {
            dialogue_events.send(DialogueEvent::MakeChoice { choice_index: 1 });
        }
        if keys.just_pressed(KeyCode::Key3) && ui_state.current_choices.len() >= 3 {
            dialogue_events.send(DialogueEvent::MakeChoice { choice_index: 2 });
        }
    }
}

/// 对话框更新系统
fn update_dialogue_box(
    time: Res<Time>,
    mut query: Query<&mut DialogueBox>,
    ui_state: Res<UiState>,
) {
    for mut dialogue_box in query.iter_mut() {
        if dialogue_box.is_typing {
            dialogue_box.type_timer.tick(time.delta());
            
            if dialogue_box.type_timer.just_finished() {
                let current_len = dialogue_box.current_text.chars().count();
                let target_len = dialogue_box.target_text.chars().count();
                
                if current_len < target_len {
                    let next_char = dialogue_box.target_text
                        .chars()
                        .nth(current_len)
                        .unwrap_or_default();
                    dialogue_box.current_text.push(next_char);
                } else {
                    dialogue_box.is_typing = false;
                }
            }
        }
    }
}

/// 对话事件处理系统
fn handle_dialogue_events(
    mut events: EventReader<DialogueEvent>,
    mut dialogue_res: ResMut<DialogueResource>,
    mut ui_events: EventWriter<UiEvent>,
    mut audio_events: EventWriter<AudioEvent>,
    mut game_state: ResMut<NextState<GameState>>,
) {
    for event in events.iter() {
        match event {
            DialogueEvent::StartDialogue { dialogue_id } => {
                if let Some(lines) = dialogue_res.dialogues.get(dialogue_id) {
                    if !lines.is_empty() {
                        dialogue_res.current_dialogue = Some(dialogue_id.clone());
                        dialogue_res.current_line = 0;
                        game_state.set(GameState::Dialogue);
                        ui_events.send(UiEvent::ShowDialogueBox);
                        
                        info!("开始对话: {}", dialogue_id);
                    }
                }
            }
            
            DialogueEvent::NextLine => {
                if let Some(dialogue_id) = &dialogue_res.current_dialogue {
                    if let Some(lines) = dialogue_res.dialogues.get(dialogue_id) {
                        let current_line = &lines[dialogue_res.current_line];
                        
                        // 处理选择
                        if let Some(choices) = &current_line.choices {
                            ui_events.send(UiEvent::ShowChoiceMenu { 
                                choices: choices.clone() 
                            });
                            continue;
                        }
                        
                        // 处理跳转
                        if let Some(jump_to) = &current_line.jump_to {
                            if let Some((target_dialogue, target_line)) = 
                                dialogue_res.label_map.get(jump_to) {
                                dialogue_res.current_dialogue = Some(target_dialogue.clone());
                                dialogue_res.current_line = *target_line;
                                continue;
                            }
                        }
                        
                        // 下一行
                        dialogue_res.current_line += 1;
                        if dialogue_res.current_line >= lines.len() {
                            ui_events.send(UiEvent::HideDialogueBox);
                            game_state.set(GameState::InGame);
                            dialogue_res.current_dialogue = None;
                            dialogue_res.current_line = 0;
                        }
                    }
                }
            }
            
            DialogueEvent::MakeChoice { choice_index } => {
                if let Some(dialogue_id) = &dialogue_res.current_dialogue {
                    if let Some(lines) = dialogue_res.dialogues.get(dialogue_id) {
                        let current_line = &lines[dialogue_res.current_line];
                        
                        if let Some(choices) = &current_line.choices {
                            if let Some(choice) = choices.get(*choice_index) {
                                ui_events.send(UiEvent::HideChoiceMenu);
                                
                                // 跳转到选择的目标
                                if let Some((target_dialogue, target_line)) = 
                                    dialogue_res.label_map.get(&choice.jump_to) {
                                    dialogue_res.current_dialogue = Some(target_dialogue.clone());
                                    dialogue_res.current_line = *target_line;
                                }
                            }
                        }
                    }
                }
            }
            
            DialogueEvent::EndDialogue => {
                ui_events.send(UiEvent::HideDialogueBox);
                ui_events.send(UiEvent::HideChoiceMenu);
                game_state.set(GameState::InGame);
                dialogue_res.current_dialogue = None;
                dialogue_res.current_line = 0;
            }
            
            DialogueEvent::SetFlag { name, value } => {
                dialogue_res.flags.insert(name.clone(), *value);
                info!("设置游戏标志: {} = {}", name, value);
            }
            
            _ => {}
        }
    }
}

/// 音频事件处理系统
fn handle_audio_events(
    mut events: EventReader<AudioEvent>,
    mut audio_res: ResMut<AudioResource>,
    mut commands: Commands,
) {
    for event in events.iter() {
        match event {
            AudioEvent::PlayBgm { path, loop_audio } => {
                if let Some(handle) = audio_res.bgm_handles.get(path) {
                    commands.spawn(AudioBundle {
                        source: handle.clone(),
                        settings: PlaybackSettings {
                            mode: if *loop_audio { 
                                bevy::audio::PlaybackMode::Loop 
                            } else { 
                                bevy::audio::PlaybackMode::Once 
                            },
                            volume: bevy::audio::Volume::new(
                                audio_res.volumes.master * audio_res.volumes.bgm
                            ),
                            ..default()
                        },
                    });
                    audio_res.current_bgm = Some(path.clone());
                }
            }
            
            AudioEvent::PlaySfx { path } => {
                if let Some(handle) = audio_res.sfx_handles.get(path) {
                    commands.spawn(AudioBundle {
                        source: handle.clone(),
                        settings: PlaybackSettings {
                            mode: bevy::audio::PlaybackMode::Once,
                            volume: bevy::audio::Volume::new(
                                audio_res.volumes.master * audio_res.volumes.sfx
                            ),
                            ..default()
                        },
                    });
                }
            }
            
            AudioEvent::SetVolume { channel, volume } => {
                match channel {
                    AudioChannel::Master => audio_res.volumes.master = *volume,
                    AudioChannel::Bgm => audio_res.volumes.bgm = *volume,
                    AudioChannel::Sfx => audio_res.volumes.sfx = *volume,
                }
            }
            
            _ => {}
        }
    }
}

/// UI事件处理系统
fn handle_ui_events(
    mut events: EventReader<UiEvent>,
    mut ui_state: ResMut<UiState>,
) {
    for event in events.iter() {
        match event {
            UiEvent::ShowDialogueBox => {
                ui_state.dialogue_box_visible = true;
            }
            
            UiEvent::HideDialogueBox => {
                ui_state.dialogue_box_visible = false;
            }
            
            UiEvent::ShowChoiceMenu { choices } => {
                ui_state.choice_menu_visible = true;
                ui_state.current_choices = choices.clone();
            }
            
            UiEvent::HideChoiceMenu => {
                ui_state.choice_menu_visible = false;
                ui_state.current_choices.clear();
            }
            
            UiEvent::UpdateTextSpeed { speed } => {
                ui_state.text_speed = *speed;
            }
            
            _ => {}
        }
    }
}

// ==================== 测试模块 ====================

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_dialogue_validation() {
        let mut dialogues = HashMap::new();
        let test_dialogue = vec![
            DialogueData {
                speaker: Some("测试角色".to_string()),
                text: "这是测试对话".to_string(),
                choices: None,
                label: Some("start".to_string()),
                jump_to: None,
                audio: None,
                background: None,
                character: None,
                effects: None,
            }
        ];
        
        dialogues.insert("test".to_string(), test_dialogue);
        
        assert!(validators::validate_dialogue_data(&dialogues).is_ok());
    }
    
    #[test]
    fn test_label_map_generation() {
        let mut dialogues = HashMap::new();
        let test_dialogue = vec![
            DialogueData {
                speaker: None,
                text: "第一行".to_string(),
                choices: None,
                label: Some("start".to_string()),
                jump_to: None,
                audio: None,
                background: None,
                character: None,
                effects: None,
            },
            DialogueData {
                speaker: None,
                text: "第二行".to_string(),
                choices: None,
                label: Some("middle".to_string()),
                jump_to: None,
                audio: None,
                background: None,
                character: None,
                effects: None,
            },
        ];
        
        dialogues.insert("test".to_string(), test_dialogue);
        
        let label_map = DialogueLoader::build_label_map(&dialogues);
        
        assert_eq!(label_map.get("start"), Some(&("test".to_string(), 0)));
        assert_eq!(label_map.get("middle"), Some(&("test".to_string(), 1)));
    }
    
    #[test]
    fn test_text_wrapping() {
        let text = "这是一个很长的文本需要进行换行处理";
        let lines = ui_utils::wrap_text(text, 100.0, 16.0);
        
        assert!(!lines.is_empty());
        assert!(lines.iter().all(|line| !line.is_empty()));
    }
    
    #[test]
    fn test_audio_filename_extraction() {
        let path = "audio/bgm/main_theme.ogg";
        let filename = AudioManager::extract_filename(path);
        
        assert_eq!(filename, "main_theme");
    }
}

// ==================== 导出接口 ====================

// 公开API
pub use constants::*;
pub use validators::validate_dialogue_data;
pub use ui_utils::*;

// 预设配置
pub fn create_default_game_config() -> (DialogueResource, AudioResource, UiState) {
    (
        DialogueResource::default(),
        AudioResource {
            bgm_handles: HashMap::new(),
            sfx_handles: HashMap::new(),
            current_bgm: None,
            volumes: AudioVolumes::default(),
        },
        UiState::default(),
    )
}