Persist forced chunks across world restarts
Co-Authored-By: Codex GPT-6.1 Sol <noreply@openai.com>
This commit is contained in:
@@ -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)));
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user