vintage_schematics/convert/

block.rs

//! Block conversion logic.

use std::{
	borrow::Cow,
	sync::{LazyLock, Mutex},
};

use tracing::{trace, warn};

use crate::{
	Map, Regex,
	convert::{
		determine_orientation, material,
		material::{convert_wood, is_stone, is_tree},
		mods::Mod,
		orientation_to_radians, reverse_orientation,
	},
	entity::Value,
	formats::{
		Settings,
		internal::{EntityMap, MinecraftBlockCode, PropertyMap},
	},
};

// The maximum fluid depth level in Vintage Story.
const MAX_FLUID: u8 = 7;

/// The maximum snow layers in Minecraft.
const MAX_SNOW: u8 = 8;

/// The number of inventory slots in a Vintage Story chest.
pub(crate) const VS_CHEST_SLOTS: i32 = 16;

/// The number of inventory slots in a Vintage Story trunk.
pub(crate) const VS_TRUNK_SLOTS: i32 = 36;

pub(crate) const VS_FLOWER_POT_CODE: &str = "game:flowerpot-red-fired";

/// Crop conversion data.
struct CropData {
	/// This crop's Vintage Story name.
	name: &'static str,

	/// The maximum age of this crop in Minecraft.
	mc_max_age: u8,

	/// The maximum age of this crop in Vintage Story.
	vs_max_age: u8,
}

/// Mapping of Minecraft crop names to [`CropData`] structs.
static CROPS: LazyLock<Map<&'static str, CropData>> = LazyLock::new(|| {
	// TODO: all the other crops!

	Map::from([
		(
			"carrots",
			CropData {
				name: "carrot",
				mc_max_age: 7,
				vs_max_age: 7,
			},
		),
		(
			"potatoes",
			CropData {
				name: "parsnip",
				mc_max_age: 7,
				vs_max_age: 8,
			},
		),
		(
			"wheat",
			CropData {
				name: "spelt",
				mc_max_age: 7,
				vs_max_age: 9,
			},
		),
		(
			"beetroots",
			CropData {
				name: "onion",
				mc_max_age: 3,
				vs_max_age: 7,
			},
		),
	])
});

/// Regex pattern for Minecraft wood blocks and tree foliage (leaves, saplings, etc.).
/// Used in [`convert_wood_block`].
static WOOD_PATTERN: LazyLock<Regex> = LazyLock::new(|| {
	// (?x) flag enables insignificant whitespace and comments
	// https://docs.rs/regex/1.12.2/regex/#example-verbose-mode
	Regex::new(
		r#"(?x)
		# matches block codes like "oak_planks" and "jungle_slab"
		# optional prefix: stripped_
		^(?:(?P<prefix>stripped)_)?
		# tree: pale_oak, jungle, etc
		(?P<tree>(?:pale_|dark_)?oak|spruce|birch|jungle|acacia|mangrove|cherry|bamboo|crimson|warped|(?:flowering_)?azalea)
		_
		# block variant: log, planks, etc
		(?P<variant>log|stem|planks|door|leaves|wood|trapdoor|sign|wall_sign|sapling|pressure_plate)$
	"#,
	)
	.unwrap()
});

/// Regex pattern for Minecraft stairs.
/// Used in [`convert_stairs`].
pub(crate) static STAIR_PATTERN: LazyLock<Regex> =
	LazyLock::new(|| Regex::new(r"^(?:minecraft:)?(?P<material>.+?)_stairs$").unwrap());

/// Regex pattern for Minecraft slabs.
/// Used in [`convert_slab`].
static SLAB_PATTERN: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^(?P<material>.+?)_slab$").unwrap());

/// Regex pattern for Minecraft fences and iron and copper bars.
/// Used in [`convert_fence`].
pub(crate) static FENCE_PATTERN: LazyLock<Regex> = LazyLock::new(|| {
	Regex::new(r"^(?:minecraft:)?(?P<material>.+?)_(?<fence>bars|fence|wall)(?P<gate>_gate)?$").unwrap()
});

/// Regex pattern for colourful blocks.
/// Used in [`convert_colourful`].
pub(crate) static COLOURFUL_PATTERN: LazyLock<Regex> = LazyLock::new(|| {
	Regex::new(
		r"^(?x)
			# colour and separator
			(?P<colour>
				white|orange|magenta|light_blue|yellow|lime|pink|gray|light_gray|cyan|purple|blue|brown|green|red|black
			)_?

			# the block:
			(?P<block>
				# - stained glass blocks and panes
				stained_glass(?:_pane)?
				|
				# - terracotta
				(?:glazed_)?terracotta
				|
				# - concrete
				concrete(?:_powder)?
				|
				# - everything else
				wool|bed|carpet|candle|banner|wall_banner
			)$",
	)
	.unwrap()
});

/// Regex pattern for Minecraft copper blocks.
/// Used in [`convert_metal`] and [`convert_lighting`].
pub(crate) static COPPER_PATTERN: LazyLock<Regex> =
	LazyLock::new(|| Regex::new(r"^(waxed_)?(?P<variant>weathered|exposed|oxidized)?_?(cut_)?copper(_block)?$").unwrap());

/// Regex pattern for Minecraft ore blocks.
/// Used in [`convert_ore`].
static ORE_PATTERN: LazyLock<Regex> = LazyLock::new(|| {
	Regex::new(
		r"^(?P<variant>nether|deepslate)?_?(?P<ore>coal|copper|iron|gold|redstone|lapis|diamond|emerald|quartz)_ore$",
	)
	.unwrap()
});

