Support for schematics file format

Cargo.toml

@@ -22,6 +22,7 @@ default = [
     "player_list",
     "scoreboard",
     "world_border",
+    "schem",
     "weather",
     "testing",
 ]
@@ -34,6 +35,7 @@ network = ["dep:valence_network"]
 player_list = ["dep:valence_player_list"]
 scoreboard = ["dep:valence_scoreboard"]
 world_border = ["dep:valence_world_border"]
+schem = ["dep:valence_schem"]
 weather = ["dep:valence_weather"]
 testing = []
 
@@ -56,6 +58,7 @@ valence_registry.workspace = true
 valence_scoreboard = { workspace = true, optional = true }
 valence_weather = { workspace = true, optional = true }
 valence_world_border = { workspace = true, optional = true }
+valence_schem = { workspace = true, optional = true }
 valence_lang.workspace = true
 valence_text.workspace = true
 valence_ident.workspace = true
@@ -169,6 +172,7 @@ uuid = "1.3.1"
 valence = { path = ".", version = "0.2.0-alpha.1" }
 valence_advancement = { path = "crates/valence_advancement", version = "0.2.0-alpha.1" }
 valence_anvil = { path = "crates/valence_anvil", version = "0.2.0-alpha.1" }
+valence_schem = { path = "crates/valence_schem", version = "0.2.0-alpha.1" }
 valence_boss_bar = { path = "crates/valence_boss_bar", version = "0.2.0-alpha.1" }
 valence_build_utils = { path = "crates/valence_build_utils", version = "0.2.0-alpha.1" }
 valence_entity = { path = "crates/valence_entity", version = "0.2.0-alpha.1" }

crates/valence_generated/Cargo.toml

@@ -12,6 +12,7 @@ build = "build/main.rs"
 [dependencies]
 valence_math.workspace = true
 valence_ident.workspace = true
+thiserror.workspace = true
 
 [build-dependencies]
 anyhow.workspace = true

crates/valence_generated/src/block.rs

@@ -3,7 +3,9 @@
 use std::fmt;
 use std::fmt::Display;
 use std::iter::FusedIterator;
+use std::str::FromStr;
 
+use thiserror::Error;
 use valence_ident::{ident, Ident};
 
 use crate::item::ItemKind;
@@ -48,6 +50,53 @@ fn fmt_block_state(bs: BlockState, f: &mut fmt::Formatter) -> fmt::Result {
     }
 }
 
+#[derive(Debug, Error, PartialEq, Eq)]
+pub enum ParseBlockStateError {
+    #[error("unknown block kind '{0}'")]
+    UnknownBlockKind(String),
+    #[error("invalid prop string '{0}'")]
+    InvalidPropString(String),
+    #[error("unknown prop name '{0}'")]
+    UnknownPropName(String),
+    #[error("unknown prop value '{0}'")]
+    UnknownPropValue(String),
+}
+
+impl FromStr for BlockState {
+    type Err = ParseBlockStateError;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        let state = match s.split_once('[') {
+            Some((kind, props)) => {
+                let Some(kind) = BlockKind::from_str(kind) else {
+                    return Err(ParseBlockStateError::UnknownBlockKind(kind.to_string()));
+                };
+                props[..props.len() - 1]
+                    .split(',')
+                    .map(|prop| prop.trim())
+                    .try_fold(kind.to_state(), |state, prop| {
+                        let Some((name, val)) = prop.split_once('=') else {
+                            return Err(ParseBlockStateError::InvalidPropString(prop.to_string()));
+                        };
+                        let Some(name) = PropName::from_str(name) else {
+                            return Err(ParseBlockStateError::UnknownPropName(name.to_string()));
+                        };
+                        let Some(val) = PropValue::from_str(val) else {
+                            return Err(ParseBlockStateError::UnknownPropValue(val.to_string()));
+                        };
+                        Ok(state.set(name, val))
+                    })?
+            }
+            None => match BlockKind::from_str(s) {
+                Some(kind) => kind.to_state(),
+                None => return Err(ParseBlockStateError::UnknownBlockKind(s.to_string())),
+            },
+        };
+
+        Ok(state)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/valence_schem/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "valence_schem"
+description = "A library for the Sponge Schematic Format."
+documentation.workspace = true
+repository = "https://github.com/valence-rs/valence/tree/main/crates/valence_schem"
+readme = "README.md"
+license.workspace = true
+keywords = ["schematics", "minecraft", "deserialization"]
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+flate2.workspace = true
+glam.workspace = true
+thiserror.workspace = true
+valence_server.workspace = true
+valence_nbt = {workspace = true, features = ["valence_ident"]}
+
+[dev-dependencies]
+valence.workspace = true

crates/valence_schem/README.md

@@ -0,0 +1,43 @@
+# valence_schem
+
+Support for the [Sponge schematic file format](https://github.com/SpongePowered/Schematic-Specification).
+
+This crate implements [Sponge schematics]
+
+Loading schematics (version 1 through 3) from [`Compounds`](Compound) is
+supported. Saving schematics to [`Compounds`](Compound) (version 3 only) is
+supported.
+
+# Examples
+
+An example that shows how to load and save [schematics] from and to the
+filesystem
+
+```rust
+# use valence_schem::Schematic;
+use flate2::Compression;
+fn schem_from_file(path: &str) -> Schematic {
+    Schematic::load(path).unwrap()
+}
+fn schem_to_file(schematic: &Schematic, path: &str) {
+    schematic.save(path);
+}
+```
+
+There are also methods to serialize and deserialize [schematics] from and to
+[`Compounds`](Compound):
+```rust
+# use valence_schem::Schematic;
+use valence_nbt::Compound;
+fn schem_from_compound(compound: &Compound) {
+    let schematic = Schematic::deserialize(compound).unwrap();
+    let comp = schematic.serialize();
+}
+```
+
+### See also
+
+Examples in the `examples/` directory
+
+[Sponge schematics]: <https://github.com/SpongePowered/Schematic-Specification>
+[schematics]: Schematic