From 9bbb674184d4a92823db37ee2ebb4cce14311931 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Wed, 14 Oct 2026 15:16:32 +0200 Subject: [PATCH] Game rules: save them with the world once, as they are now; save on Quit Game rules lived twice: Level (loaded when the world opened, written to data/minecraft/game_rules.dat by Level::write) and the rules the game and /gamerule use. Every save wrote the file first with the rules loaded at open, then again with the current ones; a failed second write (on Windows a file just renamed into place can be held briefly by the indexer or an antivirus) was only logged, leaving the old rules on disk, so the world opened with them again. - sync_level copies the current rules into Level, and Level::write is the only writer of game_rules.dat (written as vanilla writes saved data: `_new`, then renamed over the old file). - The world is saved when the application ends without a window close (ApplicationHandler::exiting): on macOS, Quit (Cmd+Q) ends the application through applicationWillTerminate, while vanilla's GLFW window turns it into a window close and Minecraft.stop saves the world. Window close, `horizon-ctl quit` and exiting share save_for_exit, which saves once. Tests: a unit test writes changed rules through Level::write and reads them back (GameRules::load and Level::read); the save round-trip harness has Horizon's player change a rule with /gamerule before saving and requires the new value in the world vanilla then loads. Fixes #74 Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 35 ++++++++++++++++----- crates/horizon-client/src/game/chat.rs | 7 ++--- crates/horizon-client/src/game/control.rs | 9 +----- crates/horizon-client/src/gamerules.rs | 37 +++++++++++++++++++++++ tools/test_save_roundtrip_parity.py | 14 ++++++++- 5 files changed, 82 insertions(+), 20 deletions(-) diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index 56af58e7d..4984b13c6 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -819,6 +819,8 @@ struct Game<'a> { /// This world is open to the network (game/lan.rs). lan: Option, world_options: Option, + /// The world was saved for the application ending (`save_for_exit`). + saved_for_exit: bool, /// The block a guest is acting on (game/lan_actions.rs). forced_hit: Option, /// Level events of this tick for the guests, and the guest acting now. @@ -5714,6 +5716,20 @@ impl Game<'_> { } Ok(()) } + /// Leaving the game with a world open (window closed, Quit, `quit`): + /// menu items go back (Player.closeContainer), then the world is saved, + /// once. + pub(super) fn save_for_exit(&mut self) -> Result<()> { + if self.title.is_some() || self.saved_for_exit { + return Ok(()); + } + self.saved_for_exit = true; + self.close_container(); + if self.remote.is_none() { + self.stats.custom("leave_game", 1); + } + self.save_game() + } fn close_world(&mut self) -> Result<()> { self.ambience.clear(&mut self.audio); // updateLevelInEngines(null): every sound stops; the music manager @@ -7113,6 +7129,8 @@ impl Game<'_> { } /// Copy the live player and world state into the `Level` that gets saved. pub(super) fn sync_level(&mut self) { + // Level.write saves the game rules (game_rules.dat) with the rest. + self.level.game_rules = self.ui.rules.by_name(); self.level.selected_slot = self.selected as i32; let mode = self.mode_id(); let level = &mut self.level; @@ -7824,13 +7842,7 @@ impl ApplicationHandler for Game<'_> { let result: Result<()> = (|| { match event { WindowEvent::CloseRequested => { - if self.title.is_none() { - self.close_container(); - if self.remote.is_none() { - self.stats.custom("leave_game", 1); - } - self.save_game()?; - } + self.save_for_exit()?; event_loop.exit(); } WindowEvent::Resized(size) => { @@ -8344,6 +8356,14 @@ impl ApplicationHandler for Game<'_> { } event_loop.set_control_flow(ControlFlow::Poll); } + /// The application is ending. On macOS, Quit (Cmd+Q) ends it through + /// applicationWillTerminate without a CloseRequested; vanilla's GLFW + /// window turns it into a window close, so Minecraft.stop saves the world. + fn exiting(&mut self, _event_loop: &ActiveEventLoop) { + if let Err(e) = self.save_for_exit() { + eprintln!("Horizon: failed to save the world on exit: {e}"); + } + } } pub fn run() -> Result<()> { let Some(mut options) = Options::read()? else { @@ -8699,6 +8719,7 @@ pub fn run() -> Result<()> { remote: None, lan: None, world_options: None, + saved_for_exit: false, forced_hit: None, lan_events: Vec::new(), lan_acting: None, diff --git a/crates/horizon-client/src/game/chat.rs b/crates/horizon-client/src/game/chat.rs index d560df45e..0e063abc2 100644 --- a/crates/horizon-client/src/game/chat.rs +++ b/crates/horizon-client/src/game/chat.rs @@ -642,14 +642,13 @@ impl Game<'_> { self.build_registries(); self.sync_rules(); } - /// Save game rules, the clock and the difficulty beside level.dat. + /// Save the clock and the difficulty beside level.dat (Level.write saves + /// the game rules: a second writer of game_rules.dat could leave it with + /// the rules loaded when the world opened). pub(super) fn save_world_state(&mut self) { if self.world_root.as_os_str().is_empty() { return; } - if let Err(e) = self.ui.rules.save(&self.world_root) { - eprintln!("Horizon: failed to save game rules: {e}"); - } use horizon_world::nbt::Tag; let c = self.ui.clock; // The other clocks stay as saved; the overworld one keeps the fields Horizon diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index 0522bef10..1e299bbd3 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -480,14 +480,7 @@ impl Game<'_> { ok() } "quit" => { - if self.title.is_none() { - // Player.closeContainer: menu items go back before saving. - self.close_container(); - if self.remote.is_none() { - self.stats.custom("leave_game", 1); - } - self.save_game()?; - } + self.save_for_exit()?; event_loop.exit(); ok() } diff --git a/crates/horizon-client/src/gamerules.rs b/crates/horizon-client/src/gamerules.rs index 92815e908..20bc9fcba 100644 --- a/crates/horizon-client/src/gamerules.rs +++ b/crates/horizon-client/src/gamerules.rs @@ -164,6 +164,20 @@ impl GameRules { } ok } + /// Every rule's value by name without namespace, as `save::Level` holds + /// them (booleans as 0 or 1). + pub fn by_name(&self) -> BTreeMap { + RULES + .iter() + .map(|r| { + let v = match self.values.get(r.name).copied().unwrap_or(r.default) { + Value::Bool(b) => i32::from(b), + Value::Int(i) => i, + }; + (r.name.to_owned(), v) + }) + .collect() + } /// GameRuleMap codec: `{data: {"minecraft:": value...}, DataVersion}`. pub fn to_nbt(&self) -> NamedTag { let data: Vec<(horizon_world::nbt::JavaString, Tag)> = RULES @@ -253,4 +267,27 @@ mod tests { assert_eq!(GameRules::load(&dir), rules); let _ = fs::remove_dir_all(dir); } + /// The world's save (Level.write) writes the rules as they are now, and a + /// world opened again reads them back (#74). + #[test] + fn level_save_keeps_changed_rules() { + let dir = + std::env::temp_dir().join(format!("horizon-gamerules-level-{}", std::process::id())); + let _ = fs::remove_dir_all(&dir); + let mut level = crate::save::Level::default(); + level.write(&dir).unwrap(); + // Rules changed while playing, then saved and loaded again. + let mut rules = GameRules::load(&dir); + assert_eq!(rules, GameRules::default()); + assert!(rules.set("advance_time", Value::Bool(false))); + assert!(rules.set("advance_weather", Value::Bool(false))); + assert!(rules.set("random_tick_speed", Value::Int(0))); + level.game_rules = rules.by_name(); + level.write(&dir).unwrap(); + assert_eq!(GameRules::load(&dir), rules); + let read = crate::save::Level::read(&dir).unwrap(); + assert_eq!(read.game_rules, rules.by_name()); + assert_eq!(read.game_rule("advance_time"), 0); + let _ = fs::remove_dir_all(dir); + } } diff --git a/tools/test_save_roundtrip_parity.py b/tools/test_save_roundtrip_parity.py index 317956a40..7c1cbaa6a 100644 --- a/tools/test_save_roundtrip_parity.py +++ b/tools/test_save_roundtrip_parity.py @@ -46,6 +46,10 @@ SERVER = LOCAL / 'minecraft' / '26.3' / 'jars' / 'server.jar' RUN = LOCAL / 'save-roundtrip' / 'run' PORT = 25000 + (os.getpid() % 5000) + 1000 +# Game rules Horizon's player changes before saving: rule -> (vanilla's value, Horizon's). +# The new value must be in Horizon's save, and nothing else may differ (#74). +HORIZON_RULES = {'max_entity_cramming': (24, 30)} + # Differences that do not change what vanilla reads: path pattern (list indices as []) # -> reason. Anything else is a failure. IGNORED = { @@ -335,7 +339,9 @@ def horizon_resave(source, destination, bin_dir): print(launch.stdout.strip()) if launch.returncode: sys.exit('horizon failed to launch: ' + launch.stdout + launch.stderr) - steps = [['wait-ready', '240'], ['save-all'], ['quit']] + steps = [['wait-ready', '240']] + steps += [['chat', f'/gamerule {rule} {new}'] for rule, (_, new) in HORIZON_RULES.items()] + steps += [['save-all'], ['quit']] for step in steps: result = subprocess.run(ctl + step, cwd=destination, env=env, capture_output=True, text=True) print(' '.join(step), '->', result.stdout.strip() or result.stderr.strip()) @@ -545,6 +551,12 @@ def compare_worlds(vanilla, horizon): if rel.endswith('scoreboard.dat'): va, hb = normalize_scoreboard(va), normalize_scoreboard(hb) compare_dat(rel, va, hb, report) + for rule, (old, new) in HORIZON_RULES.items(): + changed = (f'data/minecraft/game_rules.dat.data.minecraft:{rule}', old, new) + if changed in report: + report.remove(changed) + else: + report.append((changed[0], f'{new} set in Horizon', 'not saved')) return report