/// Converts a Minecraft block code to a Vintage Story block code.
///
/// If there is no known Vintage Story replacement for this block, returns `None`.
///
/// Otherwise, a tuple of (`String`, `Option<EntityMap>`) will be returned.
/// The first element is the [block code](https://wiki.vintagestory.at/Block_codes), and the second is the
/// [block entity properties](https://wiki.vintagestory.at/Modding:Block_Entity_Classes).
#[allow(clippy::missing_panics_doc, reason = "no need to document mutex panic")]
#[must_use]
pub fn convert_block(block: &MinecraftBlockCode, settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	// cache for "simple" blocks (those without properties)
	static SIMPLE_CACHE: LazyLock<Mutex<Map<String, String>>> = LazyLock::new(Default::default);

	let name = block.name.trim_start_matches("minecraft:");
	trace!("block: {name}");
	trace!("properties: {:?}", block.properties);

	let empty_properties = block.properties.is_empty();
	if empty_properties && let Some(result) = SIMPLE_CACHE.lock().expect("lock should not be poisoned").get(name) {
		return Some((result.clone(), None));
	}

	// individual conversion functions for classes of blocks
	let functions = [
		convert_common,
		convert_climbable,
		convert_foliage,
		convert_decor,
		convert_lighting,
		convert_utility,
		convert_clutter,
		convert_farming,
		convert_crops,
		convert_nether,
		convert_ore,
		convert_wood_block,
		convert_stone_block,
		convert_fence,
		convert_glass,
		convert_metal,
		convert_stairs,
		convert_slab,
		convert_colourful,
		convert_moss,
	];

	for function in functions {
		if let Some(result) = function(name, &block.properties, settings) {
			if empty_properties && result.1.is_none() {
				SIMPLE_CACHE.lock().expect("lock should not be poisoned").insert(name.to_string(), result.0.clone());
			}
			return Some(result);
		}
	}

	let (code, properties) = match name {
		// TODO: replace these
		"red_mushroom_block" => (String::from("game:cobblestone-redmarble"), None),
		"mushroom_stem" => (String::from("game:log-placed-oak-ud"), None),

		// TODO: move these to a separate function
		"terracotta" => (String::from("game:rock-redmarble"), None),
		"quartz_pillar" | "quartz_block" | "chiseled_quartz_block" | "bone_block" => {
			(String::from("game:stonebricks-chalk"), None)
		}
		"wool" if settings.mods.contains(&Mod::VanillaVariants) => (String::from("wool:clothblock-wool-plain"), None),

		"iron_door" => convert_door("iron", &block.properties),
		"iron_trapdoor" => convert_trapdoor("iron", &block.properties),

		"sponge" | "wet_sponge" => {
			if settings.mods.contains(&Mod::WoolAndMore) {
				(String::from("wool:clothblock-wool-yellow"), None)
			} else {
				(String::from("game:strawbedding"), None)
			}
		}

		"slime_block" => (String::from("game:glass-green"), None),
		"raw_iron_block" => (String::from("game:cobblestone-claystone"), None),

		_ => {
			warn!("unknown block: {name}");
			return None;
		}
	};

	Some((code, properties))
}

/// Converts common Minecraft blocks, such as dirt and cobblestone, to their Vintage Story equivalents.
fn convert_common(name: &str, properties: &PropertyMap, _settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	Some(match name {
		"chest" | "trapped_chest" | "ender_chest" => convert_chest(properties),
		"sand" => (String::from("game:sand-sandstone"), None),
		"red_sand" => (String::from("game:sand-bauxite"), None),
		"cobblestone" => (String::from("game:cobblestone-granite"), None),
		"dirt" | "packed_mud" => (String::from("game:soil-low-none"), None),
		"dirt_path" => (String::from("game:packeddirt"), None),
		"podzol" | "mud" | "muddy_mangrove_roots" => (String::from("game:dirtygravel-wetverydark-plain"), None),
		"coarse_dirt" => (String::from("game:soil-verylow-none"), None),
		"grass_block" => (String::from("game:soil-low-normal"), None),
		"clay" => (String::from("game:rawclay-blue-none"), None),
		"gravel" => (String::from("game:gravel-granite"), None),
		"cobweb" => (String::from("game:spiderweb"), None),
		"ice" => (String::from("game:lakeice"), None),
		"packed_ice" => (String::from("game:glacierice"), None),
		"blue_ice" => (String::from("game:packedglacierice"), None),

		"snow" | "powder_snow" | "snow_block" => {
			// powder and block don't have layers, so treat them as maximum size
			let layer = properties.get("layers").map_or(MAX_SNOW, |l| l.parse::<u8>().unwrap_or(MAX_SNOW));
			if layer >= MAX_SNOW {
				(String::from("game:snowblock"), None)
			} else {
				(format!("game:snowlayer-{layer}"), None)
			}
		}

		"water" | "lava" => {
			let level = MAX_FLUID - properties.get("level").map_or(0, |l| l.parse::<u8>().unwrap_or_default()).min(MAX_FLUID);

			(format!("game:{name}-still-{level}"), None)
		}
		_ => return None,
	})
}

/// Converts Minecraft wood blocks, such as logs, planks, or slabs, to their Vintage Story equivalents.
pub fn convert_wood_block(
	name: &str,
	properties: &PropertyMap,
	settings: &Settings,
) -> Option<(String, Option<EntityMap>)> {
	let matches = WOOD_PATTERN.captures(name)?;
	let prefix = matches.name("prefix").map(|m| m.as_str());
	let wood = matches.name("tree").map_or("", |m| m.as_str());
	let variant = matches.name("variant").map_or("", |m| m.as_str());

	let wood = if wood == "bamboo" && variant == "planks" {
		// special case: bamboo planks should be handled specially, as they become stacked bamboo
		"bamboo"
	} else {
		convert_wood(wood, true)?
	};

	let variant = match variant {
		"stem" | "wood" => "log",
		other => other,
	};

	let orientation = match properties.get("axis").map(String::as_str) {
		Some("x") => "we",
		Some("y") => "ud",

		// interpreting double slabs as planks
		_ if properties.get("type").is_some_and(|t| t == "double") => "ud",

		_ => "ns",
	};

	let sign_wood = if settings.mods.contains(&Mod::VanillaVariants) {
		Some(wood)
	} else {
		None
	};

	Some(match variant {
		"log" if prefix == Some("stripped") => (format!("game:debarkedlog-{wood}-{orientation}"), None),
		"log" => (format!("game:{variant}-placed-{wood}-{orientation}"), None),
		"planks" if wood == "bamboo" => (format!("game:stackedbamboo-{orientation}"), None),
		"planks" => (format!("game:{variant}-{wood}-{orientation}"), None),
		"door" => convert_door(wood, properties),
		"trapdoor" => convert_trapdoor(wood, properties),
		"sign" => convert_wooden_sign(false, sign_wood, properties),
		"wall_sign" => convert_wooden_sign(true, sign_wood, properties),

		// special case: purpleheart leaves don't exist, these are similar
		"leaves" if wood == "purpleheart" => (String::from("game:leaves-placed-crimsonkingmaple"), None),
		"leaves" => (format!("game:{variant}-placed-{wood}"), None),

		"sapling" => (format!("game:{variant}-{wood}-free"), None),
		"pressure_plate" => (String::from("game:metalsheet-cupronickel-free"), None),
		// _ => (format!("error:{variant}-{tree}-{orientation}-???"), None),
		_ => return None,
	})
}

