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 <noreply@anthropic.com>
This commit is contained in:
@@ -819,6 +819,8 @@ struct Game<'a> {
|
||||
/// This world is open to the network (game/lan.rs).
|
||||
lan: Option<lan::LanHost>,
|
||||
world_options: Option<lan_screen::WorldOptions>,
|
||||
/// 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<Hit>,
|
||||
/// 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,
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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()
|
||||
}
|
||||
|
||||
@@ -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<String, i32> {
|
||||
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:<rule>": 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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user