Persist forced chunks across world restarts

Co-Authored-By: Codex GPT-6.1 Sol <noreply@openai.com>
This commit is contained in:
rdbtCVS
2026-10-26 07:45:35 +00:00
parent c58af30ca6
commit 66f32a7a3a
5 changed files with 218 additions and 1 deletions
+2
View File
@@ -7968,6 +7968,7 @@ impl Game<'_> {
/// (scaled coordinates, or the End portal's fixed destination).
pub(super) fn switch_level(&mut self, target: Dim, from: Vec3) -> Result<Vec3> {
// Save the departing dimension's changed chunks.
self.save.save_forced_chunks(&self.streaming.forced)?;
self.streaming.save(&mut self.world, true);
let keys: Vec<_> = self.world.modified.drain().collect();
let chunks = self.with_entities(keys.iter().filter_map(|k| self.world.chunks.get(k)));
@@ -10082,6 +10083,7 @@ impl Game<'_> {
}
/// Save the level in place: its changed chunks, its entities and its raids.
fn save_level(&mut self, wait: bool) -> Result<()> {
self.save.save_forced_chunks(&self.streaming.forced)?;
self.streaming.save(&mut self.world, wait);
let keys: Vec<_> = self.world.modified.drain().collect();
let chunks = self.with_entities(keys.iter().filter_map(|k| self.world.chunks.get(k)));
+1
View File
@@ -179,6 +179,7 @@ impl Game<'_> {
if keys.is_empty() {
self.prune_entity_memory();
self.save_raids();
self.save.save_forced_chunks(&self.streaming.forced)?;
self.save_game_metadata()?;
save.stage = Stage::Writes;
}
@@ -261,6 +261,7 @@ pub(super) fn make_streaming(
res.threads(),
)
};
streaming.forced = save.load_forced_chunks();
streaming.radius = settings.render_distance;
streaming.biome_blend = settings.biome_blend;
streaming.smooth_lighting = settings.smooth_lighting;
+104 -1
View File
@@ -36,7 +36,7 @@ use horizon_world::{
worldgen::terrain::TerrainBlockStates,
};
use std::{
collections::{BTreeMap, HashMap},
collections::{BTreeMap, HashMap, HashSet},
fs,
path::{Path, PathBuf},
sync::{
@@ -1613,6 +1613,9 @@ pub struct SaveDir {
/// False in dimensions without skylight (no SkyLight layers are written).
pub sky_light: bool,
}
fn is_forced_ticket(ticket: &Tag) -> bool {
matches!(ticket.get("type"), Some(Tag::String(t)) if *t == JavaString::from("minecraft:forced"))
}
impl SaveDir {
pub fn new(root: PathBuf) -> Self {
let sky_light = !root.ends_with("the_nether") && !root.ends_with("DIM-1");
@@ -1628,6 +1631,50 @@ impl SaveDir {
sky_light,
}
}
/// 26.3's TicketStorage: persistent tickets live in each dimension's
/// data/minecraft/chunk_tickets.dat, with ChunkPos.CODEC's [x, z] int array.
pub fn load_forced_chunks(&self) -> HashSet<(i32, i32)> {
let Some(data) = read_saved_data(&self.root, "chunk_tickets") else {
return HashSet::new();
};
let Some(Tag::List(tickets)) = data.get("tickets") else {
return HashSet::new();
};
tickets
.iter()
.filter(|t| is_forced_ticket(t))
.filter_map(|t| match t.get("chunk_pos")? {
Tag::IntArray(pos) if pos.len() == 2 => Some((pos[0], pos[1])),
_ => None,
})
.collect()
}
pub fn save_forced_chunks(&self, forced: &HashSet<(i32, i32)>) -> Result<()> {
if forced.is_empty() && !saved_data_path(&self.root, "chunk_tickets").exists() {
return Ok(());
}
let mut data = compound_or_empty(read_saved_data(&self.root, "chunk_tickets"));
// Preserve persistent tickets Horizon does not simulate.
let mut tickets = match data.get("tickets") {
Some(Tag::List(tickets)) => tickets
.iter()
.filter(|t| !is_forced_ticket(t))
.cloned()
.collect::<Vec<_>>(),
_ => Vec::new(),
};
let mut chunks: Vec<_> = forced.iter().copied().collect();
chunks.sort_unstable();
tickets.extend(chunks.into_iter().map(|(x, z)| {
Tag::compound([
("type", Tag::String("minecraft:forced".into())),
("level", Tag::Int(31)), // ChunkMap.FORCED_TICKET_LEVEL: ENTITY_TICKING.
("chunk_pos", Tag::IntArray(vec![x, z])),
])
}));
put(&mut data, "tickets", Tag::List(tickets));
write_saved_data(&self.root, "chunk_tickets", data)
}
fn region_path(&self, folder: &str, rx: i32, rz: i32) -> PathBuf {
region_path(&self.root, folder, rx, rz)
}
@@ -3436,6 +3483,62 @@ impl<G: ChunkGenerator> ChunkGenerator for Persistent<G> {
#[cfg(test)]
mod tests {
#[test]
fn forced_chunks_survive_dimension_restarts_and_removals() {
let root = std::env::temp_dir().join(format!("horizon-forced-{}", std::process::id()));
let _ = fs::remove_dir_all(&root);
let dimensions = [
"minecraft:overworld",
"minecraft:the_nether",
"minecraft:the_end",
];
for (i, dim) in dimensions.iter().enumerate() {
let save = SaveDir::new(dimension_dir(&root, dim));
assert!(save.load_forced_chunks().is_empty());
let forced = HashSet::from([(i as i32, -17), (-23, i as i32), (-1, -1)]);
save.save_forced_chunks(&forced).unwrap();
}
for (i, dim) in dimensions.iter().enumerate() {
let path = dimension_dir(&root, dim);
let save = SaveDir::new(path.clone());
let mut forced = save.load_forced_chunks();
assert_eq!(
forced,
HashSet::from([(i as i32, -17), (-23, i as i32), (-1, -1)])
);
let mut data = read_saved_data(&path, "chunk_tickets").unwrap();
let other = Tag::compound([
("type", Tag::String("minecraft:portal".into())),
("level", Tag::Int(30)),
("chunk_pos", Tag::IntArray(vec![7, -8])),
("ticks_left", Tag::Long(42)),
]);
if let Some(Tag::List(tickets)) = data.get_mut("tickets") {
assert!(
tickets
.iter()
.all(|t| t.get("level") == Some(&Tag::Int(31)))
);
tickets.push(other.clone());
}
write_saved_data(&path, "chunk_tickets", data).unwrap();
forced.remove(&(-1, -1));
save.save_forced_chunks(&forced).unwrap();
drop(save);
let reopened = SaveDir::new(path.clone());
assert_eq!(reopened.load_forced_chunks(), forced);
reopened.save_forced_chunks(&HashSet::new()).unwrap();
assert!(SaveDir::new(path.clone()).load_forced_chunks().is_empty());
assert_eq!(
read_saved_data(&path, "chunk_tickets")
.unwrap()
.get("tickets"),
Some(&Tag::List(vec![other]))
);
}
fs::remove_dir_all(root).unwrap();
}
#[test]
fn saved_far_surface_reads_builds_and_water_without_gameplay_chunks() {
let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES") else {
+110
View File
@@ -0,0 +1,110 @@
#!/usr/bin/env python3
"""Check #1527: per-dimension /forceload add/remove across normal restarts.
Build horizon-client and horizon-ctl with the fast profile first, then run:
python3 tools/singleplayer_forced_chunks_audit.py --case force-save
Runs both default server-thread and in-frame singleplayer, using scratch homes.
"""
import argparse
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import time
from agent_control_e2e import Cli
import lab
DIMENSIONS = ('the_nether', 'the_end', 'overworld')
def query(cli, dimension, expected):
since = cli('events')['last']
cli('command', command='forceload query')
deadline = time.monotonic() + 15
while time.monotonic() < deadline:
reply = cli('events', since=since)
for event in reply['events']:
text = event.get('text', '')
if event.get('event') != 'chat' or f'minecraft:{dimension}' not in text:
continue
if expected:
if all(f'[{x}, {z}]' in text for x, z in expected):
return
elif 'No force loaded chunks' in text:
return
time.sleep(0.1)
raise AssertionError(f'{dimension}: expected {expected}, got {reply}')
def run(bin_dir, resources, in_frame):
with tempfile.TemporaryDirectory(prefix='hz-force-save-') as scratch:
work = Path(scratch)
previous = None
for stage in range(3):
# Every process gets fresh homes; copy only this fixture's saved world.
env = lab.game_env({k: v for k, v in os.environ.items() if k not in (
'HORIZON_HOME', 'HORIZON_LAUNCHER_HOME', 'XDG_DATA_HOME', 'XDG_CONFIG_HOME')})
home = Path(env['HORIZON_HOME'])
if previous is not None:
shutil.copytree(previous, home / 'saves')
socket = work / f'{stage}.sock'
cli = Cli(bin_dir / 'horizon-ctl', socket, home, env)
args = [str(bin_dir / 'horizon-client'), '--resources', str(resources),
'--world', 'forced', '--creative', '--seed', '4242', '--offscreen',
'--render-distance', '4', '--control', '--control-socket', str(socket)]
if in_frame:
args.append('--in-frame')
with (work / f'{stage}.log').open('w') as log:
process = subprocess.Popen(args, cwd=home, env=env, stdout=log, stderr=log)
try:
deadline = time.monotonic() + 120
while not socket.exists():
if process.poll() is not None or time.monotonic() > deadline:
raise RuntimeError('game did not open its control socket')
time.sleep(0.1)
cli('wait_ready', seconds=240)
for i, dim in enumerate(DIMENSIONS):
cli('command', command=f'execute in minecraft:{dim} run tp @s 0 100 0')
for _ in range(30):
cli('wait', ticks=20)
if cli('state').get('dimension') == f'minecraft:{dim}':
break
else:
raise AssertionError(f'did not enter {dim}')
cli('wait_ready', seconds=240)
expected = [(i - 1, -1)] if stage == 1 else []
query(cli, dim, expected)
if stage == 0:
cli('command', command=f'forceload add {(i - 1) * 16} -1')
query(cli, dim, [(i - 1, -1)])
elif stage == 1:
cli('command', command=f'forceload remove {(i - 1) * 16} -1')
query(cli, dim, [])
cli('quit')
assert process.wait(timeout=120) == 0
except Exception:
log.flush()
print((work / f'{stage}.log').read_text(errors='replace')[-6000:])
raise
finally:
if process.poll() is None:
process.terminate()
process.wait(timeout=30)
previous = home / 'saves'
print(f'PASS force-save: {"in-frame" if in_frame else "server-thread"}, three dimensions, add/remove/restart')
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--case', choices=['force-save'], default='force-save')
parser.add_argument('--bin-dir', type=Path, default=Path(__file__).resolve().parents[1] / 'target/fast')
args = parser.parse_args()
for in_frame in (False, True):
run(args.bin_dir.resolve(), lab.RESOURCES.resolve(), in_frame)
if __name__ == '__main__':
main()