vintage_schematics/formats/

sponge.rs

//! Sponge schematic format support.

use std::{fmt::Formatter, io::Read};

use eyre::{Context, OptionExt};
use serde::{
	Deserialize, Deserializer, Serialize, Serializer,
	de::{MapAccess, Visitor},
};
use tracing::warn;

use crate::{
	Map,
	entity::parse_seven_bit_int,
	formats::{
		Loadable, ToInternal,
		common::{FLATTENING_VERSION, MODERNISED_BLOCKS, MinecraftBlockData, MinecraftBlockEntity, Size},
		internal::{Block, BlockCodes, Internal, MinecraftBlockCode},
		read, should_reject,
	},
};

/// Sponge schematic format.
///
/// <https://github.com/SpongePowered/Schematic-Specification/blob/master/versions/schematic-3.md>
// we're ignoring a lot of fields here:
// - metadata: contains author name, creation date, etc. we don't care
// - data version: the version of minecraft this schematic was created from. this might end up being relevant later!
// - offset: [x, y, z] ints to add/subtract from the "paste" location. vintage story has no equivalent concept afaict
// - biomes: don't care
// - entities: mobs and such. don't care
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Sponge {
	/// Sponge schematic version.
	/// Only version 3 is currently supported.
	version: i32,

	/// Schematic size.
	#[serde(flatten)]
	size: Size,

	/// Block data.
	blocks: SpongeBlocks,

	/// The version of Minecraft this schematic was created from.
	data_version: i32,
}

/// Sponge schematic block data.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct SpongeBlocks {
	/// Palette mapping of block IDs and properties to indices.
	///
	/// Block properties are encoded as a square-bracketed list of comma-separated `key=value` pairs.
	/// For example, a wheat block with an `age` of `3` is represented as `minecraft:wheat[age=3]`.
	palette: SpongePalette,

	/// Indices into the palette encoded in the
	/// ["varint" format](https://minecraft.wiki/w/Java_Edition_protocol/VarInt_and_VarLong) (aka
	/// [LEB128](https://en.wikipedia.org/wiki/LEB128)).
	///
	/// Entries are indexed by `x + z * Width + y * Width * Length`.
	data: Vec<u8>,

	/// Sponge block entities.
	#[serde(default)]
	entities: Vec<SpongeBlockEntity>,
}

/// Sponge palette type.
/// Palette entries must maintain their insertion order, so we need to store them as a Vec<(K, V)> rather than a
/// Map<K, V>.
#[derive(Debug, Clone)]
struct SpongePalette(Vec<(String, i32)>);

impl<'de> Deserialize<'de> for SpongePalette {
	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
	where
		D: Deserializer<'de>,
	{
		deserializer.deserialize_map(SpongePaletteVisitor)
	}
}

impl Serialize for SpongePalette {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
		S: Serializer,
	{
		serializer.collect_map(self.0.iter().map(|(key, value)| (key, value)))
	}
}

/// [Visitor](https://serde.rs/impl-deserialize.html#the-visitor-trait) for [`SpongePalette`] deserialisation.
struct SpongePaletteVisitor;

impl<'de> Visitor<'de> for SpongePaletteVisitor {
	type Value = SpongePalette;

	fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result { write!(formatter, "a compound value") }

	fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
	where
		A: MapAccess<'de>,
	{
		let mut out = Vec::with_capacity(map.size_hint().unwrap_or_default());
		while let Some((key, value)) = map.next_entry()? {
			out.push((key, value));
		}
		Ok(SpongePalette(out.into_iter().collect()))
	}
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct SpongeBlockEntity {
	// we don't care about the ID because it's duplicated in the `data` field
	// id: String,
	/// This tile entity's position.
	pos: (i32, i32, i32),

	/// Associated entity data.
	data: MinecraftBlockData,
}

/// Wrapper for the Sponge schematic format.
///
/// Sponge files are saved as a [compound](mininbt::Compound) with a single field named `Schematic`.
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct SpongeWrapper {
	/// The actual schematic data.
	schematic: Sponge,
}

impl Loadable for Sponge {
	fn load(reader: impl Read, compressed: bool) -> eyre::Result<Self>
	where
		Self: Sized,
	{
		let schematic: SpongeWrapper = read(reader, compressed).context("failed to load schematic")?;
		let mut schematic = schematic.schematic;

		if schematic.version != 3 {
			warn!("unsupported schematic version: {}", schematic.version);
		}

		schematic.modernise();

		Ok(schematic)
	}