/// Converts Minecraft trapdoors to their Vintage Story equivalents.
fn convert_trapdoor(material: &str, properties: &PropertyMap) -> (String, Option<EntityMap>) {
	let rotation = if properties.get("half").is_some_and(|o| o == "bottom") {
		180
	} else {
		-180
	};
	let face = match properties.get("facing").map_or("north", String::as_str) {
		"north" => 0,
		"east" => 1,
		"south" => 2,
		_ => 3,
	};

	let new_properties = Map::from([
		(String::from("opened"), Value::Boolean(properties.get("open").is_some_and(|o| o == "true"))),
		(String::from("rotDeg"), Value::Integer(rotation)),
		(String::from("attachedFace"), Value::Integer(face)),
	]);

	let code = if material == "iron" {
		String::from("game:trapdoor-bars-iron-1")
	} else {
		// minecraft's spruce, pale oak, and dark oak trapdoors don't have windows
		let which = if matches!(material, "walnut" | "baldcypress" | "ebony") {
			"solid"
		} else {
			"window"
		};
		format!("game:trapdoor-{which}-{material}-1")
	};

	(code, Some(new_properties))
}

/// Converts Minecraft wooden doors to their Vintage Story equivalents.
fn convert_door(material: &str, properties: &PropertyMap) -> (String, Option<EntityMap>) {
	// radians tomfoolery
	let rotation = orientation_to_radians(properties.get("facing").map_or("north", String::as_str));

	let new_properties = Map::from([
		(String::from("opened"), Value::Boolean(properties.get("open").is_some_and(|o| o == "true"))),
		(String::from("invertHandles"), Value::Boolean(properties.get("hinge").is_some_and(|o| o == "right"))),
		(String::from("rotateYRad"), Value::Float(rotation)),
	]);

	let code = if material == "iron" {
		String::from("game:metaldoor-sleek-windowed-iron")
	} else {
		format!("game:door-sleek-windowed-{material}")
	};

	(code, Some(new_properties))
}

/// Creates a Vintage Story sign from a Minecraft wooden sign's properties.
fn convert_wooden_sign(wall: bool, wood: Option<&str>, properties: &PropertyMap) -> (String, Option<EntityMap>) {
	// standing signs will use the north block
	let facing = reverse_orientation(properties.get("facing").map_or("north", String::as_str));

	// /!\ jank alert /!\
	// create a property map with a "uniqueness marker" so that we can add the sign's text later
	let mut new_properties = Map::from([(String::from("unique!"), Value::Boolean(true))]);

	// handle standing signs
	if !wall {
		let rotation = properties.get("rotation").map_or(0, |r| r.parse::<u8>().unwrap_or_default());
		let rotation = stepped_rotation(rotation);
		new_properties.insert(String::from("meshAngle"), Value::Float(rotation));
	}

	let location = if wall { "wall" } else { "ground" };
	let code = wood.filter(|&w| w != "oak").map_or_else(
		|| format!("game:sign-{location}-{facing}"),
		|wood| format!("vanvar:sign-{wood}-{location}-{facing}"),
	);

	(code, Some(new_properties))
}

/// Converts Minecraft stone blocks, such as stones, bricks, and cobblestone, to their Vintage Story equivalents.
#[must_use]
pub fn convert_stone_block(
	name: &str,
	_properties: &PropertyMap,
	_settings: &Settings,
) -> Option<(String, Option<EntityMap>)> {
	if name == "obsidian" || name == "coal_block" {
		return Some((String::from("game:rock-obsidian"), None));
	} else if name == "crying_obsidian" {
		return Some((String::from("game:crackedrock-obsidian"), None));
	}

	let (material, variant) = material::convert_stone(name, false)?;

	let (material, variant) = match (material, variant) {
		("stonebrick", Some("chalk")) => ("quartz", None),
		("stonebrick", _) => ("stonebricks", variant),
		_ => (material, variant),
	};

	Some((variant.map_or_else(|| material.to_string(), |variant| format!("{material}-{variant}")), None))
}

/// Converts Minecraft stairs to their Vintage Story equivalents.
///
/// Stairs in Minecraft can take on different "corner" shapes depending on their placement:
/// <https://minecraft.wiki/w/Stairs#Placement>.
/// This behaviour is not possible in Vintage Story, so such shapes won't be carried over.
pub fn convert_stairs(
	name: &str,
	properties: &PropertyMap,
	_settings: &Settings,
) -> Option<(String, Option<EntityMap>)> {
	let matches = STAIR_PATTERN.captures(name)?;
	let material = matches.name("material").map_or("", |m| m.as_str());

	let material: Cow<str> = if let Some(tree) = convert_wood(material, false)
		&& !material.starts_with("bamboo")
	{
		format!("plankstairs-{tree}").into()
	} else if material.ends_with("cut_copper") {
		// copper stairs
		// unoxidised and exposed become bauxite, the other variants become peridotite
		match material.trim_end_matches("cut_copper").trim_start_matches("waxed_") {
			"" | "exposed_" => "stonebrickstairs-bauxite",
			_ => "stonebrickstairs-peridotite",
		}
		.into()
	} else {
		match material::convert_wood_or_stone(material) {
			Some((material, Some(variant))) => format!("{material}stairs-{variant}"),
			Some((stone, None)) => format!("{stone}stairs"),
			None => return None,
		}
		.into()
	};

	let facing = properties.get("facing").map_or("north", String::as_str);
	let half = match properties.get("half").map_or("bottom", String::as_str) {
		"bottom" => "up",
		_ => "down",
	};

	Some((format!("game:{material}-{half}-{facing}-free"), None))
}

