Skip to content

Minecraft: Java Edition 26.3 rewritten from scratch in Rust, checked against vanilla with 281 differential harnesses. Get it with the Horizon launcher.

Fusion packs: connection predicates

some-du6ed7896df7d8ea
diff --git a/crates/horizon-optifine/src/fusion.rs b/crates/horizon-optifine/src/fusion.rs
index 287a86ffb..db00d1ab4 100644
--- a/crates/horizon-optifine/src/fusion.rs
+++ b/crates/horizon-optifine/src/fusion.rs
@@ -1,7 +1,7 @@
//! Fusion's resource pack format (the Fusion Connected Textures mod): a `fusion` section in a
//! texture's `.mcmeta` (`texture`: connecting, random, continuous and scrolling textures, and
//! the emissive, render type and tinting options every type takes), the connection predicates
-//! that say when a connecting texture joins a neighbour (`predicate`), the `connections` of a
+//! that say when a connecting texture joins a neighbour ([`predicate`]), the `connections` of a
//! `fusion:connecting` block model (`model`), and which tiles of a connecting texture's image a
//! face draws ([`layout`]).
//!
@@ -13,5 +13,22 @@
//! Fusion itself is all rights reserved: none of its code was read.
pub mod layout;
+pub mod predicate;
pub use layout::{Layout, Tiles};
+pub use predicate::Connection;
+
+use crate::cem::json::Json;
+
+/// A type name without the `fusion:` namespace packs may give it (`fusion:connecting`).
+fn kind(name: &str) -> &str {
+ name.strip_prefix("fusion:").unwrap_or(name)
+}
+
+fn str_field<'a>(json: &'a Json, key: &str) -> Result<Option<&'a str>, String> {
+ match json.get(key) {
+ None => Ok(None),
+ Some(Json::Str(s)) => Ok(Some(s)),
+ Some(_) => Err(format!("`{key}` is not a string")),
+ }
+}
diff --git a/crates/horizon-optifine/src/fusion/predicate.rs b/crates/horizon-optifine/src/fusion/predicate.rs
new file mode 100644
index 000000000..1b04713bc
--- /dev/null
+++ b/crates/horizon-optifine/src/fusion/predicate.rs
@@ -0,0 +1,316 @@
+//! Connection predicates: whether a connecting texture joins the neighbour in one of the eight
+//! directions of its face. Each direction is tested on its own, and the true ones make the
+//! face's [`crate::ctm::connect`] mask.
+//!
+//! The predicate's block lists are `B`: [`BlockMatch`]es as parsed, which the game turns into
+//! whatever it tests block states with ([`Connection::map_blocks`]). What a test reads of the
+//! world, the game answers ([`Connection::joins`]).
+
+use super::kind;
+use crate::BlockMatch;
+use crate::cem::json::Json;
+use crate::ctm::connect::{D, DL, DR, L, R, U, UL, UR};
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Connection<B = Vec<BlockMatch>> {
+ /// `is_same_block`: the neighbour is the same block.
+ SameBlock,
+ /// `is_same_state`: the same block in the same state.
+ SameState,
+ /// `match_block`, `match_state`: the neighbour is one of these.
+ Neighbour(B),
+ /// `match_block_in_front`, `match_state_in_front`: the block in front of the neighbour (on
+ /// the side the face looks out of) is one of these.
+ InFront(B),
+ /// `is_direction`: the direction is one of these mask bits.
+ Direction(u8),
+ /// `is_face_visible`: the neighbour's face on this side isn't covered.
+ FaceVisible,
+ And(Vec<Connection<B>>),
+ Or(Vec<Connection<B>>),
+ Not(Box<Connection<B>>),
+ Const(bool),
+}
+
+/// A test only the world answers, for one direction.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Query<'a, B> {
+ SameBlock,
+ SameState,
+ Neighbour(&'a B),
+ InFront(&'a B),
+ FaceVisible,
+}
+
+/// Directions in the texture's terms, as mask bits.
+fn direction(name: &str) -> Option<u8> {
+ Some(match name {
+ "top" => U,
+ "top_right" => UR,
+ "right" => R,
+ "bottom_right" => DR,
+ "bottom" => D,
+ "bottom_left" => DL,
+ "left" => L,
+ "top_left" => UL,
+ _ => return None,
+ })
+}
+
+/// `one` or `many` of a field: a string or an array of them.
+fn names<'a>(json: &'a Json, one: &str, many: &str) -> Result<Vec<&'a str>, String> {
+ let value = json
+ .get(one)
+ .or_else(|| json.get(many))
+ .ok_or_else(|| format!("no `{one}` or `{many}`"))?;
+ let items = match value {
+ Json::Arr(items) => &items[..],
+ single => std::slice::from_ref(single),
+ };
+ items
+ .iter()
+ .map(|v| {
+ v.as_str()
+ .ok_or_else(|| format!("`{many}` holds a non-string"))
+ })
+ .collect()
+}
+
+/// `block`/`blocks`, each with `properties` (a value or an array of values per property) when
+/// `states` is set.
+fn blocks(json: &Json, states: bool) -> Result<Vec<BlockMatch>, String> {
+ let mut properties = Vec::new();
+ if states && let Some(map) = json.get("properties") {
+ for (key, values) in map.as_object().ok_or("`properties` is not an object")? {
+ let values = match values {
+ Json::Arr(items) => &items[..],
+ single => std::slice::from_ref(single),
+ };
+ let values = values
+ .iter()
+ .map(|v| match v {
+ Json::Str(s) => Ok(s.clone()),
+ Json::Bool(b) => Ok(b.to_string()),
+ Json::Num(n) => Ok(n.to_string()),
+ _ => Err(format!("property `{key}` has a value that isn't one")),
+ })
+ .collect::<Result<_, String>>()?;
+ properties.push((key.clone(), values));
+ }
+ }
+ Ok(names(json, "block", "blocks")?
+ .into_iter()
+ .map(|name| BlockMatch {
+ id: crate::matchers::namespaced(name),
+ states: properties.clone(),
+ })
+ .collect())
+}
+
+impl Connection {
+ /// A predicate, or an array of them that joins when any does (a texture's or a model's
+ /// `connections`).
+ pub fn parse(json: &Json) -> Result<Self, String> {
+ if let Some(items) = json.as_array() {
+ return Ok(Self::Or(Self::parse_all(items)?));
+ }
+ let ty = super::str_field(json, "type")?.ok_or("a predicate without a `type`")?;
+ let list = |key: &str| match json.get(key).and_then(Json::as_array) {
+ Some(items) => Self::parse_all(items),
+ None => Err(format!("`{ty}` without a `{key}` array")),
+ };
+ Ok(match kind(ty) {
+ "is_same_block" => Self::SameBlock,
+ "is_same_state" => Self::SameState,
+ "match_block" => Self::Neighbour(blocks(json, false)?),
+ "match_state" => Self::Neighbour(blocks(json, true)?),
+ "match_block_in_front" => Self::InFront(blocks(json, false)?),
+ "match_state_in_front" => Self::InFront(blocks(json, true)?),
+ "is_direction" => Self::Direction(
+ names(json, "direction", "directions")?
+ .into_iter()
+ .map(|d| direction(d).ok_or_else(|| format!("unknown direction `{d}`")))
+ .try_fold(0, |mask, bit| bit.map(|b| mask | b))?,
+ ),
+ "is_face_visible" => Self::FaceVisible,
+ "and" => Self::And(list("predicates")?),
+ "or" => Self::Or(list("predicates")?),
+ "not" => Self::Not(Box::new(Self::parse(
+ json.get("predicate").ok_or("`not` without a `predicate`")?,
+ )?)),
+ "true" => Self::Const(true),
+ "false" => Self::Const(false),
+ other => return Err(format!("unknown connection predicate `{other}`")),
+ })
+ }
+
+ fn parse_all(items: &[Json]) -> Result<Vec<Self>, String> {
+ items.iter().map(Self::parse).collect()
+ }
+}
+
+impl<B> Connection<B> {
+ /// The same predicate with its block lists turned into `C`s.
+ pub fn map_blocks<C>(self, f: &mut impl FnMut(B) -> C) -> Connection<C> {
+ let all =
+ |items: Vec<Self>, f: &mut _| items.into_iter().map(|p| p.map_blocks(f)).collect();
+ match self {
+ Self::SameBlock => Connection::SameBlock,
+ Self::SameState => Connection::SameState,
+ Self::Neighbour(b) => Connection::Neighbour(f(b)),
+ Self::InFront(b) => Connection::InFront(f(b)),
+ Self::Direction(d) => Connection::Direction(d),
+ Self::FaceVisible => Connection::FaceVisible,
+ Self::And(items) => Connection::And(all(items, f)),
+ Self::Or(items) => Connection::Or(all(items, f)),
+ Self::Not(p) => Connection::Not(Box::new(p.map_blocks(f))),
+ Self::Const(c) => Connection::Const(c),
+ }
+ }
+
+ /// Whether the face joins toward `direction` (one mask bit), `world` answering the tests
+ /// about the neighbour there. `and` and `or` stop at their first deciding predicate.
+ pub fn joins(&self, direction: u8, world: &mut impl FnMut(Query<'_, B>) -> bool) -> bool {
+ match self {
+ Self::SameBlock => world(Query::SameBlock),
+ Self::SameState => world(Query::SameState),
+ Self::Neighbour(b) => world(Query::Neighbour(b)),
+ Self::InFront(b) => world(Query::InFront(b)),
+ Self::Direction(d) => d & direction != 0,
+ Self::FaceVisible => world(Query::FaceVisible),
+ Self::And(items) => items.iter().all(|p| p.joins(direction, world)),
+ Self::Or(items) => items.iter().any(|p| p.joins(direction, world)),
+ Self::Not(p) => !p.joins(direction, world),
+ Self::Const(c) => *c,
+ }
+ }
+
+ /// The mask of the eight directions that join, `world` answering for the direction it is
+ /// given.
+ pub fn mask(&self, mut world: impl FnMut(u8, Query<'_, B>) -> bool) -> u8 {
+ [U, UR, R, DR, D, DL, L, UL]
+ .into_iter()
+ .filter(|&bit| self.joins(bit, &mut |q| world(bit, q)))
+ .fold(0, |mask, bit| mask | bit)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn parse(text: &str) -> Connection {
+ Connection::parse(&Json::parse(text).unwrap()).unwrap()
+ }
+
+ #[test]
+ fn parses_every_predicate() {
+ let p = parse(
+ r#"[
+ {"type": "fusion:is_same_block"},
+ {"type": "match_state", "blocks": ["redstone_torch", "create:lamp"],
+ "properties": {"lit": "false", "facing": ["north", "south"]}},
+ {"type": "and", "predicates": [
+ {"type": "match_block_in_front", "block": "Sand"},
+ {"type": "not", "predicate": {"type": "is_direction", "directions": ["top", "bottom_left"]}},
+ {"type": "is_face_visible"}, {"type": "true"}
+ ]}
+ ]"#,
+ );
+ let states = vec![
+ ("lit".to_owned(), vec!["false".to_owned()]),
+ (
+ "facing".to_owned(),
+ vec!["north".to_owned(), "south".to_owned()],
+ ),
+ ];
+ assert_eq!(
+ p,
+ Connection::Or(vec![
+ Connection::SameBlock,
+ Connection::Neighbour(vec![
+ BlockMatch {
+ id: "minecraft:redstone_torch".into(),
+ states: states.clone(),
+ },
+ BlockMatch {
+ id: "create:lamp".into(),
+ states,
+ },
+ ]),
+ Connection::And(vec![
+ Connection::InFront(vec![BlockMatch {
+ id: "minecraft:sand".into(),
+ states: vec![],
+ }]),
+ Connection::Not(Box::new(Connection::Direction(U | DL))),
+ Connection::FaceVisible,
+ Connection::Const(true),
+ ]),
+ ])
+ );
+ // `match_block` has no properties to test.
+ assert_eq!(
+ parse(r#"{"type": "match_block", "block": "stone", "properties": {"a": "b"}}"#),
+ Connection::Neighbour(vec![BlockMatch {
+ id: "minecraft:stone".into(),
+ states: vec![],
+ }])
+ );
+ }
+
+ #[test]
+ fn refuses_what_it_cannot_read() {
+ for bad in [
+ r#"{"type": "is_same_thing"}"#,
+ r#"{"block": "stone"}"#,
+ r#"{"type": "match_block"}"#,
+ r#"{"type": "is_direction", "direction": "up"}"#,
+ r#"{"type": "and", "predicates": {"type": "true"}}"#,
+ r#"{"type": "not"}"#,
+ ] {
+ assert!(
+ Connection::parse(&Json::parse(bad).unwrap()).is_err(),
+ "{bad}"
+ );
+ }
+ }
+
+ #[test]
+ fn masks_from_the_world() {
+ // Block transitions' sand edge: sand beside the face, or sand in front of the
+ // neighbour, but only where the neighbour's face shows.
+ let p = parse(
+ r#"{"type": "or", "predicates": [
+ {"type": "match_block_in_front", "block": "sand"},
+ {"type": "and", "predicates": [
+ {"type": "match_block", "block": "sand"}, {"type": "is_face_visible"}]}
+ ]}"#,
+ );
+ // Sand to the right, its face covered; sand in front of the neighbour above.
+ let mask = p.mask(|dir, q| match q {
+ Query::Neighbour(_) => dir == R,
+ Query::InFront(_) => dir == U,
+ Query::FaceVisible => false,
+ _ => unreachable!("not in the predicate"),
+ });
+ assert_eq!(mask, U);
+ // `is_direction` needs no world; `not` and `and` combine it.
+ let p = parse(
+ r#"{"type": "and", "predicates": [{"type": "is_same_state"},
+ {"type": "not", "predicate": {"type": "is_direction", "direction": "left"}}]}"#,
+ );
+ assert_eq!(
+ p.mask(|_, q| q == Query::SameState),
+ 0xff & !L,
+ "joins everywhere but left"
+ );
+ }
+
+ #[test]
+ fn map_blocks_keeps_the_shape() {
+ let p = parse(r#"{"type": "not", "predicate": {"type": "match_block", "block": "dirt"}}"#);
+ let mapped = p.map_blocks(&mut |b: Vec<BlockMatch>| b.len());
+ assert_eq!(mapped, Connection::Not(Box::new(Connection::Neighbour(1))));
+ }
+}