	fn modernise(&mut self) {
		let replace = |current: &String| {
			if let Some((current, properties)) = current.split_once('[') {
				if let Some((_, new)) = MODERNISED_BLOCKS.iter().find(|(old, _)| *old == current) {
					Some((String::from(current), format!("{new}[{properties}")))
				} else {
					None
				}
			} else if let Some((_, new)) = MODERNISED_BLOCKS.iter().find(|(old, _)| *old == current) {
				Some((current.clone(), new.to_string()))
			} else {
				None
			}
		};

		if self.data_version < FLATTENING_VERSION {
			let replacements: Vec<_> = self.blocks.palette.0.iter().map(|(k, _)| k).filter_map(replace).collect();
			for (old, new) in replacements {
				if let Some(entry) = self.blocks.palette.0.iter_mut().find(|(k, _)| *k == old) {
					entry.0 = new;
				}
			}
		}
	}
}

impl ToInternal for Sponge {
	fn to_internal(self) -> eyre::Result<Internal> {
		// iterator over encoded block IDs
		let mut block_bytes = self.blocks.data.into_iter();

		// - new block IDs, where `None` means the block should be rejected
		// - converted block codes
		let (ids, block_codes): (Vec<Option<u16>>, BlockCodes) = {
			let mut ids = Vec::with_capacity(self.blocks.palette.0.len());
			let mut block_codes = Vec::with_capacity(self.blocks.palette.0.len());

			let mut current_id = 0;
			for (name, _) in self.blocks.palette.0 {
				let code = parse_sponge_name(&name).context("failed to parse block code")?;

				if should_reject(&code) {
					ids.push(None);
				} else {
					ids.push(Some(current_id));
					block_codes.push(code);
					current_id += 1;
				}
			}

			(ids, BlockCodes::Minecraft(block_codes))
		};

		// size of the schematic in blocks
		let size = self.size.blocks();

		// internal blocks
		#[allow(clippy::cast_sign_loss)]
		let mut blocks = Vec::with_capacity(size as usize);

		for i in 0..size {
			// TODO: ensure we haven't run out of bytes?

			// get "old" block id
			#[allow(clippy::cast_sign_loss)]
			let block = parse_seven_bit_int(&mut block_bytes)? as usize;

			// look up the new ID, continue if the block was rejected
			let Some(id) = ids[block] else { continue };
			let id = id as usize;

			let position = self.size.index_position(i);

			blocks.push(Block { id, position });
		}

		// convert tile entities
		let tile_entities = self
			.blocks
			.entities
			.into_iter()
			.map(|e| MinecraftBlockEntity {
				id: e.data.id,
				x: e.pos.0,
				y: e.pos.1,
				z: e.pos.2,
				components: e.data.components,
			})
			.collect();

		Ok(Internal {
			block_codes,
			blocks,
			tile_entities,
			size: self.size.into(),
		})
	}
}

fn parse_sponge_name(name: &str) -> eyre::Result<MinecraftBlockCode> {
	let mut new_properties = Map::new();

	let name = if let Some((name, properties)) = name.split_once('[') {
		// `minecraft:block[key=value]`
		#[cfg_attr(not(feature = "color-eyre"), allow(unused_mut))]
		let mut parsed = properties.strip_suffix(']').ok_or_eyre("malformed block properties: missing terminating bracket");

		#[cfg(feature = "color-eyre")]
		{
			use color_eyre::{Help, SectionExt};
			parsed = parsed.with_section(|| properties.to_string().header("Properties:"));
		}

		let properties = parsed?;

		// add properties to map
		for pair in properties.split(',') {
			#[cfg_attr(not(feature = "color-eyre"), allow(unused_mut))]
			let mut parsed = pair.split_once('=').ok_or_eyre("malformed block properties: missing equals delimiter");

			#[cfg(feature = "color-eyre")]
			{
				use color_eyre::{Help, SectionExt};
				parsed = parsed.with_section(|| pair.to_string().header("Property:"));
			}

			let (key, value) = parsed?;
			new_properties.insert(key.to_string(), value.to_string());
		}

		name
	} else {
		// plain old `minecraft:block`
		name
	};

	Ok(MinecraftBlockCode {
		name: name.to_string(),
		properties: new_properties,
	})
}