Bli-AIk
diff --git a/‎crates/bevy_fact_rule_event‎ b/‎crates/bevy_fact_rule_event‎
diff --git a/‎crates/souprune/src/app_state.rs‎
Lines changed: 97 additions & 30 deletions b/‎crates/souprune/src/app_state.rs‎
Lines changed: 97 additions & 30 deletions
diff --git a/‎crates/souprune/src/app_state/app_setup.rs‎
Lines changed: 9 additions & 48 deletions b/‎crates/souprune/src/app_state/app_setup.rs‎
Lines changed: 9 additions & 48 deletions
@@ -1,48 +1,115 @@
 //! # app_state.rs
 //!
-//! # app_state.rs 文件
-//!
-//! ## Module Overview
-//!
 //! ## 模块概述
 //!
-//! The `app_state` module contains the concrete modules for each application state.
-//!
-//! app_state 模块包含了每个应用程序状态的具体模块。
-//!
-//! ## Source File Overview
-//!
-//! ## 源文件概述
-//!
-//! This file defines the application's state enumeration used throughout the game.
-//!
-//! 此处定义了贯穿整个游戏的应用程序状态枚举。
-//!
-//! It includes states for setup, menu, overworld, and battle.
-//!
-//! 包含初始化、菜单界面、Overworld 和战斗状态。
-//!
-//! The entire game's state management is based on this enumeration, with the Setup state entered first.
-//!
-//! 整个游戏的状态管理都基于此枚举，且 Setup 状态会最先被进入。
+//! 定义应用程序状态、序列模式、模式作用域和动态子状态。
+//! 全部由数据驱动，无硬编码模式枚举。
 
-use bevy::prelude::{Commands, Component, Entity, Query, States, With};
+use bevy::ecs::message::{Message, MessageReader, MessageWriter};
+use bevy::prelude::*;
 
 pub(crate) mod app_setup;
 pub(crate) mod battle;
 pub(crate) mod overworld;
 
+/// 应用程序生命周期状态。Loading = 资源加载，Running = 序列运行中。
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, States)]
-#[allow(dead_code)]
 pub enum AppState {
     #[default]
-    AppSetup,
-    Menu,
-    Overworld,
-    Battle,
+    Loading,
+    Running,
+}
+
+/// 当前序列模式。由序列 RON 文件的 `mode` 字段声明，决定哪些系统集激活。
+/// 替代原 `GameMode` 枚举——完全数据驱动。
+#[derive(Resource, Default, Debug, Clone, PartialEq, Eq)]
+pub struct SequenceMode(pub Option<String>);
+
+impl SequenceMode {
+    pub fn is(&self, mode: &str) -> bool {
+        self.0.as_deref() == Some(mode)
+    }
+}
+
+/// 判断当前模式是否匹配。用于系统集的 `run_if` 条件。
+pub fn is_mode(mode: &'static str) -> impl Fn(Res<SequenceMode>) -> bool + Clone {
+    move |res: Res<SequenceMode>| res.0.as_deref() == Some(mode)
+}
+
+/// 将实体与特定模式关联。模式切换时旧模式的实体被自动清理。
+/// 替代原 `OverworldEntity` / `BattleEntity` 标记。
+#[derive(Component, Clone, Debug)]
+pub struct ModeScoped(pub String);
+
+/// 模式变更事件。在 `SequenceMode` 资源变化时由检测系统自动发出。
+#[derive(Message, Debug, Clone)]
+pub struct ModeChanged {
+    pub from: Option<String>,
+    pub to: Option<String>,
 }
 