/// Converts Minecraft slabs to Vintage Story slabs, plank blocks, or stone blocks.
pub fn convert_slab(name: &str, properties: &PropertyMap, settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	let matches = SLAB_PATTERN.captures(name)?;
	let material = matches.name("material").map_or("", |m| m.as_str());
	let slab_type = match properties.get("type").map_or("bottom", String::as_str) {
		"top" => "up",
		"bottom" => "down",
		"double" => {
			if is_tree(material) {
				// wood blocks
				return convert_wood_block(&format!("{material}_planks"), properties, settings);
			} else if is_stone(material) {
				// stone blocks
				return convert_stone_block(material, properties, settings);
			}

			// double copper slabs
			"double"
		}
		other => {
			warn!("unknown slab type: {other}");
			return None;
		}
	};

	Some((
		match material {
			// minecraft copper my beloathed
			"cut_copper" | "waxed_cut_copper" | "exposed_cut_copper" | "waxed_exposed_cut_copper" => {
				if slab_type == "double" {
					String::from("game:stonebricks-bauxite")
				} else {
					format!("game:stonebrickslab-bauxite-{slab_type}-free")
				}
			}
			"weathered_cut_copper" | "waxed_weathered_cut_copper" | "oxidized_cut_copper" | "waxed_oxidized_cut_copper" => {
				match (slab_type, settings.mods.contains(&Mod::Bricklayers)) {
					("double", true) => String::from("bricklayers:claytiles-polished-malachite"),
					("double", false) => String::from("game:stonebricks-kimberlite"),
					(_, true) => format!("bricklayers:claytilesslab-polished-malachite-{slab_type}-free"),
					(_, false) => format!("game:stonebrickslab-kimberlite-{slab_type}-free"),
				}
			}

			_ => match material::convert_wood_or_stone(material) {
				Some((material, Some(variant))) => format!("game:{material}slab-{variant}-{slab_type}-free"),
				Some((material, None)) => format!("game:{material}slab-{slab_type}-free"),

				None => return None,
			},
		},
		None,
	))
}

/// Converts Minecraft fences, gates, bars, and walls to Vintage Story fences and gates.
pub fn convert_fence(
	name: &str,
	properties: &PropertyMap,
	_settings: &Settings,
) -> Option<(String, Option<EntityMap>)> {
	let matches = FENCE_PATTERN.captures(name)?;
	let material = matches.name("material").map_or("", |m| m.as_str());
	let fence = matches.name("fence").map_or("", |f| f.as_str());
	let gate = matches.name("gate").is_some();

	let directions = if gate {
		match properties.get("facing").map_or("north", String::as_str) {
			"north" | "south" => String::from("n"),
			_ => String::from("w"),
		}
	} else {
		let mut directions = String::new();

		for direction in ["north", "east", "south", "west"] {
			if properties.get(direction).is_some_and(|d| d == "low" || d == "tall") {
				directions.push(direction.chars().next().unwrap_or_default());
			}
		}

		if directions.is_empty() {
			String::from("empty")
		} else {
			directions
		}
	};

	let code = match (material::convert_wood_or_stone(material), is_tree(material)) {
		// wooden gate
		(Some((_, Some(variant))), true) if gate => {
			let opened = if properties.get("open").is_some_and(|o| o == "true") {
				"opened"
			} else {
				"closed"
			};

			// e.g. game:woodenfencegate-oak-n-opened-left-free
			// universal prefix - wood variant - north or west - open? - hinge side - snow?
			Some(format!("game:woodenfencegate-{variant}-{directions}-{opened}-left-free"))
		}

		// stone fence/wall
		(Some((_, Some(variant))), false) => Some(format!("game:drystonefence-{variant}-{directions}-free")),

		// wooden fence/wall
		(Some((_, Some(variant))), true) => Some(format!("game:woodenfence-{variant}-{directions}-free")),

		// iron/copper bars
		_ if fence == "bars" => Some(format!("game:ironfence-base-{directions}")),

		// fallback
		_ if is_stone(material) => Some(format!("game:drystonefence-whitemarble-{directions}-free")),

		_ => None,
	}?;

	Some((code, None))
}

/// Converts the various "colourful" Minecraft blocks to their Vintage Story equivalents.
fn convert_colourful(name: &str, properties: &PropertyMap, settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	let matches = COLOURFUL_PATTERN.captures(name)?;
	let colour = matches.name("colour").map_or("", |c| c.as_str());
	let block = matches.name("block").map_or("", |v| v.as_str());

	Some(match block {
		"stained_glass" | "stained_glass_pane" => convert_colourful_glass(block, Some(colour), properties),
		"carpet" => {
			if settings.mods.contains(&Mod::WoolAndMore) {
				let colour = convert_wool_colour(colour);

				(format!("wool:wool-{colour}"), None)
			} else {
				let colour = match colour {
					"black" | "blue" | "brown" | "red" | "purple" => colour,
					"orange" => "red",
					"magenta" | "pink" => "purple",
					"light_blue" | "cyan" | "green" | "lime" | "yellow" => "turqoise", // sic
					_ => "black",
				};

				(format!("game:smallcarpet-{colour}"), None)
			}
		}
		"terracotta" | "glazed_terracotta" | "concrete" | "concrete_powder" => {
			if settings.mods.contains(&Mod::Bricklayers) {
				let colour = match colour {
					"blue" => "blurple",
					"cyan" | "light_blue" => "malachite",
					"lime" => "palegreen",
					"magenta" => "purple",
					"light_gray" => "light",
					"gray" => "granite",
					colour => colour,
				};

				(format!("bricklayers:claytiles-polished-{colour}"), None)
			} else {
				let colour = match colour {
					"white" | "yellow" => "white",
					"green" | "lime" => "green",
					_ => "red",
				};

				(format!("game:rock-{colour}marble"), None)
			}
		}
		"candle" => convert_candle(properties),
		"bed" => convert_bed(properties),
		"wool" => return convert_colourful_wool(colour, settings),
		"banner" | "wall_banner" => {
			let wall = block == "wall_banner";
			let colour = match colour {
				// direct mappings
				"blue" | "green" | "orange" | "purple" | "red" | "yellow" => colour,

				// other
				"light_blue" | "cyan" => "blue",
				"lime" => "green",
				"pink" | "brown" | "gray" | "black" => "red",
				"magenta" => "purple",
				_ => "yellow",
			};

			let rotation = if wall {
				orientation_to_radians(reverse_orientation(properties.get("facing").map_or("north", String::as_str)))
			} else {
				stepped_rotation(properties.get("rotation").map_or(0, |r| r.parse::<u8>().unwrap_or_default()))
			};

			clutter("game:clutter", &format!("banner-sunsmall-{colour}-segment"), None, rotation)
		}
		_ => return None,
	})
}

