AiYo-Studio/emod-cli
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(debug): 支持 JSON UI 热重载

Browse Source 
新增可选的 auto_hot_reload_ui 配置，追踪资源包 UI JSON 的新增、修改、删除和重命名，并在游戏回到前台时发送原生 Ctrl+R。

统一 Python 与 JSON UI 的批处理和拖尾防抖逻辑，同时补充路径分类、事件动作与快捷键消息测试。
This commit is contained in:
Blank038
2026-07-21 20:44:13 +08:00
parent 86a39dace7
commit 3afc122404
6 changed files with 701 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@@ -30,5 +30,6 @@ windows-sys = { version = "0.59", features = [
"Win32_System_SystemServices",
"Win32_System_SystemInformation",
"Win32_System_Threading",
"Win32_UI_Input_KeyboardAndMouse",
"Win32_UI_WindowsAndMessaging",
] }

14
src/debug/config.rs
View File

@@ -26,6 +26,8 @@ pub struct DebugConfig {
pub include_debug_mod: bool,
#[serde(default = "default_true")]
pub auto_hot_reload_mods: bool,
#[serde(default)]
pub auto_hot_reload_ui: bool,
#[serde(default = "default_world_type")]
pub world_type: i32,
#[serde(default = "default_game_mode")]
@@ -200,6 +202,7 @@ fn create_default_config() -> DebugConfig {
auto_join_game: true,
include_debug_mod: true,
auto_hot_reload_mods: true,
auto_hot_reload_ui: false,
world_type: default_world_type(),
game_mode: default_game_mode(),
enable_cheats: true,
@@ -350,7 +353,7 @@ mod tests {
time::{SystemTime, UNIX_EPOCH},
};
use super::{allocate_new_world, resolve_mod_dir, strip_json_comments};
use super::{DebugConfig, allocate_new_world, resolve_mod_dir, strip_json_comments};
struct TempProject {
path: PathBuf,
@@ -388,6 +391,15 @@ mod tests {
);
}
#[test]
fn json_ui_hot_reload_is_opt_in() {
let default_config: DebugConfig = serde_json::from_str("{}").unwrap();
assert!(!default_config.auto_hot_reload_ui);
let enabled: DebugConfig = serde_json::from_str(r#"{"auto_hot_reload_ui":true}"#).unwrap();
assert!(enabled.auto_hot_reload_ui);
}
#[test]
fn allocate_new_world_updates_folder_and_name() {
let project = TempProject::new();

710
src/debug/hotreload.rs
View File

@@ -1,32 +1,101 @@
use std::{
collections::{HashMap, HashSet},
collections::{BTreeSet, HashSet},
mem,
path::{Path, PathBuf},
sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
},
thread::{self, JoinHandle},
time::Duration,
time::{Duration, Instant},
};
#[cfg(not(windows))]
use std::{fs, time::SystemTime};
use std::{collections::HashMap, fs, time::SystemTime};
use serde_json::json;
#[cfg(not(windows))]
use walkdir::WalkDir;
use super::{
addon::{self, PackType},
config::ResolvedModDir,
ipc::DebugIpcServer,
log::{self, ConsoleColor},
win,
};
const DEBOUNCE_MS: u64 = 100;
const DEBOUNCE_MS: u64 = 150;
#[derive(Clone, Copy, Debug, Default)]
pub struct HotReloadOptions {
pub python: bool,
pub json_ui: bool,
}
impl HotReloadOptions {
fn enabled(self) -> bool {
self.python || self.json_ui
}
}
#[derive(Debug, Default, Eq, PartialEq)]
struct PendingReload {
python_modules: BTreeSet<String>,
json_ui: bool,
}
impl PendingReload {
fn is_empty(&self) -> bool {
self.python_modules.is_empty() && !self.json_ui
}
fn merge(&mut self, mut other: Self) {
self.python_modules.append(&mut other.python_modules);
self.json_ui |= other.json_ui;
}
}
#[derive(Debug, Default)]
struct ReloadState {
pending: PendingReload,
is_foreground: bool,
}
#[derive(Debug, Eq, PartialEq)]
enum ReloadAction {
Python(Vec<String>),
JsonUi,
}
#[derive(Debug, Default)]
struct DebouncedPaths {
paths: HashSet<PathBuf>,
last_event: Option<Instant>,
}
impl DebouncedPaths {
fn push(&mut self, path: PathBuf, now: Instant) {
self.paths.insert(path);
self.last_event = Some(now);
}
fn take_ready(&mut self, now: Instant) -> Vec<PathBuf> {
let ready = self
.last_event
.map(|last| now.duration_since(last) >= Duration::from_millis(DEBOUNCE_MS))
.unwrap_or(false);
if !ready {
return Vec::new();
}
self.last_event = None;
self.paths.drain().collect()
}
}
pub struct HotReloadTask {
stop: Arc<AtomicBool>,
file_thread: Option<JoinHandle<()>>,
foreground_thread: Option<JoinHandle<()>>,
}
@@ -35,8 +104,13 @@ impl HotReloadTask {
pub fn start(
process_id: u32,
mod_dirs: &[ResolvedModDir],
ipc: DebugIpcServer,
ipc: Option<DebugIpcServer>,
options: HotReloadOptions,
) -> Option<Self> {
if !options.enabled() {
return None;
}
let roots: Vec<PathBuf> = mod_dirs
.iter()
.filter(|dir| dir.hot_reload)
@@ -52,45 +126,24 @@ impl HotReloadTask {
}
let stop = Arc::new(AtomicBool::new(false));
let need_update = Arc::new(AtomicBool::new(false));
let is_foreground = Arc::new(AtomicBool::new(false));
let cached_paths = Arc::new(Mutex::new(HashSet::new()));
let state = Arc::new(Mutex::new(ReloadState::default()));
let file_thread = {
let stop = Arc::clone(&stop);
let need_update = Arc::clone(&need_update);
let is_foreground = Arc::clone(&is_foreground);
let cached_paths = Arc::clone(&cached_paths);
let state = Arc::clone(&state);
let ipc = ipc.clone();
let roots = roots.clone();
thread::spawn(move || {
watch_py_files(roots, stop, need_update, is_foreground, cached_paths, ipc)
})
thread::spawn(move || watch_files(process_id, roots, stop, state, ipc, options))
};
let foreground_thread = {
let stop = Arc::clone(&stop);
let need_update = Arc::clone(&need_update);
let is_foreground = Arc::clone(&is_foreground);
let cached_paths = Arc::clone(&cached_paths);
let ipc = ipc.clone();
let roots = roots.clone();
thread::spawn(move || {
watch_foreground(
process_id,
roots,
stop,
need_update,
is_foreground,
cached_paths,
ipc,
)
})
let state = Arc::clone(&state);
thread::spawn(move || watch_foreground(process_id, stop, state, ipc))
};
Some(Self {
stop,
file_thread: Some(file_thread),
foreground_thread: Some(foreground_thread),
})
@@ -113,32 +166,32 @@ impl Drop for HotReloadTask {
}
}
fn watch_py_files(
fn watch_files(
process_id: u32,
roots: Vec<PathBuf>,
stop: Arc<AtomicBool>,
need_update: Arc<AtomicBool>,
is_foreground: Arc<AtomicBool>,
cached_paths: Arc<Mutex<HashSet<PathBuf>>>,
ipc: DebugIpcServer,
state: Arc<Mutex<ReloadState>>,
ipc: Option<DebugIpcServer>,
options: HotReloadOptions,
) {
watch_py_files_native(roots, stop, need_update, is_foreground, cached_paths, ipc);
watch_files_native(process_id, roots, stop, state, ipc, options);
}
#[cfg(windows)]
fn watch_py_files_native(
fn watch_files_native(
process_id: u32,
roots: Vec<PathBuf>,
stop: Arc<AtomicBool>,
need_update: Arc<AtomicBool>,
is_foreground: Arc<AtomicBool>,
cached_paths: Arc<Mutex<HashSet<PathBuf>>>,
ipc: DebugIpcServer,
state: Arc<Mutex<ReloadState>>,
ipc: Option<DebugIpcServer>,
options: HotReloadOptions,
) {
use std::{mem, os::windows::ffi::OsStrExt, ptr, time::Instant};
use std::{mem, os::windows::ffi::OsStrExt, ptr};
use windows_sys::Win32::{
Foundation::{HANDLE, INVALID_HANDLE_VALUE, WAIT_FAILED, WAIT_OBJECT_0, WAIT_TIMEOUT},
Storage::FileSystem::{
CreateFileW, FILE_ACTION_MODIFIED, FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OVERLAPPED,
FILE_LIST_DIRECTORY, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_NOTIFY_INFORMATION,
CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OVERLAPPED, FILE_LIST_DIRECTORY,
FILE_NOTIFY_CHANGE_FILE_NAME, FILE_NOTIFY_CHANGE_LAST_WRITE, FILE_NOTIFY_INFORMATION,
FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE, OPEN_EXISTING,
ReadDirectoryChangesW,
},
@@ -179,7 +232,7 @@ fn watch_py_files_native(
item.buffer.as_mut_ptr().cast(),
item.buffer.len() as u32,
1,
FILE_NOTIFY_CHANGE_LAST_WRITE,
FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_FILE_NAME,
&mut bytes_returned,
&mut item.overlapped,
None,
@@ -239,178 +292,236 @@ fn watch_py_files_native(
start_watch(item);
}
let mut debounce = HashMap::<PathBuf, Instant>::new();
let mut debounced = DebouncedPaths::default();
while !stop.load(Ordering::Relaxed) {
let handles: Vec<HANDLE> = items.iter().map(|item| item.event).collect();
let result =
unsafe { WaitForMultipleObjects(handles.len() as u32, handles.as_ptr(), 0, 100) };
if result == WAIT_TIMEOUT {
continue;
}
unsafe { WaitForMultipleObjects(handles.len() as u32, handles.as_ptr(), 0, 50) };
if result == WAIT_FAILED {
break;
}
let index = (result - WAIT_OBJECT_0) as usize;
if index >= items.len() {
continue;
}
let item = &mut items[index];
let mut bytes = 0u32;
let ok = unsafe { GetOverlappedResult(item.h_dir, &mut item.overlapped, &mut bytes, 0) };
if ok == 0 || bytes == 0 {
start_watch(item);
continue;
if result != WAIT_TIMEOUT {
let index = (result - WAIT_OBJECT_0) as usize;
if index < items.len() {
let item = &mut items[index];
let mut bytes = 0u32;
let ok =
unsafe { GetOverlappedResult(item.h_dir, &mut item.overlapped, &mut bytes, 0) };
if ok != 0 && bytes != 0 {
let mut offset = 0usize;
let now = Instant::now();
while offset < bytes as usize {
let info = unsafe {
&*(item.buffer.as_ptr().add(offset) as *const FILE_NOTIFY_INFORMATION)
};
let name_len = (info.FileNameLength / 2) as usize;
let name =
unsafe { std::slice::from_raw_parts(info.FileName.as_ptr(), name_len) };
let path = item.dir.join(String::from_utf16_lossy(name));
if is_supported_file_action(info.Action)
&& is_tracked_reload_path(&path, &roots, options)
{
debounced.push(path, now);
}
if info.NextEntryOffset == 0 {
break;
}
offset += info.NextEntryOffset as usize;
}
}
start_watch(item);
}
}
let mut offset = 0usize;
while offset < bytes as usize {
let info =
unsafe { &*(item.buffer.as_ptr().add(offset) as *const FILE_NOTIFY_INFORMATION) };
let name_len = (info.FileNameLength / 2) as usize;
let name = unsafe { std::slice::from_raw_parts(info.FileName.as_ptr(), name_len) };
let path = item.dir.join(String::from_utf16_lossy(name));
if info.Action == FILE_ACTION_MODIFIED
&& path.extension().and_then(|ext| ext.to_str()) == Some("py")
{
let now = Instant::now();
let should_trigger = debounce
.get(&path)
.map(|last| now.duration_since(*last) >= Duration::from_millis(DEBOUNCE_MS))
.unwrap_or(true);
if should_trigger {
debounce.insert(path.clone(), now);
record_changed_path(
&roots,
&path,
&cached_paths,
&need_update,
&is_foreground,
&ipc,
);
}
}
if info.NextEntryOffset == 0 {
break;
}
offset += info.NextEntryOffset as usize;
let paths = debounced.take_ready(Instant::now());
if !paths.is_empty() {
record_changed_paths(process_id, &roots, paths, options, &state, ipc.as_ref());
}
start_watch(item);
}
}
#[cfg(windows)]
fn is_supported_file_action(action: u32) -> bool {
use windows_sys::Win32::Storage::FileSystem::{
FILE_ACTION_ADDED, FILE_ACTION_MODIFIED, FILE_ACTION_REMOVED, FILE_ACTION_RENAMED_NEW_NAME,
FILE_ACTION_RENAMED_OLD_NAME,
};
matches!(
action,
FILE_ACTION_ADDED
| FILE_ACTION_MODIFIED
| FILE_ACTION_REMOVED
| FILE_ACTION_RENAMED_OLD_NAME
| FILE_ACTION_RENAMED_NEW_NAME
)
}
#[cfg(not(windows))]
fn watch_py_files_native(
fn watch_files_native(
process_id: u32,
roots: Vec<PathBuf>,
stop: Arc<AtomicBool>,
need_update: Arc<AtomicBool>,
is_foreground: Arc<AtomicBool>,
cached_paths: Arc<Mutex<HashSet<PathBuf>>>,
ipc: DebugIpcServer,
state: Arc<Mutex<ReloadState>>,
ipc: Option<DebugIpcServer>,
options: HotReloadOptions,
) {
let mut last_seen = snapshot_py_files(&roots);
let mut debounce = HashMap::<PathBuf, SystemTime>::new();
let mut last_seen = snapshot_files(&roots, options);
while !stop.load(Ordering::Relaxed) {
thread::sleep(Duration::from_millis(DEBOUNCE_MS));
let now = SystemTime::now();
let current = snapshot_py_files(&roots);
let current = snapshot_files(&roots, options);
let mut paths = Vec::new();
for (path, modified) in &current {
let changed = match last_seen.get(path) {
Some(previous) => modified > previous,
None => false,
};
if !changed {
continue;
if last_seen.get(path) != Some(modified) {
paths.push(path.clone());
}
if let Some(last) = debounce.get(path) {
if now.duration_since(*last).unwrap_or_default()
< Duration::from_millis(DEBOUNCE_MS)
{
continue;
}
}
for path in last_seen.keys() {
if !current.contains_key(path) {
paths.push(path.clone());
}
debounce.insert(path.clone(), now);
record_changed_path(
&roots,
path,
&cached_paths,
&need_update,
&is_foreground,
&ipc,
);
}
if !paths.is_empty() {
record_changed_paths(process_id, &roots, paths, options, &state, ipc.as_ref());
}
last_seen = current;
}
}
fn record_changed_path(
fn record_changed_paths(
process_id: u32,
roots: &[PathBuf],
path: &Path,
cached_paths: &Arc<Mutex<HashSet<PathBuf>>>,
need_update: &Arc<AtomicBool>,
is_foreground: &Arc<AtomicBool>,
ipc: &DebugIpcServer,
paths: Vec<PathBuf>,
options: HotReloadOptions,
state: &Arc<Mutex<ReloadState>>,
ipc: Option<&DebugIpcServer>,
) {
log::print_colored(
&format!("[HotReload] Detected change in: {}", path.display()),
ConsoleColor::Yellow,
);
cached_paths.lock().unwrap().insert(path.to_path_buf());
need_update.store(true, Ordering::Relaxed);
if is_foreground.load(Ordering::Relaxed) {
trigger_reload(roots, cached_paths, need_update, ipc);
let (batch, tracked_paths) = build_reload_batch(paths, roots, options);
if batch.is_empty() {
return;
}
for path in tracked_paths {
log::print_colored(
&format!("[HotReload] Detected change in: {}", path.display()),
ConsoleColor::Yellow,
);
}
let should_trigger = {
let mut guard = state.lock().unwrap();
guard.pending.merge(batch);
guard.is_foreground
};
if should_trigger {
trigger_reload(process_id, state, ipc);
}
}
fn build_reload_batch(
paths: Vec<PathBuf>,
roots: &[PathBuf],
options: HotReloadOptions,
) -> (PendingReload, Vec<PathBuf>) {
let mut batch = PendingReload::default();
let mut tracked_paths = Vec::new();
for path in paths {
let mut tracked = false;
if options.python {
if let Some(module) = py_path_to_module_name(&path, roots) {
batch.python_modules.insert(module);
tracked = true;
}
}
if options.json_ui && is_json_ui_path(&path, roots) {
batch.json_ui = true;
tracked = true;
}
if tracked {
tracked_paths.push(path);
}
}
(batch, tracked_paths)
}
fn watch_foreground(
process_id: u32,
roots: Vec<PathBuf>,
stop: Arc<AtomicBool>,
need_update: Arc<AtomicBool>,
is_foreground: Arc<AtomicBool>,
cached_paths: Arc<Mutex<HashSet<PathBuf>>>,
ipc: DebugIpcServer,
state: Arc<Mutex<ReloadState>>,
ipc: Option<DebugIpcServer>,
) {
let mut last_state = false;
while !stop.load(Ordering::Relaxed) {
let current = foreground_process_id() == Some(process_id);
is_foreground.store(current, Ordering::Relaxed);
if current && !last_state && need_update.load(Ordering::Relaxed) {
trigger_reload(&roots, &cached_paths, &need_update, &ipc);
let should_trigger = {
let mut guard = state.lock().unwrap();
guard.is_foreground = current;
current && !last_state && !guard.pending.is_empty()
};
if should_trigger {
trigger_reload(process_id, &state, ipc.as_ref());
}
last_state = current;
thread::sleep(Duration::from_millis(80));
}
}
fn trigger_reload(
roots: &[PathBuf],
cached_paths: &Arc<Mutex<HashSet<PathBuf>>>,
need_update: &Arc<AtomicBool>,
ipc: &DebugIpcServer,
) {
let paths: Vec<PathBuf> = {
let mut guard = cached_paths.lock().unwrap();
guard.drain().collect()
fn trigger_reload(process_id: u32, state: &Arc<Mutex<ReloadState>>, ipc: Option<&DebugIpcServer>) {
let batch = {
let mut guard = state.lock().unwrap();
mem::take(&mut guard.pending)
};
let modules: Vec<String> = paths
.iter()
.filter_map(|path| py_path_to_module_name(path, roots))
.collect();
need_update.store(false, Ordering::Relaxed);
if modules.is_empty() {
return;
for action in reload_actions(batch) {
match action {
ReloadAction::Python(modules) => {
log::print_colored(
"[HotReload] 检测到 Python 修改，已触发增量热更新。",
ConsoleColor::Yellow,
);
if let Some(ipc) = ipc {
let payload = json!(modules).to_string();
let _ = ipc.send_message(2, payload.as_bytes());
}
}
ReloadAction::JsonUi => match win::trigger_ui_reload_shortcut(process_id) {
Ok(()) => log::print_colored(
"[HotReload] JSON UI 修改已触发原生 Ctrl+R 重载。",
ConsoleColor::Green,
),
Err(err) => {
log::print_colored(
&format!("[HotReload] JSON UI 原生 Ctrl+R 重载失败：{err}"),
ConsoleColor::Red,
);
state.lock().unwrap().pending.json_ui = true;
}
},
}
}
log::print_colored(
"[HotReload] 检测到修改，已触发热更新。",
ConsoleColor::Yellow,
);
let payload = json!(modules).to_string();
let _ = ipc.send_message(2, payload.as_bytes());
}
fn reload_actions(batch: PendingReload) -> Vec<ReloadAction> {
let mut actions = Vec::with_capacity(2);
if !batch.python_modules.is_empty() {
actions.push(ReloadAction::Python(
batch.python_modules.into_iter().collect(),
));
}
if batch.json_ui {
actions.push(ReloadAction::JsonUi);
}
actions
}
#[cfg(not(windows))]
fn snapshot_py_files(roots: &[PathBuf]) -> HashMap<PathBuf, SystemTime> {
fn snapshot_files(roots: &[PathBuf], options: HotReloadOptions) -> HashMap<PathBuf, SystemTime> {
let mut files = HashMap::new();
for root in roots {
if !root.is_dir() {
@@ -418,7 +529,7 @@ fn snapshot_py_files(roots: &[PathBuf]) -> HashMap<PathBuf, SystemTime> {
}
for entry in WalkDir::new(root).into_iter().filter_map(Result::ok) {
let path = entry.path();
if !path.is_file() || path.extension().and_then(|ext| ext.to_str()) != Some("py") {
if !path.is_file() || !is_tracked_reload_path(path, roots, options) {
continue;
}
if let Ok(metadata) = fs::metadata(path) {
@@ -431,6 +542,53 @@ fn snapshot_py_files(roots: &[PathBuf]) -> HashMap<PathBuf, SystemTime> {
files
}
fn is_tracked_reload_path(path: &Path, roots: &[PathBuf], options: HotReloadOptions) -> bool {
(options.python && py_path_to_module_name(path, roots).is_some())
|| (options.json_ui && is_json_ui_path(path, roots))
}
fn is_json_ui_path(file_path: &Path, mod_roots: &[PathBuf]) -> bool {
let is_json = file_path
.extension()
.and_then(|ext| ext.to_str())
.map(|ext| ext.eq_ignore_ascii_case("json"))
.unwrap_or(false);
if !is_json {
return false;
}
let Some(parent) = file_path.parent() else {
return false;
};
for ancestor in parent.ancestors() {
let is_ui_dir = ancestor
.file_name()
.and_then(|name| name.to_str())
.map(|name| name.eq_ignore_ascii_case("ui"))
.unwrap_or(false);
if !is_ui_dir {
continue;
}
let Some(pack_root) = ancestor.parent() else {
continue;
};
let under_tracked_root = mod_roots
.iter()
.any(|root| same_path(root, pack_root) || pack_root.strip_prefix(root).is_ok());
if !under_tracked_root {
continue;
}
if matches!(
addon::parse_pack_info(pack_root),
Ok(Some(info)) if info.pack_type == PackType::Resource
) {
return true;
}
}
false
}
pub fn py_path_to_module_name(file_path: &Path, mod_roots: &[PathBuf]) -> Option<String> {
if file_path.extension().and_then(|ext| ext.to_str()) != Some("py") {
return None;
@@ -484,30 +642,224 @@ fn foreground_process_id() -> Option<u32> {
#[cfg(test)]
mod tests {
use std::fs;
use std::{
fs,
path::{Path, PathBuf},
time::{Duration, Instant, SystemTime, UNIX_EPOCH},
};
use super::py_path_to_module_name;
use serde_json::json;
use super::{
DEBOUNCE_MS, DebouncedPaths, HotReloadOptions, ReloadAction, build_reload_batch,
is_json_ui_path, py_path_to_module_name, reload_actions,
};
struct TempProject {
path: PathBuf,
}
impl TempProject {
fn new() -> Self {
let nonce = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_nanos();
let path = std::env::temp_dir().join(format!(
"emod-hot-reload-test-{}-{nonce}",
std::process::id()
));
fs::create_dir_all(&path).unwrap();
Self { path }
}
}
impl Drop for TempProject {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.path);
}
}
fn create_pack(project: &Path, name: &str, module_type: &str) -> PathBuf {
let pack = project.join(name);
fs::create_dir_all(&pack).unwrap();
let manifest = json!({
"header": {
"name": name,
"uuid": "00000000-0000-0000-0000-000000000001",
"version": [1, 0, 0]
},
"modules": [{
"type": module_type,
"uuid": "00000000-0000-0000-0000-000000000002",
"version": [1, 0, 0]
}]
});
fs::write(
pack.join("pack_manifest.json"),
serde_json::to_vec(&manifest).unwrap(),
)
.unwrap();
pack
}
#[test]
fn maps_py_file_to_module_name_under_manifest() {
let root = std::env::temp_dir().join(format!("emod-hot-{}", std::process::id()));
let pack = root.join("behavior_pack");
let project = TempProject::new();
let pack = create_pack(&project.path, "behavior_pack", "data");
let module = pack.join("foo/bar.py");
fs::create_dir_all(module.parent().unwrap()).unwrap();
fs::write(pack.join("manifest.json"), "{}").unwrap();
fs::write(&module, "").unwrap();
assert_eq!(
py_path_to_module_name(&module, std::slice::from_ref(&root)),
py_path_to_module_name(&module, std::slice::from_ref(&project.path)),
Some("foo.bar".to_string())
);
let outside = root.join("x.py");
let outside = project.path.join("x.py");
fs::write(&outside, "").unwrap();
assert_eq!(
py_path_to_module_name(&outside, std::slice::from_ref(&root)),
py_path_to_module_name(&outside, std::slice::from_ref(&project.path)),
None
);
}
let _ = fs::remove_dir_all(root);
#[test]
fn recognizes_only_resource_pack_json_ui_files() {
let project = TempProject::new();
let resource = create_pack(&project.path, "resource_pack", "resources");
let behavior = create_pack(&project.path, "behavior_pack", "data");
let roots = std::slice::from_ref(&project.path);
let screen = resource.join("ui/screen.json");
let nested = resource.join("ui/widgets/_global_variables.json");
let defs = resource.join("UI/_ui_defs.JSON");
let removed = resource.join("ui/removed.json");
let texture_json = resource.join("textures/ui.json");
let nested_texture_json = resource.join("textures/ui/icons.json");
let mcgui = resource.join("ui/screen.mcgui");
let behavior_ui = behavior.join("ui/screen.json");
let mcp_state = project.path.join(".emod-cli/debug-mcp.json");
fs::create_dir_all(nested.parent().unwrap()).unwrap();
fs::create_dir_all(defs.parent().unwrap()).unwrap();
fs::write(&screen, "{}").unwrap();
fs::write(&nested, "{}").unwrap();
fs::write(&defs, "{}").unwrap();
fs::write(&removed, "{}").unwrap();
fs::remove_file(&removed).unwrap();
assert!(is_json_ui_path(&screen, roots));
assert!(is_json_ui_path(&nested, roots));
assert!(is_json_ui_path(&defs, roots));
assert!(is_json_ui_path(&removed, roots));
assert!(is_json_ui_path(&screen, std::slice::from_ref(&resource)));
assert!(!is_json_ui_path(&texture_json, roots));
assert!(!is_json_ui_path(&nested_texture_json, roots));
assert!(!is_json_ui_path(&mcgui, roots));
assert!(!is_json_ui_path(&behavior_ui, roots));
assert!(!is_json_ui_path(&mcp_state, roots));
let (excluded, tracked) = build_reload_batch(
vec![
texture_json,
nested_texture_json,
mcgui,
behavior_ui,
mcp_state,
],
roots,
HotReloadOptions {
python: false,
json_ui: true,
},
);
assert!(excluded.is_empty());
assert!(tracked.is_empty());
let (disabled, tracked) =
build_reload_batch(vec![screen], roots, HotReloadOptions::default());
assert!(disabled.is_empty());
assert!(tracked.is_empty());
}
#[test]
fn batches_python_and_json_ui_changes_together() {
let project = TempProject::new();
let behavior = create_pack(&project.path, "behavior_pack", "data");
let resource = create_pack(&project.path, "resource_pack", "resources");
let python = behavior.join("scripts/client.py");
let screen = resource.join("ui/screen.json");
fs::create_dir_all(python.parent().unwrap()).unwrap();
fs::create_dir_all(screen.parent().unwrap()).unwrap();
fs::write(&python, "").unwrap();
fs::write(&screen, "{}").unwrap();
let (batch, tracked) = build_reload_batch(
vec![screen, python],
std::slice::from_ref(&project.path),
HotReloadOptions {
python: true,
json_ui: true,
},
);
assert_eq!(tracked.len(), 2);
assert_eq!(
reload_actions(batch),
vec![
ReloadAction::Python(vec!["scripts.client".to_string()]),
ReloadAction::JsonUi,
]
);
}
#[test]
fn uses_global_trailing_edge_debounce() {
let start = Instant::now();
let mut paths = DebouncedPaths::default();
paths.push(PathBuf::from("ui/screen.json"), start);
paths.push(
PathBuf::from("ui/screen.json"),
start + Duration::from_millis(50),
);
paths.push(
PathBuf::from("ui/_ui_defs.json"),
start + Duration::from_millis(100),
);
assert!(
paths
.take_ready(start + Duration::from_millis(100 + DEBOUNCE_MS - 1))
.is_empty()
);
assert_eq!(
paths
.take_ready(start + Duration::from_millis(100 + DEBOUNCE_MS))
.len(),
2
);
assert!(
paths
.take_ready(start + Duration::from_millis(100 + DEBOUNCE_MS * 2))
.is_empty()
);
}
#[cfg(windows)]
#[test]
fn accepts_windows_content_and_name_change_actions() {
use windows_sys::Win32::Storage::FileSystem::{
FILE_ACTION_ADDED, FILE_ACTION_MODIFIED, FILE_ACTION_REMOVED,
FILE_ACTION_RENAMED_NEW_NAME, FILE_ACTION_RENAMED_OLD_NAME,
};
for action in [
FILE_ACTION_ADDED,
FILE_ACTION_MODIFIED,
FILE_ACTION_REMOVED,
FILE_ACTION_RENAMED_OLD_NAME,
FILE_ACTION_RENAMED_NEW_NAME,
] {
assert!(super::is_supported_file_action(action));
}
}
}

1
src/debug/nbt.rs
View File

@@ -457,6 +457,7 @@ mod tests {
auto_join_game: true,
include_debug_mod: true,
auto_hot_reload_mods: true,
auto_hot_reload_ui: false,
world_type: 1,
game_mode: 1,
enable_cheats: true,

44
src/debug/process.rs
View File

@@ -4,7 +4,7 @@ use crate::error::{CliError, Result};
use super::{
config::{DebugConfig, ResolvedModDir},
hotreload::HotReloadTask,
hotreload::{HotReloadOptions, HotReloadTask},
ipc::DebugIpcServer,
log::{self, LineBuffer},
};
@@ -52,9 +52,13 @@ pub fn launch_game(
let command = build_command(config, config_arg);
let mut command_w = wide_null(OsStr::new(&command));
let env_block = ipc
.as_ref()
.map(|server| build_environment_block(server.port()));
let env_block = if ipc.is_some() || config.auto_hot_reload_ui {
Some(build_environment_block(
ipc.as_ref().map(|server| server.port()),
))
} else {
None
};
let mut security = SECURITY_ATTRIBUTES {
nLength: std::mem::size_of::<SECURITY_ATTRIBUTES>() as u32,
@@ -116,12 +120,15 @@ pub fn launch_game(
let stderr_thread =
thread::spawn(move || read_pipe(err_read, stderr_filter, log::process_stderr_line));
let mut hotreload = if config.auto_hot_reload_mods {
ipc.clone()
.and_then(|server| HotReloadTask::start(pid, mod_dirs, server))
} else {
None
};
let mut hotreload = HotReloadTask::start(
pid,
mod_dirs,
ipc.clone(),
HotReloadOptions {
python: config.auto_hot_reload_mods,
json_ui: config.auto_hot_reload_ui,
},
);
unsafe { WaitForSingleObject(process_info.hProcess, INFINITE) };
@@ -223,14 +230,21 @@ where
}
#[cfg(windows)]
fn build_environment_block(ipc_port: u16) -> Vec<u16> {
fn build_environment_block(ipc_port: Option<u16>) -> Vec<u16> {
let mut pairs: Vec<(Vec<u16>, Vec<u16>)> = std::env::vars_os()
.filter(|(key, _)| {
let key = key.to_string_lossy();
!key.eq_ignore_ascii_case("MCDEV_DEBUG_IPC_PORT")
})
.map(|(key, value)| (key.encode_wide().collect(), value.encode_wide().collect()))
.collect();
pairs.push((
OsStr::new("MCDEV_DEBUG_IPC_PORT").encode_wide().collect(),
OsStr::new(&ipc_port.to_string()).encode_wide().collect(),
));
if let Some(port) = ipc_port {
pairs.push((
OsStr::new("MCDEV_DEBUG_IPC_PORT").encode_wide().collect(),
OsStr::new(&port.to_string()).encode_wide().collect(),
));
}
pairs.sort_by(|a, b| a.0.cmp(&b.0));
let mut block = Vec::new();

126
src/debug/win.rs
View File

@@ -10,6 +10,12 @@ use windows_sys::Win32::{
CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT, OPEN_EXISTING,
},
System::IO::DeviceIoControl,
UI::{
Input::KeyboardAndMouse::{MAPVK_VK_TO_VSC, MapVirtualKeyW, VK_CONTROL},
WindowsAndMessaging::{
GetForegroundWindow, GetWindowThreadProcessId, PostMessageW, WM_KEYDOWN, WM_KEYUP,
},
},
};
#[cfg(windows)]
@@ -148,6 +154,89 @@ pub fn create_junction(target: &Path, link: &Path) -> io::Result<()> {
}
}
#[cfg(windows)]
pub fn trigger_ui_reload_shortcut(process_id: u32) -> io::Result<()> {
let window = unsafe { GetForegroundWindow() };
if window.is_null() {
return Err(io::Error::new(
io::ErrorKind::WouldBlock,
"当前没有前台窗口，无法向 Minecraft 发送 Ctrl+R",
));
}
let mut foreground_process_id = 0u32;
let foreground_thread_id =
unsafe { GetWindowThreadProcessId(window, &mut foreground_process_id) };
if foreground_thread_id == 0 {
return Err(io::Error::new(
io::ErrorKind::Other,
"无法读取当前前台窗口的进程 ID",
));
}
if foreground_process_id != process_id {
return Err(io::Error::new(
io::ErrorKind::WouldBlock,
format!(
"Minecraft 不在前台：期望 PID {process_id}，当前前台 PID {foreground_process_id}"
),
));
}
let [ctrl_down, r_down, r_up, ctrl_up] = ui_reload_key_messages();
post_key_message(window, ctrl_down)?;
if let Err(err) = post_key_message(window, r_down) {
let _ = post_key_message(window, ctrl_up);
return Err(err);
}
let r_up_result = post_key_message(window, r_up);
let ctrl_up_result = post_key_message(window, ctrl_up);
r_up_result?;
ctrl_up_result?;
Ok(())
}
#[cfg(windows)]
fn ui_reload_key_messages() -> [(u32, u32, bool); 4] {
let control = u32::from(VK_CONTROL);
[
(WM_KEYDOWN, control, false),
(WM_KEYDOWN, u32::from(b'R'), false),
(WM_KEYUP, u32::from(b'R'), true),
(WM_KEYUP, control, true),
]
}
#[cfg(windows)]
fn post_key_message(
window: *mut std::ffi::c_void,
key_message: (u32, u32, bool),
) -> io::Result<()> {
let (message, key, key_up) = key_message;
let posted = unsafe {
PostMessageW(
window,
message,
key as usize,
key_message_lparam(key, key_up),
)
};
if posted == 0 {
return Err(io::Error::last_os_error());
}
Ok(())
}
#[cfg(windows)]
fn key_message_lparam(key: u32, key_up: bool) -> isize {
let scan_code = unsafe { MapVirtualKeyW(key, MAPVK_VK_TO_VSC) };
let mut value = 1isize | ((scan_code as isize) << 16);
if key_up {
value |= (1isize << 30) | (1isize << 31);
}
value
}
#[cfg(not(windows))]
pub fn create_junction(_target: &Path, _link: &Path) -> io::Result<()> {
Err(io::Error::new(
@@ -155,3 +244,40 @@ pub fn create_junction(_target: &Path, _link: &Path) -> io::Result<()> {
"debug launch is only supported on Windows",
))
}
#[cfg(not(windows))]
pub fn trigger_ui_reload_shortcut(_process_id: u32) -> io::Result<()> {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"debug launch is only supported on Windows",
))
}
#[cfg(all(test, windows))]
mod tests {
use windows_sys::Win32::UI::{
Input::KeyboardAndMouse::VK_CONTROL,
WindowsAndMessaging::{WM_KEYDOWN, WM_KEYUP},
};
use super::{key_message_lparam, ui_reload_key_messages};
#[test]
fn ui_reload_shortcut_uses_native_ctrl_r_order() {
let control = u32::from(VK_CONTROL);
assert_eq!(
ui_reload_key_messages(),
[
(WM_KEYDOWN, control, false),
(WM_KEYDOWN, u32::from(b'R'), false),
(WM_KEYUP, u32::from(b'R'), true),
(WM_KEYUP, control, true),
]
);
let r_down = key_message_lparam(u32::from(b'R'), false) as usize;
let r_up = key_message_lparam(u32::from(b'R'), true) as usize;
assert_eq!((r_down >> 30) & 0b11, 0);
assert_eq!((r_up >> 30) & 0b11, 0b11);
}
}