//! Vanilla tree, fallen-tree and ore features over a layered synthetic world. use horizon_core::{ geometry::{Direction, VoxelShape}, random::{LegacyRandom, RandomSource, XoroshiroRandom}, }; use horizon_world::{ block_collision::{BlockCollisionRegistry, DynamicCollisionWorld, ShulkerCollisionState}, block_placement::BlockPlacementBindings, block_properties::BlockPropertiesRegistry, block_support::{BlockSupportRegistry, SupportType}, block_survival::{BlockSurvivalRegistry, SurvivalDefinitions, SurvivalRule, SurvivalWorld}, collision::CachedCollisionRegistry, dynamic_support::DynamicSupportWorld, fluid::{FluidKind, FluidState, FluidStateTable}, heightmap::HeightmapType, nbt::{self, Limits, Tag}, registry::{BlockRegistry, BlockStateId}, worldgen::{ anchor::WorldGenerationContext, block_feature::FeatureBlockBindings, feature::{FeatureBlocks, FeatureWorld}, feature_catalog::FeatureCatalog, placement::{PlacementContext, PlacementQueryError}, state_provider::{StateProviderBindings, StateProviderCatalog}, tags::TagDefinitions, }, }; use serde_json::Value; use std::{ collections::{BTreeMap, BTreeSet, HashMap}, fs, io::{self, BufRead, Write}, path::Path, sync::Arc, }; const MIN_Y: i32 = -64; const HEIGHT: i32 = 384; struct Terrain { layers: Vec<[i32; 2]>, boxes: Vec<[i32; 7]>, hole: [i32; 2], obstacle: [i32; 3], overrides: HashMap<[i32; 3], u32>, air: u32, } impl Terrain { fn new(f: &Value, air: u32) -> Self { let n = |key: &str| f[key].as_i64().unwrap() as i32; Self { layers: f["layers"] .as_array() .unwrap() .iter() .map(|l| [l[0].as_i64().unwrap() as i32, l[1].as_i64().unwrap() as i32]) .collect(), boxes: f .get("boxes") .and_then(Value::as_array) .map(|boxes| { boxes .iter() .map(|b| std::array::from_fn(|i| b[i].as_i64().unwrap() as i32)) .collect() }) .unwrap_or_default(), hole: [n("hole_mod"), n("hole_state")], obstacle: [n("obstacle_mod"), n("obstacle_state"), n("obstacle_min")], overrides: f["states"] .as_array() .unwrap() .iter() .map(|v| { ( std::array::from_fn(|i| v[i].as_i64().unwrap() as i32), v[3].as_u64().unwrap() as u32, ) }) .collect(), air, } } fn hash(x: i32, y: i32, z: i32) -> i32 { let mut h = x.wrapping_mul(73856093) ^ y.wrapping_mul(19349663) ^ z.wrapping_mul(83492791); h ^= ((h as u32) >> 13) as i32; h = h.wrapping_mul(0x5bd1e995); h ^= ((h as u32) >> 15) as i32; h & 0x7fff_ffff } fn at(&self, [x, y, z]: [i32; 3]) -> BlockStateId { if let Some(state) = self.overrides.get(&[x, y, z]) { return BlockStateId(*state); } for b in &self.boxes { if x >= b[0] && y >= b[1] && z >= b[2] && x <= b[3] && y <= b[4] && z <= b[5] { return BlockStateId(b[6] as u32); } } let h = Self::hash(x, y, z); if let Some(layer) = self.layers.iter().find(|l| y <= l[0]) { if self.hole[0] > 0 && h % self.hole[0] == 0 { return BlockStateId(self.hole[1] as u32); } return BlockStateId(layer[1] as u32); } if self.obstacle[0] > 0 && y >= self.obstacle[2] && h % self.obstacle[0] == 0 { return BlockStateId(self.obstacle[1] as u32); } BlockStateId(self.air) } } struct World<'a, 'r, W> { out: &'a mut W, terrain: Terrain, overlay: BTreeMap<[i32; 3], BlockStateId>, void_air: BlockStateId, height: i32, fluids: &'a FluidStateTable, tags: &'a BTreeMap>, support: &'a BlockSupportRegistry<'r>, survival: &'a BlockSurvivalRegistry<'r>, collision: &'a BlockCollisionRegistry<'r>, seed: i64, chest: BlockStateId, world_random: LegacyRandom, water_mask: u8, /// A vine without faces and air: the only fixture obstacle that changes /// under a shape update (VineBlock.updateShape). faceless_vine: Option, /// VegetationBlock obstacles (short grass, fern): air once unsupported. vegetation: BTreeSet, air: BlockStateId, } impl World<'_, '_, W> { fn get(&self, p: [i32; 3]) -> BlockStateId { if p[1] < MIN_Y || p[1] >= MIN_Y + HEIGHT { return self.void_air; } self.overlay .get(&p) .copied() .unwrap_or_else(|| self.terrain.at(p)) } } fn query(error: impl std::fmt::Display) -> PlacementQueryError { PlacementQueryError::Failed(error.to_string()) } impl FeatureWorld for World<'_, '_, W> { type Error = io::Error; fn block(&mut self, p: [i32; 3]) -> io::Result { Ok(self.get(p)) } fn set_block(&mut self, p: [i32; 3], state: BlockStateId, flags: i32) -> io::Result { writeln!( self.out, "set {} {} {} {} {flags}", p[0], p[1], p[2], state.0 )?; if p[1] < MIN_Y || p[1] >= MIN_Y + HEIGHT { return Ok(false); } self.overlay.insert(p, state); Ok(true) } } impl DynamicSupportWorld for World<'_, '_, W> { type Error = io::Error; fn shulker_is_closed(&mut self, _: [i32; 3]) -> io::Result> { Ok(None) } fn moving_piston_shape(&mut self, _: [i32; 3]) -> io::Result> { Ok(None) } } impl DynamicCollisionWorld for World<'_, '_, W> { fn shulker_collision_state( &mut self, _: [i32; 3], ) -> io::Result> { Ok(None) } } impl SurvivalWorld for World<'_, '_, W> { fn block_state(&mut self, p: [i32; 3]) -> io::Result { Ok(self.get(p)) } fn fluid_state(&mut self, p: [i32; 3]) -> io::Result { self.fluids .get(self.get(p)) .ok_or_else(|| io::Error::other("unknown fluid")) } fn raw_brightness(&mut self, _: [i32; 3], _: i32) -> io::Result { Ok(15) } } impl PlacementContext for World<'_, '_, W> { /// StructureTemplate.updateShapeAtEdge: the state, then its neighbour. /// VineBlock.updateShape drops a vine left without faces on any update /// but from below; the other fixture states keep their shape. fn update_shape_at_face( &mut self, position: [i32; 3], direction: Direction, flags: i32, ) -> Result<(), PlacementQueryError> { let n = direction.normal(); let neighbor = [position[0] + n[0], position[1] + n[1], position[2] + n[2]]; for (p, from) in [(position, direction), (neighbor, direction.opposite())] { let state = self.get(p); let drop = if Some(state) == self.faceless_vine { from != Direction::Down } else if self.vegetation.contains(&state) { let survival = self.survival; !survival.can_survive(self, state, p).map_err(query)? } else { false }; if drop { self.set_block(p, self.air, flags & !1).map_err(query)?; } } Ok(()) } fn collision_full_block( &mut self, state: BlockStateId, p: [i32; 3], ) -> Result { use horizon_core::geometry::Axis; let collision = self.collision; let shape = collision.collision_shape(self, state, p).map_err(query)?; let [nx, ny, nz] = shape.sizes(); let spans = [Axis::X, Axis::Y, Axis::Z] .into_iter() .all(|axis| shape.min(axis) == 0.0 && shape.max(axis) == 1.0); Ok(!shape.is_empty() && spans && (0..nx).all(|x| { (0..ny).all(|y| (0..nz).all(|z| shape.is_full(x as i32, y as i32, z as i32))) })) } fn configure_end_gateway( &mut self, _: [i32; 3], _: [i32; 3], _: bool, ) -> Result<(), PlacementQueryError> { Ok(()) } fn world_seed(&mut self) -> Result { Ok(self.seed) } fn next_world_boolean(&mut self) -> Result { Ok(self.world_random.next_boolean()) } fn schedule_block_tick( &mut self, _: [i32; 3], _: BlockStateId, _: i32, ) -> Result<(), PlacementQueryError> { Ok(()) } fn schedule_fluid_tick( &mut self, _: [i32; 3], _: FluidKind, _: i32, ) -> Result<(), PlacementQueryError> { Ok(()) } fn block_brightness(&mut self, _: [i32; 3]) -> Result { Ok(15) } fn sea_level(&mut self) -> Result { Ok(63) } fn water_at(&mut self, p: [i32; 3]) -> Result { let fluid = PlacementContext::fluid_state(self, p)?; Ok(fluid.kind().mask() & self.water_mask != 0) } fn block_survives( &mut self, state: BlockStateId, p: [i32; 3], ) -> Result { let survival = self.survival; survival.can_survive(self, state, p).map_err(query) } fn attachment_at( &mut self, p: [i32; 3], direction: Direction, ) -> Result { let survival = self.survival; survival.can_attach_to(self, p, direction).map_err(query) } fn state_collision_empty( &mut self, state: BlockStateId, p: [i32; 3], ) -> Result { let collision = self.collision; collision .collision_shape(self, state, p) .map(|shape| shape.is_empty()) .map_err(query) } fn set_block_entity_loot_table( &mut self, p: [i32; 3], table: &str, random: &mut impl RandomSource, ) -> Result<(), PlacementQueryError> { if self.get(p) == self.chest { let seed = random.next_long(); writeln!(self.out, "loot {} {} {} {table} {seed}", p[0], p[1], p[2]).map_err(query)?; } Ok(()) } fn configure_spawner(&mut self, p: [i32; 3], entity: &str) -> Result<(), PlacementQueryError> { writeln!(self.out, "spawner {} {} {} {entity}", p[0], p[1], p[2]).map_err(query) } fn generation(&self) -> WorldGenerationContext { WorldGenerationContext::new(MIN_Y, HEIGHT, 63) } fn min_y(&mut self) -> Result { Ok(MIN_Y) } fn max_y(&mut self) -> Result { Ok(MIN_Y + HEIGHT - 1) } fn height(&mut self, _: HeightmapType, _: i32, _: i32) -> Result { Ok(self.height) } fn block_state(&mut self, p: [i32; 3]) -> Result { Ok(self.get(p)) } fn fluid_state(&mut self, p: [i32; 3]) -> Result { self.fluids .get(self.get(p)) .ok_or_else(|| query("unknown fluid")) } fn block_matches_tag(&mut self, p: [i32; 3], tag: &str) -> Result { let state = self.get(p); Ok(self.tags.get(tag).is_some_and(|s| s.contains(&state))) } fn state_face_sturdy( &mut self, state: BlockStateId, p: [i32; 3], direction: Direction, ) -> Result { let support = self.support; support .is_face_sturdy(self, state, p, direction, SupportType::Full) .map_err(query) } fn face_sturdy( &mut self, p: [i32; 3], direction: Direction, ) -> Result { let state = self.get(p); self.state_face_sturdy(state, p, direction) } fn mark_postprocessing(&mut self, p: [i32; 3]) -> Result<(), PlacementQueryError> { writeln!(self.out, "post {} {} {}", p[0], p[1], p[2]).map_err(query) } fn set_section_block( &mut self, p: [i32; 3], state: BlockStateId, ) -> Result<(), PlacementQueryError> { self.overlay.insert(p, state); Ok(()) } fn store_beehive_occupants( &mut self, p: [i32; 3], ticks: &[i32], ) -> Result<(), PlacementQueryError> { for t in ticks { writeln!(self.out, "bee {} {} {} {t}", p[0], p[1], p[2]).map_err(query)?; } Ok(()) } } #[allow(clippy::too_many_arguments)] fn fixture( f: &Value, mut random: R, catalog: &FeatureCatalog, features: &BTreeMap, bindings: &FeatureBlockBindings<'_>, blocks: FeatureBlocks, world: &mut World<'_, '_, impl Write>, ) -> io::Result<()> { let name = f["feature"].as_str().unwrap(); writeln!(world.out, "fixture {name}")?; let feature = match catalog.feature_with_blocks(&features[name], bindings) { Ok(feature) => feature, Err(error) => { eprintln!("decode {name}: {error}"); return writeln!(world.out, "decode error"); } }; let origin = std::array::from_fn(|i| f["origin"][i].as_i64().unwrap() as i32); match feature.place(world, &mut random, origin, blocks) { Ok(result) => writeln!(world.out, "place {result}")?, Err(error) => { eprintln!("{name}: {error}"); writeln!(world.out, "place error")? } } writeln!(world.out, "next {}", random.next_long())?; let changes: Vec<_> = world .overlay .iter() .filter(|(p, state)| world.terrain.at(**p) != **state) .map(|(p, s)| (*p, *s)) .collect(); for (p, state) in changes { writeln!(world.out, "final {} {} {} {}", p[0], p[1], p[2], state.0)?; } writeln!(world.out, "end") } fn survival_rule(rule: &str) -> SurvivalRule { use SurvivalRule::*; match rule { value if value.starts_with("TagBelow:") => TagBelow(value[9..].to_owned()), "CactusFlower" => CactusFlower, "Seagrass" => Seagrass, "BubbleColumn" => BubbleColumn, "RedstoneWire" => RedstoneWire, "DoublePlant" => DoublePlant, "Door" => Door, "BigDripleaf" => BigDripleaf, "BigDripleafStem" => BigDripleafStem, "Farmland" => Farmland, "Cocoa" => Cocoa, "Crop" => Crop, "GrowingPlant" => GrowingPlant, "MangrovePropagule" => MangrovePropagule, "Speleothem" => Speleothem, "Scaffolding" => Scaffolding, "PistonHead" => PistonHead, "ChorusPlant" => ChorusPlant, "ChorusFlower" => ChorusFlower, "PitcherCrop" => PitcherCrop, "Multiface" => Multiface, "Vine" => Vine, "HangingMoss" => HangingMoss, "SnowLayer" => SnowLayer, "SeaPickle" => SeaPickle, "Fire" => Fire, "Cactus" => Cactus, "Path" => Path, "Mushroom" => Mushroom, "Bell" => Bell, "SugarCane" => SugarCane, "LilyPad" => LilyPad, "Frogspawn" => Frogspawn, "SporeBlossom" => SporeBlossom, "SmallDripleaf" => SmallDripleaf, "TallSeagrass" => TallSeagrass, "Always" => Always, "SolidBelow" => SolidBelow, "SolidBehind" => SolidBehind, "NonAirBelow" => NonAirBelow, "MossCarpet" => MossCarpet, "CenterBelow" => CenterBelow, "Lantern" => Lantern, "FullAbove" => FullAbove, "FullBehind" => FullBehind, "RigidOrCenterBelow" => RigidOrCenterBelow, "RigidBelow" => RigidBelow, "FullBelow" => FullBelow, "CenterAbove" => CenterAbove, "FaceAttached" => FaceAttached, "SupportsBamboo" => SupportsBamboo, _ => panic!("unknown rule {rule}"), } } fn main() -> Result<(), Box> { let arg = std::env::args().nth(1).expect("private fixture directory"); let dir = Path::new(&arg); let read = |name: &str| -> Result> { Ok( nbt::read_named(&fs::read(dir.join(name))?, Limits::default())? .0 .tag, ) }; let registry = BlockRegistry::from_nbt(&read("block-registry.nbt")?)?; let collisions = CachedCollisionRegistry::from_nbt(&read("cached-collision.nbt")?, ®istry)?; let properties = BlockPropertiesRegistry::from_nbt(&read("block-properties.nbt")?, &collisions)?; let support = BlockSupportRegistry::from_nbt(&read("cached-support.nbt")?, ®istry)?; let resources: BTreeMap = serde_json::from_str(&fs::read_to_string(dir.join("tags.json"))?)?; let mut tags = TagDefinitions::default(); for (name, text) in resources { tags.apply_json(&name, "vanilla", &text)?; } let tags = tags.build(|name, _| registry.default_state(name).map(|_| name.to_owned()))?; let fluid_resources: BTreeMap = serde_json::from_str(&fs::read_to_string(dir.join("fluid-tags.json"))?)?; let mut fluid_tags = TagDefinitions::default(); for (name, text) in fluid_resources { fluid_tags.apply_json(&name, "vanilla", &text)?; } let fluid_tags = fluid_tags.build(|name, _| FluidKind::from_name(name).map(|_| name.to_owned()))?; let facts: Value = serde_json::from_str(&fs::read_to_string(dir.join("facts.json"))?)?; let integers: BTreeSet<(String, String)> = facts["integers"] .as_array() .unwrap() .iter() .map(|v| { ( v[0].as_str().unwrap().to_owned(), v[1].as_str().unwrap().to_owned(), ) }) .collect(); let bundle: Value = serde_json::from_str(&fs::read_to_string(dir.join("vanilla-features.json"))?)?; let providers: BTreeMap = serde_json::from_value(bundle["providers"].clone())?; let features: BTreeMap = serde_json::from_value(bundle["features"].clone())?; let placed: BTreeMap = serde_json::from_value(bundle["placed"].clone())?; let definitions: Value = serde_json::from_str(&fs::read_to_string(dir.join("placement-definitions.json"))?)?; let bindings = FeatureBlockBindings::with_tags(®istry, integers.clone(), &tags.tags)? .with_block_properties(&properties)? .with_fluid_tags(&fluid_tags.tags)? .with_state_providers( StateProviderBindings::new(®istry, integers, &tags.tags)? .with_block_properties(&properties)? .with_fluid_tags(&fluid_tags.tags)?, StateProviderCatalog::from_resources(&providers)?, BlockPlacementBindings::new( ®istry, &properties, &serde_json::from_value(definitions["double_plants"].clone())?, &serde_json::from_value(definitions["mossy_carpets"].clone())?, )?, )?; let catalog = FeatureCatalog::from_resources(&features, &placed, &TagDefinitions::default())?; let blocks = FeatureBlocks::from_registry(®istry)?; let fluids = FluidStateTable::new(®istry)?; let mut by_name = BTreeMap::>::new(); for id in 0..registry.len() { let id = BlockStateId(id as u32); by_name .entry(registry.state(id).unwrap().name.clone()) .or_default() .push(id); } let tag_states: BTreeMap> = tags .tags .iter() .map(|(name, entries)| { ( name.clone(), entries .iter() .flat_map(|e| by_name.get(e).into_iter().flatten().copied()) .collect(), ) }) .collect(); let support = Arc::new(support); let definitions_text: BTreeMap = serde_json::from_str(&fs::read_to_string(dir.join("survival-rules.json"))?)?; let rules = definitions_text .into_iter() .map(|(name, rule)| (name, survival_rule(&rule))) .collect(); let extra: Value = serde_json::from_str(&fs::read_to_string( dir.join("survival-extra-definitions.json"), )?)?; let survival_definitions = SurvivalDefinitions { rules, ignition_odds: serde_json::from_value(extra["ignition_odds"].clone())?, fence_gates: serde_json::from_value(extra["fence_gates"].clone())?, }; let collision = Arc::new(BlockCollisionRegistry::new(Arc::new( CachedCollisionRegistry::from_nbt(&read("cached-collision.nbt")?, ®istry)?, ))?); let survival = BlockSurvivalRegistry::new( ®istry, &properties, support.clone(), collision.clone(), &survival_definitions, &tags.tags, &fluid_tags.tags, )?; let chest = registry.default_state("minecraft:chest").unwrap(); let vegetation: BTreeSet = ["minecraft:short_grass", "minecraft:fern"] .iter() .filter_map(|n| by_name.get(*n)) .flatten() .copied() .collect(); let faceless_vine = by_name.get("minecraft:vine").and_then(|ids| { ids.iter().copied().find(|id| { registry .state(*id) .is_some_and(|s| s.properties.values().all(|v| v == "false")) }) }); let water_mask = fluid_tags.tags["minecraft:water"] .iter() .fold(0, |mask, name| { mask | FluidKind::from_name(name).unwrap().mask() }); let air = registry.default_state("minecraft:air").unwrap().0; let void_air = registry.default_state("minecraft:void_air").unwrap(); let mut out = io::BufWriter::new(fs::File::create(dir.join("rust.txt"))?); for line in io::BufReader::new(fs::File::open(dir.join("inputs.txt"))?).lines() { let f: Value = serde_json::from_str(&line?)?; let mut world = World { out: &mut out, terrain: Terrain::new(&f, air), overlay: BTreeMap::new(), void_air, height: f["height"].as_i64().unwrap() as i32, fluids: &fluids, tags: &tag_states, support: &support, survival: &survival, collision: &collision, seed: f["world_seed"].as_i64().unwrap_or(0), chest, world_random: LegacyRandom::new(0), water_mask, faceless_vine, vegetation: vegetation.clone(), air: BlockStateId(air), }; let seed = f["seed"].as_i64().unwrap(); if f["legacy"].as_bool().unwrap() { fixture( &f, LegacyRandom::new(seed), &catalog, &features, &bindings, blocks, &mut world, )?; } else { fixture( &f, XoroshiroRandom::new(seed), &catalog, &features, &bindings, blocks, &mut world, )?; } } out.flush()?; Ok(()) }