/// Converts Minecraft glass panes and blocks to Vintage Story pine leaded glass panes and glass blocks, respectively.
///
/// Glass panes in Minecraft can take on a variety of shapes, such as L-bends, T-joins, or plus sign layouts.
/// Vintage Story's glass panes don't support this, so such shapes won't be carried over.
fn convert_glass(name: &str, properties: &PropertyMap, _settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	if matches!(name, "glass" | "glass_pane") {
		Some(convert_colourful_glass(name, None, properties))
	} else if name == "tinted_glass" {
		Some(convert_colourful_glass("glass", Some("black"), properties))
	} else {
		None
	}
}

/// Converts potentially colourful Minecraft glass panes and blocks to their Vintage Story equivalents.
///
/// See [`convert_glass`] for some caveats around panes.
fn convert_colourful_glass(name: &str, colour: Option<&str>, properties: &PropertyMap) -> (String, Option<EntityMap>) {
	(
		if name.ends_with("pane") {
			// glass panes
			if properties.get("north").is_some_and(|n| n == "true") && properties.get("south").is_some_and(|e| e == "true") {
				// pane is touching the north and south edges
				// therefore, it's "facing" east and west
				// TODO: what if it's doing something other that n/s or e/w? corner shapes? plus shapes?
				String::from("game:glasspane-leaded-pine-ew")
			} else {
				String::from("game:glasspane-leaded-pine-ns")
			}
		} else {
			// glass blocks
			match colour {
				None => String::from("game:glass-plain"),
				Some("white") => String::from("game:glass-quartz"),
				Some("brown" | "orange") => String::from("game:glass-brown"),
				Some("red") => String::from("game:glass-red"),
				Some("yellow") => String::from("game:glass-yellow"),
				Some("green" | "lime") => String::from("game:glass-green"),
				Some("cyan" | "light_blue" | "blue") => String::from("game:glass-blue"),
				Some("purple" | "magenta") => String::from("game:glass-violet"),
				Some("pink") => String::from("game:glass-pink"),
				_ => String::from("game:glass-smoky"), // sic
			}
		},
		None,
	)
}

/// Converts Minecraft's metal blocks to their Vintage Story equivalents.
fn convert_metal(name: &str, _properties: &PropertyMap, _setting: &Settings) -> Option<(String, Option<EntityMap>)> {
	Some(match name {
		"gold_block" => (String::from("game:metalblock-new-plain-gold"), None),
		"iron_block" => (String::from("game:metalblock-new-plain-iron"), None),

		_ => {
			// TODO: update when `if_let_guard` is stable
			// https://github.com/rust-lang/rust/issues/51114
			if let Some(matches) = COPPER_PATTERN.captures(name) {
				let variant = matches.name("variant").map(|v| v.as_str());
				match variant {
					None => (String::from("game:metalblock-new-plain-copper"), None),
					Some(_) => (String::from("game:shingleblock-copper"), None),
				}
			} else {
				return None;
			}
		}
	})
}

/// Converts Minecraft's climbable blocks, such as ladders and vines, to their Vintage Story equivalents.
fn convert_climbable(
	name: &str,
	properties: &PropertyMap,
	_settings: &Settings,
) -> Option<(String, Option<EntityMap>)> {
	Some(match name {
		"ladder" => {
			let orientation = reverse_orientation(properties.get("facing").map_or("north", String::as_str));
			(format!("game:ladder-wood-{orientation}"), None)
		}
		"vine" => {
			let orientation = reverse_orientation(determine_orientation(properties).unwrap_or("north"));
			(format!("game:wildvine-section-{orientation}"), None)
		}
		_ => return None,
	})
}

/// Converts Minecraft farming-related blocks, such as farmland tiles, and pumpkins, to their Vintage Story
/// equivalents.
///
/// This function does not handle crops.
/// See [`convert_crops`].
fn convert_farming(name: &str, properties: &PropertyMap, _settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	Some(match name {
		"farmland" => {
			let moisture = properties.get("moisture").map(|m| m.parse::<u8>().unwrap_or_default()).unwrap_or_default();

			let code = if moisture == 7 {
				"game:farmland-moist-verylow"
			} else {
				"game:farmland-dry-verylow"
			};

			let vs_moisture = if moisture == 0 { 0.0 } else { f32::from(moisture) / 7.0 };

			(String::from(code), Some(Map::from([(String::from("moisture"), Value::Float(vs_moisture))])))
		}

		"hay_block" => (
			String::from(match properties.get("axis").map_or("x", String::as_str) {
				"x" => "hay-normal-we",
				"y" => "hay-normal-ud",
				_ => "hay-normal-ns",
			}),
			None,
		),

		"composter" | "barrel" => (String::from("game:barrel"), None),

		"pumpkin" | "carved_pumpkin" | "jack_o_lantern" => (String::from("game:pumpkin-fruit-4"), None),

		"sugar_cane" => (String::from("game:tallplant-tule-land-normal-free"), None),

		_ => return None,
	})
}