-// TODO: 状态管理、状态转换
+/// 模式内的动态子状态。替代原 `OverworldSubState`，任何模式都可使用。
+/// 模式切换时自动重置为 "Normal"。
+#[derive(Debug, Clone, PartialEq, Eq, Hash, States)]
+pub struct SequenceSubState(pub String);
+
+impl Default for SequenceSubState {
+    fn default() -> Self {
+        Self("Normal".to_string())
+    }
+}
+
+impl SequenceSubState {
+    pub fn new(name: impl Into<String>) -> Self {
+        Self(name.into())
+    }
+
+    pub fn is(&self, name: &str) -> bool {
+        self.0 == name
+    }
+
+    pub fn name(&self) -> &str {
+        &self.0
+    }
+}
+
+/// 检测 `SequenceMode` 变化并发出 `ModeChanged` 事件。同时重置 `SequenceSubState`。
+pub fn detect_mode_changes(
+    mode: Res<SequenceMode>,
+    mut previous: Local<Option<String>>,
+    mut events: MessageWriter<ModeChanged>,
+    mut next_sub_state: ResMut<NextState<SequenceSubState>>,
+) {
+    if mode.is_changed() {
+        let from = previous.clone();
+        let to = mode.0.clone();
+        if from != to {
+            events.write(ModeChanged {
+                from: from.clone(),
+                to: to.clone(),
+            });
+            next_sub_state.set(SequenceSubState::default());
+            *previous = to;
+        }
+    }
+}
+
+/// 模式切换时清理旧模式的 `ModeScoped` 实体。
+pub fn cleanup_mode_scoped_entities(
+    mut commands: Commands,
+    mut events: MessageReader<ModeChanged>,
+    query: Query<(Entity, &ModeScoped)>,
+) {
+    for event in events.read() {
+        if let Some(ref from) = event.from {
+            for (entity, scoped) in query.iter() {
+                if scoped.0 == *from {
+                    commands.entity(entity).despawn();
+                }
+            }
+        }
+    }
+}
 
 pub fn cleanup_entities_system<T: Component>(
     mut commands: Commands,
 
@@ -25,27 +25,25 @@ use crate::core::sprite::ModuleSpriteRegistry;
 use bevy::app::{App, Plugin, Update};
 use bevy::asset::LoadedFolder;
 use bevy::prelude::*;
-use bevy_ecs_tiled::prelude::TiledMapAsset;
 use std::fs;
 
 pub(crate) struct AppSetupPlugin;
 
 impl Plugin for AppSetupPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
-            OnEnter(AppState::AppSetup),
+            OnEnter(AppState::Loading),
             (
                 load_textures_system,
                 setup_camera_system,
-                preload_maps_system,
                 #[cfg(not(target_os = "android"))]
                 setup_touch_overlay_system,
             ),
         )
         .add_systems(
             Update,
             (
-                check_textures_system.run_if(in_state(AppState::AppSetup)),
+                check_textures_system.run_if(in_state(AppState::Loading)),
                 crate::core::input::touch::update_touch_button_visuals,
                 crate::core::input::touch::tick_touch_button_animations,
                 crate::core::input::touch::update_controller_directions,
@@ -142,18 +140,14 @@ pub struct DiscoveredModules(pub Vec<String>);
 
 fn check_textures_system(
     mut next_state: ResMut<NextState<AppState>>,
+    mut sequence_mode: ResMut<crate::app_state::SequenceMode>,
     sprite_registry: Res<ModuleSpriteRegistry>,
     asset_server: Res<AssetServer>,
     mut events: MessageReader<AssetEvent<LoadedFolder>>,
     souprune_config: Res<crate::config::SoupruneConfig>,
     discovered_modules: Res<DiscoveredModules>,
 ) {
     for _ in events.read() {
-        // Check that all required modules are loaded
-        // Required modules come from config, but must be present in discovered modules
-        //
-        // 检查所有必需模块是否已加载
-        // 必需模块来自配置，但必须存在于发现的模块中
         let required_loaded = souprune_config.game.required_modules.iter().all(|module| {
             if !discovered_modules.0.contains(module) {
                 warn!(
@@ -169,9 +163,6 @@ fn check_textures_system(
             }
         });
 
-        // Also check that all discovered modules are loaded
-        //
-        // 同时检查所有发现的模块是否已加载
         let all_discovered_loaded = discovered_modules.0.iter().all(|module| {
             if let Some(handle) = sprite_registry.get_module(module) {
                 asset_server.is_loaded_with_dependencies(handle)
@@ -183,16 +174,19 @@ fn check_textures_system(
         if required_loaded && all_discovered_loaded {
             info!("All texture modules loaded: {:?}", discovered_modules.0);
 
-            if souprune_config.game.initial_map_path.is_empty()
+            next_state.set(AppState::Running);
+
+            if souprune_config.game.initial_sequence_path.is_none()
+                && souprune_config.game.initial_map_path.is_empty()
                 && !souprune_config.game.initial_battle_path.is_empty()
             {
                 info!(
                     "No initial map path, but initial battle path found. Entering Battle: {}",
                     souprune_config.game.initial_battle_path
                 );
-                next_state.set(AppState::Battle);
+                sequence_mode.0 = Some("battle".to_string());
             } else {
-                next_state.set(AppState::Overworld);
+                sequence_mode.0 = Some("overworld".to_string());
             }
             break;
         }
@@ -343,39 +337,6 @@ fn deferred_touch_overlay_system(
     commands.insert_resource(TouchOverlaySpawned);
 }
 
-/// Preload map assets during AppSetup to avoid loading spikes when entering Overworld.
-///
-/// 在 AppSetup 阶段预加载地图资源，避免进入 Overworld 时的加载卡顿。
-fn preload_maps_system(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-    souprune_config: Res<crate::config::SoupruneConfig>,
-) {
-    let initial_map = &souprune_config.game.initial_map_path;
-
-    if !initial_map.is_empty() {
-        info!("Preloading initial map: {}", initial_map);
-        let handle: Handle<TiledMapAsset> = asset_server.load(initial_map);
-        commands.insert_resource(PreloadedMaps {
-            initial_map: Some(handle),
-        });
-    } else {
-        commands.insert_resource(PreloadedMaps { initial_map: None });
-    }
-}
-
-/// Resource storing preloaded map handles.
-/// Using preloaded maps avoids the loading spike when entering Overworld.
-///
-/// 存储预加载地图句柄的资源。
-/// 使用预加载地图可以避免进入 Overworld 时的加载尖峰。
-#[derive(Resource, Default)]
-pub struct PreloadedMaps {
-    /// The initial overworld map handle, preloaded during AppSetup.
-    /// 初始 Overworld 地图句柄，在 AppSetup 期间预加载。
-    pub initial_map: Option<Handle<TiledMapAsset>>,
-}
-
 #[derive(Resource)]
 pub(crate) struct ResolutionScale(pub(crate) u32);