2ef155348f
desktop_seams.rs holds the launcher's two hard-to-undo desktop effects. HORIZON_LAUNCHER_TRASH=<folder> makes Delete (worlds, screenshots, packs) move into that folder instead of the system's trash, and HORIZON_LAUNCHER_CLIPBOARD=<file> makes every Copy in the window write into that file instead of the clipboard. Test runs set both inside their scratch folders. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
261 lines
9.4 KiB
Rust
261 lines
9.4 KiB
Rust
//! An instance's single-player worlds (`saves/` in its game folder): what each is, and backing
|
|
//! up, copying and deleting them. Backups are made as vanilla's Make Backup makes them
|
|
//! (`LevelStorageAccess.makeWorldBackup`): `backups/<yyyy-MM-dd_HH-mm-ss>_<folder>.zip` in the
|
|
//! game folder, every file under `<folder>/` but the world's `session.lock`.
|
|
use horizon_world::nbt::{self, Limits, Tag};
|
|
use std::fs;
|
|
use std::io::{Read, Write};
|
|
use std::path::{Path, PathBuf};
|
|
use std::time::{Duration, SystemTime, UNIX_EPOCH};
|
|
|
|
/// The lock a running game holds on a world; vanilla's backups leave it out.
|
|
const LOCK: &str = "session.lock";
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct World {
|
|
/// Its folder's name under `saves/`, the id commands take.
|
|
pub folder: String,
|
|
pub path: PathBuf,
|
|
/// `LevelName`, else the folder's name.
|
|
pub name: String,
|
|
/// Survival, Creative, Adventure, Spectator or Hardcore.
|
|
pub mode: &'static str,
|
|
/// `LastPlayed`, else when level.dat changed.
|
|
pub last_played: SystemTime,
|
|
/// The version that last saved it (`Version.Name`).
|
|
pub version: Option<String>,
|
|
/// Bytes on disk, every file in its folder.
|
|
pub size: u64,
|
|
/// `icon.png`, the picture the game took of it.
|
|
pub icon: Option<PathBuf>,
|
|
}
|
|
|
|
/// The worlds in a game folder's `saves/`, the last played first.
|
|
pub fn list(home: &Path) -> Vec<World> {
|
|
let mut worlds: Vec<World> = fs::read_dir(home.join("saves"))
|
|
.into_iter()
|
|
.flatten()
|
|
.flatten()
|
|
.filter_map(|e| read(&e.path()))
|
|
.collect();
|
|
worlds.sort_by_key(|w| std::cmp::Reverse(w.last_played));
|
|
worlds
|
|
}
|
|
|
|
/// level.dat: gzip, as vanilla writes it, or plain.
|
|
fn level_dat(path: &Path) -> Option<Tag> {
|
|
let bytes = fs::read(path).ok()?;
|
|
let mut raw = Vec::new();
|
|
let raw = match flate2::read::GzDecoder::new(&bytes[..])
|
|
.take(64 << 20)
|
|
.read_to_end(&mut raw)
|
|
{
|
|
Ok(_) => raw,
|
|
Err(_) => bytes,
|
|
};
|
|
Some(nbt::read_named(&raw, Limits::default()).ok()?.0.tag)
|
|
}
|
|
|
|
fn read(path: &Path) -> Option<World> {
|
|
let dat = path.join("level.dat");
|
|
let changed = fs::metadata(&dat).and_then(|m| m.modified()).ok()?;
|
|
let folder = path.file_name()?.to_string_lossy().into_owned();
|
|
let root = level_dat(&dat);
|
|
let data = root.as_ref().and_then(|r| r.get("Data"));
|
|
let field = |key: &str| data.and_then(|d| d.get(key));
|
|
let number = |tag: Option<&Tag>| match tag {
|
|
Some(Tag::Byte(v)) => i64::from(*v),
|
|
Some(Tag::Int(v)) => i64::from(*v),
|
|
Some(Tag::Long(v)) => *v,
|
|
_ => 0,
|
|
};
|
|
let text = |tag: Option<&Tag>| match tag {
|
|
Some(Tag::String(s)) => Some(s.to_string_lossy()),
|
|
_ => None,
|
|
};
|
|
// 26.3 keeps hardcore with the difficulty; older saves at the top of Data.
|
|
let hardcore = number(field("difficulty_settings").and_then(|d| d.get("hardcore"))) != 0
|
|
|| number(field("hardcore")) != 0;
|
|
let mode = match (hardcore, number(field("GameType"))) {
|
|
(true, _) => "Hardcore",
|
|
(_, 1) => "Creative",
|
|
(_, 2) => "Adventure",
|
|
(_, 3) => "Spectator",
|
|
_ => "Survival",
|
|
};
|
|
let last_played = match number(field("LastPlayed")) {
|
|
millis if millis > 0 => UNIX_EPOCH + Duration::from_millis(millis as u64),
|
|
_ => changed,
|
|
};
|
|
let icon = path.join("icon.png");
|
|
Some(World {
|
|
name: text(field("LevelName"))
|
|
.filter(|n| !n.trim().is_empty())
|
|
.unwrap_or_else(|| folder.clone()),
|
|
folder,
|
|
path: path.to_path_buf(),
|
|
mode,
|
|
last_played,
|
|
version: text(field("Version").and_then(|v| v.get("Name"))),
|
|
size: size(path),
|
|
icon: icon.is_file().then_some(icon),
|
|
})
|
|
}
|
|
|
|
fn size(dir: &Path) -> u64 {
|
|
fs::read_dir(dir)
|
|
.into_iter()
|
|
.flatten()
|
|
.flatten()
|
|
.map(|e| match e.file_type() {
|
|
Ok(t) if t.is_dir() => size(&e.path()),
|
|
Ok(_) => e.metadata().map_or(0, |m| m.len()),
|
|
Err(_) => 0,
|
|
})
|
|
.sum()
|
|
}
|
|
|
|
/// The world in `home` a command names: its folder, or its name (any case).
|
|
pub fn find(home: &Path, query: &str) -> Result<World, String> {
|
|
let all = list(home);
|
|
all.iter()
|
|
.find(|w| w.folder == query)
|
|
.or_else(|| all.iter().find(|w| w.name.eq_ignore_ascii_case(query)))
|
|
.cloned()
|
|
.ok_or_else(|| format!("No world {query} in {}", home.join("saves").display()))
|
|
}
|
|
|
|
/// `base`, else `base (1)`, `base (2)`... from the `first` count: the first name free in `dir`
|
|
/// (vanilla's `FileUtil.findAvailableName`, after making the name safe for every file system).
|
|
fn free_name(dir: &Path, base: &str, suffix: &str, first: u32) -> String {
|
|
let safe: String = base
|
|
.chars()
|
|
.map(|c| match c {
|
|
'/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
|
|
c if c.is_control() => '_',
|
|
c => c,
|
|
})
|
|
.collect();
|
|
let safe = safe.trim_matches(|c: char| c == '.' || c.is_whitespace());
|
|
let safe = if safe.is_empty() { "World" } else { safe };
|
|
(first..)
|
|
.map(|n| match n {
|
|
0 => format!("{safe}{suffix}"),
|
|
n => format!("{safe} ({n}){suffix}"),
|
|
})
|
|
.find(|name| !dir.join(name).exists())
|
|
.unwrap()
|
|
}
|
|
|
|
/// Zips the world into the game folder's `backups/`, as vanilla's Make Backup does. Returns the
|
|
/// zip's path.
|
|
pub fn backup(home: &Path, world: &World) -> Result<PathBuf, String> {
|
|
backup_at(home, world, chrono::Local::now())
|
|
}
|
|
|
|
fn backup_at(
|
|
home: &Path,
|
|
world: &World,
|
|
now: chrono::DateTime<chrono::Local>,
|
|
) -> Result<PathBuf, String> {
|
|
let dir = home.join("backups");
|
|
fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
|
|
let prefix = format!("{}_{}", now.format("%Y-%m-%d_%H-%M-%S"), world.folder);
|
|
let zip_path = dir.join(free_name(&dir, &prefix, ".zip", 0));
|
|
let made = (|| -> std::io::Result<()> {
|
|
let mut zip = zip::ZipWriter::new(std::io::BufWriter::new(fs::File::create(&zip_path)?));
|
|
let options = zip::write::SimpleFileOptions::default()
|
|
.compression_method(zip::CompressionMethod::Deflated)
|
|
.large_file(true);
|
|
let mut stack = vec![world.path.clone()];
|
|
while let Some(dir) = stack.pop() {
|
|
let mut entries: Vec<_> = fs::read_dir(&dir)?.collect::<Result<_, _>>()?;
|
|
entries.sort_by_key(|e| e.file_name());
|
|
for e in entries {
|
|
let path = e.path();
|
|
if e.file_type()?.is_dir() {
|
|
stack.push(path);
|
|
continue;
|
|
}
|
|
if path.file_name() == Some(LOCK.as_ref()) {
|
|
continue;
|
|
}
|
|
let relative = path.strip_prefix(&world.path).unwrap_or(&path);
|
|
let mut entry = world.folder.clone();
|
|
for part in relative.components() {
|
|
entry.push('/');
|
|
entry.push_str(&part.as_os_str().to_string_lossy());
|
|
}
|
|
zip.start_file(entry, options)?;
|
|
std::io::copy(&mut fs::File::open(&path)?, &mut zip)?;
|
|
}
|
|
}
|
|
zip.finish()?.flush()
|
|
})();
|
|
made.map(|()| zip_path.clone()).map_err(|e| {
|
|
let _ = fs::remove_file(&zip_path);
|
|
format!("Could not back up {}: {e}", world.name)
|
|
})
|
|
}
|
|
|
|
/// Copies the world into a new folder of the same `saves/`, named "<name> (1)", "<name> (2)"...
|
|
/// and gives the copy that name in its level.dat so the game's list tells them apart.
|
|
pub fn copy(world: &World) -> Result<World, String> {
|
|
let saves = world.path.parent().ok_or("A world folder has a parent")?;
|
|
let folder = free_name(saves, &world.name, "", 1);
|
|
let to = saves.join(&folder);
|
|
let made = copy_dir(&world.path, &to).and_then(|()| rename_level(&to, &folder));
|
|
if let Err(e) = made {
|
|
let _ = fs::remove_dir_all(&to);
|
|
return Err(format!("Could not copy {}: {e}", world.name));
|
|
}
|
|
read(&to).ok_or_else(|| format!("{} has no level.dat", to.display()))
|
|
}
|
|
|
|
fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
|
|
fs::create_dir_all(to)?;
|
|
for e in fs::read_dir(from)? {
|
|
let e = e?;
|
|
let target = to.join(e.file_name());
|
|
if e.file_type()?.is_dir() {
|
|
copy_dir(&e.path(), &target)?;
|
|
} else if e.file_name() != LOCK {
|
|
fs::copy(e.path(), target)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Sets `Data.LevelName`; a level.dat that can't be read is left as it is.
|
|
fn rename_level(world: &Path, name: &str) -> std::io::Result<()> {
|
|
let dat = world.join("level.dat");
|
|
let Some(mut root) = level_dat(&dat) else {
|
|
return Ok(());
|
|
};
|
|
let Some(Tag::Compound(data)) = root.get_mut("Data") else {
|
|
return Ok(());
|
|
};
|
|
data.insert("LevelName".into(), Tag::String(name.into()));
|
|
let bytes = nbt::write_named(
|
|
&nbt::NamedTag {
|
|
name: "".into(),
|
|
tag: root,
|
|
},
|
|
Limits::default(),
|
|
)
|
|
.map_err(std::io::Error::other)?;
|
|
let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
|
|
gz.write_all(&bytes)?;
|
|
fs::write(dat, gz.finish()?)
|
|
}
|
|
|
|
/// Moves the world to the system's trash, where the player can still get it back.
|
|
pub fn delete(world: &World) -> Result<(), String> {
|
|
crate::desktop_seams::to_trash(&world.path)
|
|
.map_err(|e| format!("Could not move {} to the trash: {e}", world.name))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[path = "worlds/tests.rs"]
|
|
mod tests;
|