/// Converts Minecraft crops to their Vintage Story equivalents using data stored in the [`CROPS`] map.
#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
fn convert_crops(name: &str, properties: &PropertyMap, _settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	let crop_data = CROPS.get(name)?;

	let vs_name = crop_data.name;
	let age = properties.get("age").map(|a| a.parse::<u8>().unwrap_or_default()).unwrap_or_default() + 1;
	let vs_age = ((f32::from(age) / f32::from(crop_data.mc_max_age)) * f32::from(crop_data.vs_max_age)).round() as u8;

	Some((format!("crop-{vs_name}-{vs_age}"), None))
}

/// Converts Minecraft ores to their Vintage Story equivalents.
fn convert_ore(name: &str, _properties: &PropertyMap, _settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	let matches = ORE_PATTERN.captures(name)?;
	let variant = matches.name("variant").map(|v| v.as_str()).unwrap_or_default();
	let ore = matches.name("ore").map(|m| m.as_str()).unwrap_or_default();

	let stone = match variant {
		"" => "granite",
		"deepslate" => "basalt",
		"nether" => "chert",
		_ => return None,
	};

	let block = match ore {
		"coal" => {
			let stone = match stone {
				"granite" => "limestone",
				"basalt" => "shale",
				_ => stone,
			};

			format!("ore-lignite-{stone}")
		}
		"copper" => format!("ore-medium-nativecopper-{stone}"),
		"iron" => {
			let ore = if stone == "granite" { "hematite" } else { "limonite" };
			format!("ore-medium-{ore}-{stone}")
		}
		"gold" => format!("ore-medium-quartz_nativegold-{stone}"),
		"redstone" => {
			let stone = if stone == "chert" { "granite" } else { stone };
			format!("ore-cinnabar-{stone}")
		}
		"lapis" => {
			let stone = match stone {
				"granite" => "limestone",
				"chert" => "bauxite",
				"basalt" => "redmarble",
				_ => stone,
			};
			format!("ore-lapislazuli-{stone}")
		}
		"diamond" => String::from("ore-medium-diamond-kimberlite"),
		"emerald" => {
			let stone = match stone {
				"granite" => "phyllite",
				"chert" => "slate",
				_ => stone,
			};
			format!("ore-medium-emerald-{stone}")
		}
		"quartz" => format!("ore-quartz-{stone}"),
		_ => return None,
	};

	Some((block, None))
}

/// Converts Minecraft lighting-related blocks, such as torches and lanterns, to their Vintage Story equivalents.
fn convert_lighting(name: &str, properties: &PropertyMap, _settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	Some(match name {
		"torch" | "copper_torch" | "redstone_torch" | "soul_torch" => {
			// torches that live "forever"!
			let new_properties = Map::from([
				(String::from("transitionHoursLeft"), Value::Double(f64::MAX)),
				(String::from("lastCheckAtTotalDays"), Value::Double(f64::MAX)),
			]);

			let lit = properties.get("lit").is_none_or(|l| l == "true");
			let code = if lit {
				"torch-basic-lit-up"
			} else {
				"torch-basic-extinct-up"
			};

			(String::from(code), Some(new_properties))
		}

		"wall_torch" | "copper_wall_torch" | "redstone_wall_torch" | "soul_wall_torch" => {
			// TODO: unlit redstone wall torches
			let facing = reverse_orientation(properties.get("facing").map_or("north", String::as_str));

			(format!("torchholder-aged-filled-{facing}"), None)
		}

		"lantern" => {
			let hanging = properties.get("hanging").is_some_and(|h| h == "true");
			lantern("brass", None, hanging)
		}

		"soul_lantern" => {
			let hanging = properties.get("hanging").is_some_and(|h| h == "true");
			lantern("steel", None, hanging)
		}

		"sea_lantern" | "redstone_lamp" => (String::from("game:paperlantern-on"), None),

		"campfire" => (String::from("game:firepit-extinct"), None),

		_ if name
			.rsplit_once('_')
			.is_some_and(|(copper, lantern)| COPPER_PATTERN.is_match(copper) && lantern == "lantern") =>
		{
			let hanging = properties.get("hanging").is_some_and(|h| h == "true");
			lantern("copper", None, hanging)
		}

		"candle" => convert_candle(properties),

		_ => return None,
	})
}

fn convert_candle(properties: &PropertyMap) -> (String, Option<EntityMap>) {
	let count = properties.get("candles").map_or(1, |c| c.parse::<u8>().unwrap_or(1)).min(9);

	(format!("bunchocandles-{count}"), None)
}

/// Converts Minecraft flowers, bushes, and other plants to their Vintage Story equivalents.
fn convert_foliage(name: &str, properties: &PropertyMap, _settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	Some(match name {
		// `grass` was renamed to `short_grass` in 1.20.3: https://minecraft.wiki/w/Java_Edition_1.20.3#Blocks
		"short_grass" | "short_dry_grass" | "seagrass" | "grass" => (String::from("game:tallgrass-medium-free"), None),
		"tall_grass" | "tall_dry_grass" | "tall_seagrass" => (String::from("game:tallgrass-verytall-free"), None),

		"bush" | "azalea" | "flowering_azalea" | "dead_bush" | "fern" | "large_fern" | "firefly_bush" => {
			(String::from("game:leavesbranchy-placed-birch"), None)
		}
		"cactus" => (String::from("game:saguarocactus-segment"), None),
		"sweet_berry_bush" => (String::from("game:smallberrybush-cranberry-ripe"), None),
		"bamboo" => {
			let code = match properties.get("leaves").map_or("none", String::as_str) {
				"large" => String::from("game:bamboo-placed-green-segment3"),
				"small" => String::from("game:bamboo-placed-green-segment2"),
				_ => String::from("game:bamboo-placed-green-segment1"),
			};
			(code, None)
		}
		"bamboo_sapling" => (String::from("game:sapling-greenbamboo-free"), None),

		// aquatic plants
		"lily_pad" => (String::from("game:aquatic-lilygiant-small"), None),
		"kelp" | "kelp_plant" => (String::from("game:aquatic-kelp-section"), None),
		"dried_kelp_block" => (String::from("game:stonebricks-peridotite"), None),

		// coral
		"tube_coral" | "tube_coral_fan" | "tube_coral_wall_fan" => (String::from("game:coral-shrub-blue-1"), None),

		"brain_coral"
		| "brain_coral_fan"
		| "brain_coral_wall_fan"
		| "bubble_coral"
		| "bubble_coral_fan"
		| "bubble_coral_wall_fan" => (String::from("game:coral-shrub-purple-1"), None),

		"fire_coral" | "fire_coral_fan" | "fire_coral_wall_fan" => (String::from("game:coral-shrub-red-1"), None),

		"horn_coral" | "horn_coral_fan" | "horn_coral_wall_fan" => (String::from("game:coral-shrub-yellow-1"), None),

		// dead coral
		"dead_tube_coral"
		| "dead_tube_coral_fan"
		| "dead_tube_coral_wall_fan"
		| "dead_brain_coral"
		| "dead_brain_coral_fan"
		| "dead_brain_coral_wall_fan"
		| "dead_bubble_coral"
		| "dead_bubble_coral_fan"
		| "dead_bubble_coral_wall_fan"
		| "dead_fire_coral"
		| "dead_fire_coral_fan"
		| "dead_fire_coral_wall_fan"
		| "dead_horn_coral"
		| "dead_horn_coral_fan"
		| "dead_horn_coral_wall_fan" => (String::from("game:coral-shrub-dead-1"), None),

		// flowers
		_ => {
			if let Some(flower) = convert_flower(name) {
				// flowers placed in the world
				(String::from(flower), None)
			} else if let Some(flower) = name
				.split_once('_')
				.and_then(|(potted, flower)| (potted == "potted").then(|| convert_flower(flower)))
				.flatten()
			{
				// potted flowers: https://minecraft.wiki/w/Flower_Pot#Data_values
				// we need to an entry to the block_codes list, which we can't do from in here.
				// instead, we return an EntityMap with a marker value set, and rely on `Internal::convert_to_vintage_story` to
				// fix it up.
				(
					String::from(VS_FLOWER_POT_CODE),
					Some(Map::from([(String::from("flower"), Value::String(String::from(flower)))])),
				)
			} else {
				return None;
			}
		}
	})
}

fn convert_flower(name: &str) -> Option<&'static str> {
	Some(match name {
		// TODO: the other flowers
		"cornflower" | "blue_orchid" => "game:flower-cornflower-free",
		"poppy" | "red_tulip" => "game:flower-lupine-red-free",
		"orange_tulip" | "dandelion" => "game:flower-lupine-orange-free",
		"white_tulip" => "game:flower-lupine-white-free",
		"pink_tulip" | "lilac" | "allium" | "peony" => "game:flower-lupine-purple-free",
		"oxeye_daisy" | "azure_bluet" => "game:flower-wilddaisy-free",
		"rose_bush" => "game:flower-redtopgrass-free",
		"lily_of_the_valley" => "game:flower-lilyofthevalley-free",
		_ => return None,
	})
}

/// Converts Minecraft "decor" blocks, such as bookshelves and carpets, to their Vintage Story equivalents.
fn convert_decor(name: &str, properties: &PropertyMap, _settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	Some(match name {
		// TODO: bookshelf with books on all sides somehow?
		"bookshelf" | "chiseled_bookshelf" => clutter(
			"game:clutteredbookshelf",
			"bookshelves/bookshelf-full",
			Some("full"),
			orientation_to_radians(properties.get("facing").map_or("north", String::as_str)),
		),

		"bed" => convert_bed(properties),

		"bell" if properties.get("attachment").is_some_and(|a| a == "ceiling") => {
			lantern("gold", properties.get("facing").map(String::as_str), true)
		}

		"decorated_pot" => (String::from("game:storagevessel-red-fired"), None),
		"flower_pot" => (String::from("game:flowerpot-red-fired"), None), // TODO: pots with flowers

		_ => return None,
	})
}

fn convert_bed(properties: &PropertyMap) -> (String, Option<EntityMap>) {
	let facing = reverse_orientation(properties.get("facing").map_or("north", String::as_str));
	let half = match properties.get("part").map_or("foot", String::as_str) {
		"head" => "head",
		_ => "feet",
	};

	(format!("game:bed-wood-{half}-{facing}"), None)
}

/// Converts Minecraft utility blocks, such as furnaces and anvils, to their Vintage Story equivalents.
fn convert_utility(name: &str, properties: &PropertyMap, settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	Some(match name {
		"furnace" | "blast_furnace" | "smoker" => (String::from("game:forge"), None),
		"anvil" | "chipped_anvil" | "damaged_anvil" => {
			let angle = orientation_to_radians(properties.get("facing").map_or("north", String::as_str));
			// rotate 90 degrees
			let angle = angle + std::f32::consts::FRAC_PI_2;

			let new_properties = Map::from([(String::from("meshAngle"), Value::Float(angle))]);

			(String::from("game:anvil-iron"), Some(new_properties))
		}
		"hopper" => {
			if settings.mods.contains(&Mod::VanillaVariants) {
				(String::from("vanvar:hopper-iron"), None)
			} else {
				(String::from("game:hopper"), None)
			}
		}
		"stone_pressure_plate" => (String::from("game:metalsheet-steel-down"), None),
		"polished_blackstone_pressure_plate" => (String::from("game:metalsheet-lead-down"), None),
		"heavy_weighted_pressure_plate" => (String::from("game:metalsheet-nickel-down"), None),
		"light_weighted_pressure_plate" => (String::from("game:metalsheet-gold-down"), None),
		"lodestone" | "observer" | "stonecutter" | "dropper" | "dispenser" => {
			(String::from("game:diamond-stone-light"), None)
		}
		"cauldron" | "water_cauldron" => (String::from("game:storagevessel-black-fired"), None),
		_ => return None,
	})
}

/// Converts [Minecraft chests](https://minecraft.wiki/w/Chest) to
/// [Vintage Story chests and trunks](https://wiki.vintagestory.at/Chest).
///
/// Items contained within Minecraft chests are not currently converted.
fn convert_chest(properties: &PropertyMap) -> (String, Option<Map<String, Value>>) {
	// MC double chests become trunks.
	// MC chests are stored with type `single`, while double chests are stored with either `left` or `right`.
	// the `left` chests are rejected by `should_reject`, ensuring MC chests don't become two VS trunks.
	// VS chests have 16 slots, trunks have 36: https://wiki.vintagestory.at/Chest
	let (chest, slots) = if properties.get("type").is_some_and(|t| t == "single") {
		("chest", VS_CHEST_SLOTS)
	} else {
		("trunk", VS_TRUNK_SLOTS)
	};

	let facing = reverse_orientation(properties.get("facing").map_or("north", String::as_str));
	let rotation = orientation_to_radians(facing);
	let code = format!("game:{chest}-{facing}");

	// inventory tree
	let inventory = Map::from([
		// number of slots in this chest's inventory
		(String::from("qslots"), Value::Integer(slots)),
		// the items this chest is currently storing
		(String::from("slots"), Value::Tree(Map::new())),
	]);

	let new_properties = Map::from([
		(String::from("inventory"), Value::Tree(inventory)),
		(String::from("meshAngle"), Value::Float(rotation)),
		// i don't know what these properties are for
		(String::from("forBlockCode"), Value::String(code.trim_start_matches("game:").to_owned())),
		(String::from("type"), Value::String(String::from("normal-generic"))),
	]);

	(code, Some(new_properties))
}

/// Converts Minecraft "clutter" blocks, such as lecterns, to their Vintage Story equivalents.
fn convert_clutter(name: &str, properties: &PropertyMap, _settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	Some(match name {
		"lectern" => {
			let which = if properties.get("has_book").is_some_and(|b| b == "true") {
				// sic
				"bookshelves/lecturn-book-open"
			} else {
				"bookshelves/lecturn-empty"
			};

			clutter(
				"game:clutter",
				which,
				None,
				orientation_to_radians(properties.get("facing").map_or("north", |f| reverse_orientation(f))),
			)
		}
		_ => return None,
	})
}

/// Converts Nether blocks to their Vintage Story equivalents.
fn convert_nether(name: &str, _properties: &PropertyMap, _settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	Some(match name {
		"netherrack" => (String::from("game:polishedrockold-cobbled-chert"), None),
		"soul_sand" => (String::from("game:cobbleskull-conglomerate"), None),
		"soul_soil" => (String::from("game:dirtygravel-wet-plain"), None),
		"glowstone" => (String::from("game:paperlantern-on"), None),
		_ => return None,
	})
}

/// Creates a Vintage Story lantern.
fn lantern(material: &str, facing: Option<&str>, hanging: bool) -> (String, Option<EntityMap>) {
	let rotation = orientation_to_radians(facing.unwrap_or("north"));

	let properties = Map::from([
		(String::from("meshAngle"), Value::Float(rotation)),
		(String::from("glass"), Value::String(String::from("quartz"))),
		(String::from("lining"), Value::String(String::from("plain"))),
		(String::from("material"), Value::String(material.to_owned())),
	]);

	let code = if hanging {
		"game:lantern-down"
	} else {
		"game:lantern-up"
	};

	(String::from(code), Some(properties))
}

/// Creates a Vintage Story [clutter](https://wiki.vintagestory.at/Clutter) block.
fn clutter(code: &str, clutter_code: &str, variant: Option<&str>, angle: f32) -> (String, Option<EntityMap>) {
	let mut properties = Map::from([
		(String::from("meshAngle"), Value::Float(angle)),
		(String::from("type"), Value::String(clutter_code.to_owned())),
		(String::from("collected"), Value::Boolean(false)),
		(String::from("repairState"), Value::Float(0.0)),
	]);

	if let Some(variant) = variant {
		properties.insert(String::from("variant"), Value::String(variant.to_owned()));
	}

	(String::from(code), Some(properties))
}

/// Converts colourful wool blocks to their Vintage Story equivalents.
fn convert_colourful_wool(colour: &str, settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	if !settings.mods.contains(&Mod::WoolAndMore) {
		return None;
	}

	let colour = convert_wool_colour(colour);
	Some((format!("wool:clothblock-wool-{colour}"), None))
}

/// Converts a Minecraft wool colour to the corresponding Vintage Story 'Wool & More' wool colour.
fn convert_wool_colour(colour: &str) -> &str {
	match colour {
		"white" => "plain",
		"cyan" | "light_blue" => "blue",
		"blue" => "darkblue",
		"lime" => "green",
		"green" => "darkgreen",
		"magenta" => "purple",
		"light_gray" => "gray",
		_ => colour,
	}
}

/// Converts [Minecraft's various moss blocks](https://minecraft.wiki/w/Moss) to their Vintage Story equivalents.
fn convert_moss(name: &str, _properties: &PropertyMap, settings: &Settings) -> Option<(String, Option<EntityMap>)> {
	Some(match name {
		"moss_block" => (String::from("game:daub-moss-normal"), None),
		"pale_moss_block" => (String::from("game:soil-verylow-none"), None),
		"moss_carpet" => {
			if settings.mods.contains(&Mod::WoolAndMore) {
				(String::from("wool:wool-green"), None)
			} else {
				(String::from("game:smallcarpet-turqoise"), None) // sic
			}
		}
		"pale_moss_carpet" => {
			if settings.mods.contains(&Mod::WoolAndMore) {
				(String::from("wool:wool-gray"), None)
			} else {
				(String::from("game:smallcarpet-purple"), None)
			}
		}
		_ => return None,
	})
}

/// Converts a stepped rotation value (as used by [signs](https://minecraft.wiki/w/Sign#Block_states) and
/// [banners](https://minecraft.wiki/w/Banner#Block_states)) to a Vintage Story-compatible rotation value.
fn stepped_rotation(rotation: u8) -> f32 { (std::f32::consts::PI / 8.0) * f32::from(16 - rotation) }