From 0a4a4ea643b1b3bb5ce3af6dbdf876fd1d421b72 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Thu, 8 Oct 2026 15:09:34 +0200 Subject: [PATCH] Grow saplings, fungi and mushrooms and apply bone meal through live feature placement Port TreeGrower (all growers incl. 2x2 dark oak, pale oak, mega spruce/jungle, mangrove, azalea, poplar), BoneMealItem.useOn/growCrop/growWaterPlant and every BonemealableBlock. Configured and placed features run on the live level via a FeatureWorld/PlacementContext adapter with vanilla setBlock semantics. Also fix torchflower crops never maturing and kelp growth into flowing water. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-world/src/level/bonemeal.rs | 1131 +++++++++++++++++ crates/horizon-world/src/level/data.rs | 1 + .../horizon-world/src/level/feature_world.rs | 293 +++++ crates/horizon-world/src/level/growth.rs | 342 +++++ .../horizon-world/src/level/growth_tests.rs | 342 +++++ crates/horizon-world/src/level/mod.rs | 15 + crates/horizon-world/src/level/tick.rs | 25 +- crates/horizon-world/src/worldgen.rs | 1 + crates/horizon-world/src/worldgen/live.rs | 316 +++++ 9 files changed, 2452 insertions(+), 14 deletions(-) create mode 100644 crates/horizon-world/src/level/bonemeal.rs create mode 100644 crates/horizon-world/src/level/feature_world.rs create mode 100644 crates/horizon-world/src/level/growth.rs create mode 100644 crates/horizon-world/src/level/growth_tests.rs create mode 100644 crates/horizon-world/src/worldgen/live.rs diff --git a/crates/horizon-world/src/level/bonemeal.rs b/crates/horizon-world/src/level/bonemeal.rs new file mode 100644 index 000000000..a59a1c7e1 --- /dev/null +++ b/crates/horizon-world/src/level/bonemeal.rs @@ -0,0 +1,1131 @@ +//! Bone meal: `BoneMealItem.useOn` / `growCrop` / `growWaterPlant` and every +//! vanilla `BonemealableBlock` (`isValidBonemealTarget`, `isBonemealSuccess`, +//! `performBonemeal`), ported in vanilla's random draw order. +use super::{ + Behaviours, LevelAccess, LevelEvent, Sim, Ticks, + classes::{Class, Interface}, + growth::grower, + update::{HORIZONTAL, above, below, rel}, +}; +use crate::{fluid::FluidState, registry::BlockStateId}; +use horizon_core::{geometry::Direction, position::BlockPos, random::RandomSource}; + +/// The `BonemealableBlock` implementation a block uses (most derived wins). +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum Kind { + Sapling, + Propagule, + Mushroom, + Fungus, + Azalea, + Grass, + Nylium, + Netherrack, + FeaturePlacer, + RootedDirt, + MangroveLeaves, + Crop, + Stem, + Pitcher, + BambooSapling, + Bamboo, + Cocoa, + SweetBerry, + TallGrass, + TallFlower, + SpreadingBush, + FlowerBed, + CaveVines, + PlantHead, + CaveVinesPlant, + PlantBody, + Seagrass, + SeaPickle, + BigDripleaf, + BigDripleafStem, + SmallDripleaf, + GlowLichen, + HangingMoss, + MossyCarpet, + ShortDryGrass, + TallDryGrass, + ShelfMushroom, +} + +fn kind_of(class: Class) -> Option { + Some(match class { + Class::MangrovePropagule => Kind::Propagule, + Class::Sapling => Kind::Sapling, + Class::Mushroom => Kind::Mushroom, + Class::NetherFungus => Kind::Fungus, + Class::Azalea => Kind::Azalea, + Class::Grass => Kind::Grass, + Class::Nylium => Kind::Nylium, + Class::Netherrack => Kind::Netherrack, + Class::BonemealableFeaturePlacer => Kind::FeaturePlacer, + Class::RootedDirt => Kind::RootedDirt, + Class::MangroveLeaves => Kind::MangroveLeaves, + Class::Crop => Kind::Crop, + Class::Stem => Kind::Stem, + Class::PitcherCrop => Kind::Pitcher, + Class::BambooSapling => Kind::BambooSapling, + Class::BambooStalk => Kind::Bamboo, + Class::Cocoa => Kind::Cocoa, + Class::SweetBerryBush => Kind::SweetBerry, + Class::TallGrass => Kind::TallGrass, + Class::TallFlower => Kind::TallFlower, + Class::Bush | Class::FireflyBush => Kind::SpreadingBush, + Class::FlowerBed => Kind::FlowerBed, + Class::CaveVines => Kind::CaveVines, + Class::GrowingPlantHead => Kind::PlantHead, + Class::CaveVinesPlant => Kind::CaveVinesPlant, + Class::GrowingPlantBody => Kind::PlantBody, + Class::Seagrass => Kind::Seagrass, + Class::SeaPickle => Kind::SeaPickle, + Class::BigDripleaf => Kind::BigDripleaf, + Class::BigDripleafStem => Kind::BigDripleafStem, + Class::SmallDripleaf => Kind::SmallDripleaf, + Class::GlowLichen => Kind::GlowLichen, + Class::HangingMoss => Kind::HangingMoss, + Class::MossyCarpet => Kind::MossyCarpet, + Class::ShortDryGrass => Kind::ShortDryGrass, + Class::TallDryGrass => Kind::TallDryGrass, + Class::ShelfMushroom => Kind::ShelfMushroom, + _ => return None, + }) +} + +/// `Mth.nextInt(random, min, max)`. +fn next_int_between(random: &mut R, min: i32, max: i32) -> i32 { + if min >= max { + min + } else { + random.next_int_bound(max - min + 1).unwrap_or(0) + min + } +} + +impl Behaviours { + /// `BoneMealItem.useOn` for a player clicking `pos` on `face`. Returns + /// whether bone meal was used (the caller then shrinks the stack unless + /// the player is in creative mode). Reports level event 1505 (growth + /// particles and sound) at the grown position. + pub fn use_bone_meal( + &self, + level: &mut L, + ticks: &mut Ticks, + pos: BlockPos, + face: Direction, + ) -> bool { + let mut sim = self.sim(level, ticks); + if sim.grow_crop(pos) { + sim.level_event(1505, pos, 15); + return true; + } + let clicked = sim.state(pos); + let relative = rel(pos, face); + if self.is_face_sturdy(clicked, face) && sim.grow_water_plant(relative, Some(face)) { + sim.level_event(1505, relative, 15); + return true; + } + false + } + /// `BoneMealItem.growCrop` (dispensers call this directly). + pub fn grow_crop( + &self, + level: &mut L, + ticks: &mut Ticks, + pos: BlockPos, + ) -> bool { + self.sim(level, ticks).grow_crop(pos) + } + /// `BoneMealItem.growWaterPlant` (dispensers pass no clicked face). + pub fn grow_water_plant( + &self, + level: &mut L, + ticks: &mut Ticks, + pos: BlockPos, + face: Option, + ) -> bool { + self.sim(level, ticks).grow_water_plant(pos, face) + } + /// The `BonemealableBlock.Type` particle spread of a block at level event + /// 1505: Some(true) for `NEIGHBOR_SPREADER` (particles over a 3-block + /// area above), Some(false) for `GROWER`, None when not bonemealable. + pub fn bone_meal_spreads(&self, state: BlockStateId) -> Option { + let kind = self.bonemeal_kind(state)?; + Some(matches!( + kind, + Kind::Grass | Kind::Nylium | Kind::Netherrack | Kind::FeaturePlacer + )) + } + fn bonemeal_kind(&self, state: BlockStateId) -> Option { + let data = self.data(state); + if !data.implements(Interface::Bonemealable) { + return None; + } + data.chain.iter().find_map(|&c| kind_of(c)) + } +} + +impl Sim<'_, L> { + fn next_int(&mut self, bound: i32) -> i32 { + self.random().next_int_bound(bound).unwrap_or(0) + } + fn block_named(&self, name: &str) -> Option { + let b = self.b; + b.table.block_by_name(name).map(|id| b.default_of(id)) + } + fn in_tag(&self, state: BlockStateId, tag: &str) -> bool { + self.b.tag(tag).is_some_and(|set| self.b.in_set(state, set)) + } + + /// `BoneMealItem.growCrop`: true when the block is a valid target (bone + /// meal is consumed even when `isBonemealSuccess` fails). + pub(crate) fn grow_crop(&mut self, pos: BlockPos) -> bool { + let state = self.state(pos); + let Some(kind) = self.b.bonemeal_kind(state) else { + return false; + }; + if !self.bonemeal_valid(kind, pos, state) { + return false; + } + if self.bonemeal_success(kind, pos, state) { + self.perform_bonemeal(kind, pos, state); + } + true + } + + /// `BonemealableBlock.isValidBonemealTarget`. + fn bonemeal_valid(&mut self, kind: Kind, pos: BlockPos, state: BlockStateId) -> bool { + let b = self.b; + let p = b.props; + let up = above(pos); + match kind { + Kind::Sapling => { + let Some(g) = b.data(state).feature.as_deref().and_then(grower) else { + return false; + }; + if b.live_features().is_none() || !self.tree_can_grow(g, pos, state) { + return false; + } + let height = self.tree_minimum_height(g); + self.is_inside_build_height(pos.y + height) + } + Kind::Propagule => !b.table.bool(state, p.hanging) || b.table.int(state, p.age) != 4, + Kind::Mushroom => { + let Some(feature) = b.data(state).feature.as_deref() else { + return false; + }; + let Some(json) = b.live_features().and_then(|f| f.configured_json(feature)) else { + return false; + }; + let huge = matches!( + json["type"].as_str(), + Some("minecraft:huge_red_mushroom" | "minecraft:huge_brown_mushroom") + ); + let radius = json["foliage_radius"].as_i64().unwrap_or(2) as i32; + huge && self.is_inside_build_height(pos.y + 4 + radius) + } + Kind::Fungus => { + let below_state = self.below_state(pos); + b.data(state) + .link + .is_some_and(|required| b.is_block(below_state, required)) + && self.is_inside_build_height(pos.y + 1) + } + Kind::Azalea => { + let Some(g) = grower("azalea") else { + return false; + }; + let height = self.tree_minimum_height(g); + self.is_inside_build_height(pos.y + height + 2) + && self.fluid_at(up) == FluidState::EMPTY + } + Kind::Grass | Kind::Nylium | Kind::BambooSapling => { + b.is_air(self.state(up)) && self.is_inside_build_height(up.y) + } + Kind::Netherrack => { + if !b.has_flag(self.state(up), super::data::state_flags::SKYLIGHT_DOWN) { + return false; + } + self.netherrack_nylium_near(pos) != (false, false) + } + Kind::FeaturePlacer => b.is_air(self.state(up)), + Kind::RootedDirt => { + b.is_air(self.state(below(pos))) && self.is_inside_build_height(pos.y - 1) + } + Kind::MangroveLeaves => b.is_air(self.state(below(pos))), + Kind::Crop => b.table.int(state, p.age) < self.crop_max_age(state), + Kind::Stem => b.table.int(state, p.age) != 7, + Kind::Pitcher => match self.pitcher_lower(pos, state) { + Some((lower_pos, lower)) => { + let age = b.table.int(lower, p.age) + 1; + self.pitcher_can_grow(lower_pos, lower, age) + } + None => false, + }, + Kind::Bamboo => { + let height_above = self.bamboo_height_above(pos); + let height_below = self.bamboo_height_below(pos); + let growth = pos.offset(0, height_above + 1, 0); + height_above + height_below + 1 < 16 + && b.table + .int(self.state(pos.offset(0, height_above, 0)), p.stage) + != 1 + && self.is_inside_build_height(growth.y) + && self.is_empty_block(growth) + } + Kind::Cocoa => b.table.int(state, p.age) < 2, + Kind::SweetBerry => b.table.int(state, p.age) < 3, + Kind::TallGrass => { + let Some(grown) = self.tall_grass_grown(state) else { + return false; + }; + self.can_survive(grown, pos) + && self.is_empty_block(up) + && self.is_inside_build_height(up.y) + } + Kind::TallFlower | Kind::FlowerBed | Kind::SmallDripleaf | Kind::ShortDryGrass => true, + Kind::SpreadingBush => self.spreadable_neighbour(pos, state, false).is_some(), + Kind::TallDryGrass => { + let Some(short) = self.block_named("minecraft:short_dry_grass") else { + return false; + }; + self.spreadable_neighbour(pos, short, false).is_some() + } + Kind::PlantHead => { + let growth = rel(pos, b.data(state).growth_direction); + self.plant_can_grow_into(state, self.state(growth)) + && self.is_inside_build_height(growth.y) + } + Kind::CaveVines | Kind::CaveVinesPlant => !b.table.bool(state, p.berries), + Kind::PlantBody => match self.plant_head_pos(pos, state) { + Some(head) => { + let head_state = self.state(head); + let growth = rel(head, b.data(state).growth_direction); + self.plant_can_grow_into(head_state, self.state(growth)) + && self.is_inside_build_height(growth.y) + } + None => false, + }, + Kind::Seagrass => b.is_block(self.state(up), b.named.water), + Kind::SeaPickle => { + b.table.bool(state, p.waterlogged) + && self.in_tag(self.below_state(pos), "minecraft:coral_blocks") + } + Kind::BigDripleaf => self.dripleaf_can_grow_into(up), + Kind::BigDripleafStem => { + let Some(leaf) = b.table.block_by_name("minecraft:big_dripleaf") else { + return false; + }; + self.top_connected(pos, b.block(state), Direction::Up, leaf) + .is_some_and(|head| self.dripleaf_can_grow_into(above(head))) + } + Kind::GlowLichen => Direction::ALL + .iter() + .any(|&face| self.lichen_can_spread_in_any_direction(state, pos, face.opposite())), + Kind::HangingMoss => { + let grow = below(self.hanging_moss_tip(pos, state)); + b.is_air(self.state(grow)) && self.is_inside_build_height(grow.y) + } + Kind::MossyCarpet => { + b.table.bool(state, p.bottom) && !b.is_air(self.mossy_topper_all_sides(pos)) + } + Kind::ShelfMushroom => b.table.int(state, p.age) < 1, + } + } + + /// `BonemealableBlock.isBonemealSuccess`. + fn bonemeal_success(&mut self, kind: Kind, _pos: BlockPos, state: BlockStateId) -> bool { + let b = self.b; + match kind { + Kind::Sapling | Kind::Azalea => self.random().next_float() < 0.45, + Kind::Propagule => { + if b.table.bool(state, b.props.hanging) { + b.table.int(state, b.props.age) != 4 + } else { + self.random().next_float() < 0.45 + } + } + Kind::Mushroom | Kind::Fungus => self.random().next_float() < 0.4, + _ => true, + } + } + + /// `BonemealableBlock.performBonemeal`. + fn perform_bonemeal(&mut self, kind: Kind, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let p = b.props; + let up = above(pos); + match kind { + Kind::Sapling => self.advance_tree(pos, state), + Kind::Propagule => { + if b.table.bool(state, p.hanging) && b.table.int(state, p.age) != 4 { + self.set_block(pos, b.table.cycle(state, p.age), 2); + } else { + self.advance_tree(pos, state); + } + } + Kind::Mushroom => { + self.grow_mushroom(pos, state); + } + Kind::Fungus => { + if let Some(feature) = b.data(state).feature.clone() { + self.place_configured_feature(&feature, pos); + } + } + Kind::Azalea => { + if let Some(g) = grower("azalea") { + self.grow_tree(g, pos, state); + } + } + Kind::Grass => self.grass_bonemeal(pos, state), + Kind::Nylium => { + if self.is_inside_build_height(up.y) { + self.place_configured_feature("minecraft:nylium_bonemeal", up); + } + } + Kind::Netherrack => { + let (warped, crimson) = self.netherrack_nylium_near(pos); + let warped_state = self.block_named("minecraft:warped_nylium"); + let crimson_state = self.block_named("minecraft:crimson_nylium"); + let next = if warped && crimson { + if self.random().next_boolean() { + warped_state + } else { + crimson_state + } + } else if warped { + warped_state + } else if crimson { + crimson_state + } else { + None + }; + if let Some(next) = next { + self.set_block_and_update(pos, next); + } + } + Kind::FeaturePlacer => { + if let Some(feature) = b.data(state).feature.clone() { + self.place_configured_feature(&feature, up); + } + } + Kind::RootedDirt => { + if let Some(roots) = self.block_named("minecraft:hanging_roots") { + self.set_block_and_update(below(pos), roots); + } + } + Kind::MangroveLeaves => { + if let Some(propagule) = self.block_named("minecraft:mangrove_propagule") { + let hanging = b.table.set_bool(propagule, p.hanging, true); + self.set_block(below(pos), b.table.set_int(hanging, p.age, 0), 2); + } + } + Kind::Crop => { + let max = self.crop_max_age(state); + let increase = self.crop_bonemeal_increase(state); + let age = max.min(b.table.int(state, p.age) + increase); + let next = self.crop_state_for_age(state, age); + self.set_block(pos, next, 2); + } + Kind::Stem => { + let increase = next_int_between(self.random(), 2, 5); + let age = 7.min(b.table.int(state, p.age) + increase); + let next = b.table.set_int(state, p.age, age); + self.set_block(pos, next, 2); + if age == 7 { + self.random_tick_block(next, pos); + } + } + Kind::Pitcher => { + if let Some((lower_pos, lower)) = self.pitcher_lower(pos, state) { + self.pitcher_grow(lower, lower_pos, 1); + } + } + Kind::BambooSapling => self.bamboo_sapling_grow(pos), + Kind::Bamboo => { + let mut height_above = self.bamboo_height_above(pos); + let height_below = self.bamboo_height_below(pos); + let mut total = height_above + height_below + 1; + let count = 1 + self.next_int(2); + for _ in 0..count { + let top = pos.offset(0, height_above, 0); + let top_state = self.state(top); + let growth = above(top); + if total >= 16 + || b.table.int(top_state, p.stage) == 1 + || !self.is_empty_block(growth) + || !self.is_inside_build_height(growth.y) + { + return; + } + self.bamboo_grow(top_state, top, total); + height_above += 1; + total += 1; + } + } + Kind::Cocoa => { + let age = b.table.int(state, p.age); + self.set_block(pos, b.table.set_int(state, p.age, age + 1), 2); + } + Kind::SweetBerry => { + let age = 3.min(b.table.int(state, p.age) + 1); + self.set_block(pos, b.table.set_int(state, p.age, age), 2); + } + Kind::TallGrass => { + if let Some(grown) = self.tall_grass_grown(state) { + self.double_plant_place_at(grown, pos, 2); + } + } + Kind::TallFlower => self.pop_block_item(pos, state), + Kind::SpreadingBush => { + if let Some(at) = self.spreadable_neighbour(pos, state, true) { + self.set_block_and_update(at, b.default_of(b.block(state))); + } + } + Kind::TallDryGrass => { + if let Some(short) = self.block_named("minecraft:short_dry_grass") + && let Some(at) = self.spreadable_neighbour(pos, short, true) + { + self.set_block_and_update(at, short); + } + } + Kind::ShortDryGrass => { + if let Some(tall) = self.block_named("minecraft:tall_dry_grass") { + self.set_block_and_update(pos, tall); + } + } + Kind::FlowerBed => { + let amount = b.table.int(state, p.flower_amount); + if amount < 4 { + self.set_block(pos, b.table.set_int(state, p.flower_amount, amount + 1), 2); + } else { + self.pop_block_item(pos, state); + } + } + Kind::PlantHead => self.plant_head_bonemeal(pos, state), + Kind::CaveVines | Kind::CaveVinesPlant => { + self.set_block(pos, b.table.set_bool(state, p.berries, true), 2); + } + Kind::PlantBody => { + if let Some(head) = self.plant_head_pos(pos, state) { + let head_state = self.state(head); + match b.bonemeal_kind(head_state) { + Some(Kind::CaveVines) => { + self.set_block(head, b.table.set_bool(head_state, p.berries, true), 2); + } + Some(Kind::PlantHead) => self.plant_head_bonemeal(head, head_state), + _ => {} + } + } + } + Kind::Seagrass => { + let lower = b.default_of(b.named.tall_seagrass); + let upper = b.table.set_text(lower, p.half, "upper"); + self.set_block(pos, lower, 2); + self.set_block(up, upper, 2); + } + Kind::SeaPickle => self.sea_pickle_bonemeal(pos, state), + Kind::BigDripleaf => { + if self.dripleaf_can_grow_into(up) { + let facing = b.facing(state); + let fluid = b.fluid(state); + self.dripleaf_stem_place(pos, fluid, facing); + let fluid_above = self.fluid_at(up); + self.dripleaf_place(up, fluid_above, facing); + } + } + Kind::BigDripleafStem => { + let Some(leaf) = b.table.block_by_name("minecraft:big_dripleaf") else { + return; + }; + if let Some(head) = self.top_connected(pos, b.block(state), Direction::Up, leaf) { + let facing = b.facing(state); + let fluid = self.fluid_at(head); + self.dripleaf_stem_place(head, fluid, facing); + let fluid_above = self.fluid_at(above(head)); + self.dripleaf_place(above(head), fluid_above, facing); + } + } + Kind::SmallDripleaf => { + if b.table.text(state, p.half) == "lower" { + let empty = b.legacy_block(self.fluid_at(up)); + self.set_block(up, empty, 18); + let facing = b.facing(state); + self.dripleaf_place_random_height(pos, facing); + } else { + let below_pos = below(pos); + let below_state = self.state(below_pos); + if b.bonemeal_kind(below_state) == Some(Kind::SmallDripleaf) { + self.perform_bonemeal(Kind::SmallDripleaf, below_pos, below_state); + } else { + // performBonemeal on a non-dripleaf below: vanilla reads + // FACING/HALF of that state and would throw; do nothing. + } + } + } + Kind::GlowLichen => self.lichen_spread_random(pos, state), + Kind::HangingMoss => { + let tip = below(self.hanging_moss_tip(pos, state)); + if b.is_air(self.state(tip)) { + self.set_block_and_update(tip, b.table.set_bool(state, p.tip, true)); + } + } + Kind::MossyCarpet => { + let topper = self.mossy_topper_all_sides(pos); + if !b.is_air(topper) { + self.set_block_and_update(up, topper); + } + } + Kind::ShelfMushroom => { + let age = b.table.int(state, p.age); + self.set_block(pos, b.table.set_int(state, p.age, age + 1), 2); + } + } + } + + // ---- helpers ---- + + /// `Block.popResource(level, pos, new ItemStack(this))`. + fn pop_block_item(&mut self, pos: BlockPos, state: BlockStateId) { + self.emit(LevelEvent::BlockEvent { + pos, + state, + kind: "pop_block_item", + }); + } + /// `CropBlock.getMaxAge`. + pub(crate) fn crop_max_age(&self, state: BlockStateId) -> i32 { + let b = self.b; + if b.instance_of(state, Class::TorchflowerCrop) { + 2 + } else { + b.table.int_range(state, b.props.age).map_or(7, |r| r.1) + } + } + /// `CropBlock.getStateForAge` (torchflower crops become torchflowers). + pub(crate) fn crop_state_for_age(&self, state: BlockStateId, age: i32) -> BlockStateId { + let b = self.b; + if b.instance_of(state, Class::TorchflowerCrop) + && age == 2 + && let Some(flower) = self.block_named("minecraft:torchflower") + { + return flower; + } + b.table + .set_int(b.default_of(b.block(state)), b.props.age, age) + } + /// `CropBlock.getBonemealAgeIncrease` and its overrides. + fn crop_bonemeal_increase(&mut self, state: BlockStateId) -> i32 { + let b = self.b; + if b.instance_of(state, Class::TorchflowerCrop) { + 1 + } else if b.instance_of(state, Class::Beetroot) { + next_int_between(self.random(), 2, 5) / 3 + } else { + next_int_between(self.random(), 2, 5) + } + } + /// `PitcherCropBlock.getLowerHalf`. + fn pitcher_lower( + &self, + pos: BlockPos, + state: BlockStateId, + ) -> Option<(BlockPos, BlockStateId)> { + let b = self.b; + let is_lower = |s: BlockStateId| { + b.is_block(s, b.named.pitcher_crop) && b.table.text(s, b.props.half) == "lower" + }; + if is_lower(state) { + return Some((pos, state)); + } + let below_pos = below(pos); + let below_state = self.state(below_pos); + is_lower(below_state).then_some((below_pos, below_state)) + } + /// `PitcherCropBlock.canGrow`. + fn pitcher_can_grow(&self, lower_pos: BlockPos, lower: BlockStateId, new_age: i32) -> bool { + let b = self.b; + let upper = self.state(above(lower_pos)); + b.table.int(lower, b.props.age) < 4 + && self.raw_brightness(lower_pos, 0) >= 8 + && self.is_inside_build_height(lower_pos.y + 1) + && (new_age < 3 || b.is_air(upper) || b.is_block(upper, b.named.pitcher_crop)) + } + /// `TallGrassBlock.getGrownBlock`. + fn tall_grass_grown(&self, state: BlockStateId) -> Option { + let name = if self.b.table.name(state) == "minecraft:fern" { + "minecraft:large_fern" + } else { + "minecraft:tall_grass" + }; + self.block_named(name) + } + /// `DoublePlantBlock.placeAt`. + fn double_plant_place_at(&mut self, state: BlockStateId, lower: BlockPos, flags: i32) { + let b = self.b; + let p = b.props; + let upper = above(lower); + let lower_state = b.table.set_text(state, p.half, "lower"); + let lower_state = b + .table + .with_bool(lower_state, p.waterlogged, self.is_water_at(lower)) + .unwrap_or(lower_state); + self.set_block(lower, lower_state, flags); + let upper_state = b.table.set_text(state, p.half, "upper"); + let upper_state = b + .table + .with_bool(upper_state, p.waterlogged, self.is_water_at(upper)) + .unwrap_or(upper_state); + self.set_block(upper, upper_state, flags); + } + /// `BonemealableBlock.getSpreadableNeighbourPos` (shuffled order when + /// `shuffle`, as `findSpreadableNeighbourPos`). + fn spreadable_neighbour( + &mut self, + pos: BlockPos, + to_place: BlockStateId, + shuffle: bool, + ) -> Option { + let mut directions = HORIZONTAL; + if shuffle { + // Util.shuffle. + for i in (2..=directions.len()).rev() { + let swap = self.next_int(i as i32) as usize; + directions.swap(i - 1, swap); + } + } + directions + .into_iter() + .map(|d| rel(pos, d)) + .find(|&n| self.is_empty_block(n) && self.can_survive(to_place, n)) + } + /// `NetherrackBlock`: (warped nylium nearby, crimson nylium nearby). + fn netherrack_nylium_near(&self, pos: BlockPos) -> (bool, bool) { + let (mut warped, mut crimson) = (false, false); + for x in -1..=1 { + for y in -1..=1 { + for z in -1..=1 { + let state = self.state(pos.offset(x, y, z)); + if !self.in_tag(state, "minecraft:nylium") { + continue; + } + match self.b.table.name(state) { + "minecraft:warped_nylium" => warped = true, + "minecraft:crimson_nylium" => crimson = true, + _ => {} + } + if warped && crimson { + return (true, true); + } + } + } + } + (warped, crimson) + } + /// `GrowingPlantHeadBlock.canGrowInto` of the head's block. + fn plant_can_grow_into(&self, head: BlockStateId, state: BlockStateId) -> bool { + let b = self.b; + if b.instance_of(head, Class::Kelp) { + b.is_block(state, b.named.water) + } else { + b.is_air(state) + } + } + /// `GrowingPlantHeadBlock.performBonemeal`. + fn plant_head_bonemeal(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let direction = b.data(state).growth_direction; + let mut forward = rel(pos, direction); + let mut next_age = (b.table.int(state, b.props.age) + 1).min(25); + let count = if b.instance_of(state, Class::TwistingVines) + || b.instance_of(state, Class::WeepingVines) + { + // NetherVines.getBlocksToGrowWhenBonemealed. + let mut probability = 1.0; + let mut count = 0; + while self.random().next_double() < probability { + probability *= 0.826; + count += 1; + } + count + } else { + 1 + }; + for _ in 0..count { + if !self.plant_can_grow_into(state, self.state(forward)) + || !self.is_inside_build_height(forward.y) + { + break; + } + self.set_block_and_update(forward, b.table.set_int(state, b.props.age, next_age)); + forward = rel(forward, direction); + next_age = (next_age + 1).min(25); + } + } + /// `GrowingPlantBodyBlock.getHeadPos` (`BlockUtil.getTopConnectedBlock`). + fn plant_head_pos(&self, pos: BlockPos, state: BlockStateId) -> Option { + let b = self.b; + let name = b.table.name(state); + let head = b.table.block_by_name(name.strip_suffix("_plant")?)?; + self.top_connected(pos, b.block(state), b.data(state).growth_direction, head) + } + /// `BlockUtil.getTopConnectedBlock`. + fn top_connected( + &self, + pos: BlockPos, + body: super::states::BlockId, + direction: Direction, + head: super::states::BlockId, + ) -> Option { + let mut forward = pos; + loop { + forward = rel(forward, direction); + let state = self.state(forward); + if !self.b.is_block(state, body) { + return self.b.is_block(state, head).then_some(forward); + } + if !self.level.is_loaded(forward) || !self.is_in_valid_bounds(forward) { + return None; + } + } + } + /// `HangingMossBlock.getTip`. + fn hanging_moss_tip(&self, pos: BlockPos, state: BlockStateId) -> BlockPos { + let block = self.b.block(state); + let mut forward = pos; + loop { + forward = below(forward); + if !self.b.is_block(self.state(forward), block) || forward.y < self.level.min_y() { + return above(forward); + } + } + } + /// `MossyCarpetBlock.createTopperWithSideChance(level, pos, () -> true)`. + fn mossy_topper_all_sides(&mut self, pos: BlockPos) -> BlockStateId { + let b = self.b; + let p = b.props; + let block = b.block(self.state(pos)); + let above_pos = above(pos); + let above_state = self.state(above_pos); + let is_carpet = b.is_block(above_state, block); + if (!is_carpet || !b.table.bool(above_state, p.bottom)) + && (is_carpet || b.is_replaceable(above_state)) + { + let carpet = b.table.set_bool(b.default_of(block), p.bottom, false); + let topper = self.mossy_carpet_updated_state(carpet, above_pos, true); + if self.mossy_carpet_has_faces(topper) && topper != above_state { + return topper; + } + } + b.air() + } + /// `SeaPickleBlock.performBonemeal`. + fn sea_pickle_bonemeal(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let p = b.props; + let (mut z_span, mut z_offset) = (1, 0); + let x_start = pos.x - 2; + for (count, x) in (0..5).enumerate() { + for z in 0..z_span { + let end_y = 2 + pos.y - 1; + for y in (end_y - 2)..end_y { + let position = BlockPos::new(x_start + x, y, pos.z - z_offset + z); + if position != pos + && self.next_int(6) == 0 + && b.is_block(self.state(position), b.named.water) + && self.in_tag(self.below_state(position), "minecraft:coral_blocks") + { + let pickles = self.next_int(4) + 1; + let pickle = + b.table + .set_int(b.default_of(b.block(state)), p.pickles, pickles); + self.set_block_and_update(position, pickle); + } + } + } + if count < 2 { + z_span += 2; + z_offset += 1; + } else { + z_span -= 2; + z_offset -= 1; + } + } + self.set_block(pos, b.table.set_int(state, p.pickles, 4), 2); + } + /// `BigDripleafBlock.canGrowInto` / `canPlaceAt`. + fn dripleaf_can_grow_into(&self, pos: BlockPos) -> bool { + let b = self.b; + let state = self.state(pos); + self.is_inside_build_height(pos.y) + && (b.is_air(state) + || b.is_block(state, b.named.water) + || b.table.name(state) == "minecraft:small_dripleaf") + } + fn dripleaf_set(&mut self, name: &str, pos: BlockPos, fluid: FluidState, facing: Direction) { + let b = self.b; + let Some(state) = self.block_named(name) else { + return; + }; + let state = b + .table + .set_bool(state, b.props.waterlogged, fluid == FluidState::WATER); + let state = b.table.set_dir(state, b.props.facing, facing); + self.set_block_and_update(pos, state); + } + fn dripleaf_place(&mut self, pos: BlockPos, fluid: FluidState, facing: Direction) { + self.dripleaf_set("minecraft:big_dripleaf", pos, fluid, facing); + } + fn dripleaf_stem_place(&mut self, pos: BlockPos, fluid: FluidState, facing: Direction) { + self.dripleaf_set("minecraft:big_dripleaf_stem", pos, fluid, facing); + } + /// `BigDripleafBlock.placeWithRandomHeight`. + fn dripleaf_place_random_height(&mut self, bottom: BlockPos, facing: Direction) { + let desired = next_int_between(self.random(), 2, 5); + let mut pos = bottom; + let mut height = 0; + while height < desired && self.dripleaf_can_grow_into(pos) { + height += 1; + pos = above(pos); + } + let leaf_y = bottom.y + height - 1; + pos = bottom; + while pos.y < leaf_y { + let fluid = self.fluid_at(pos); + self.dripleaf_stem_place(pos, fluid, facing); + pos = above(pos); + } + let fluid = self.fluid_at(pos); + self.dripleaf_place(pos, fluid, facing); + } + + // ---- MultifaceSpreader (glow lichen, default config) ---- + + /// `SpreadType.getSpreadPos` for SAME_POSITION, SAME_PLANE, WRAP_AROUND. + fn spread_positions( + pos: BlockPos, + spread: Direction, + from: Direction, + ) -> [(BlockPos, Direction); 3] { + [ + (pos, spread), + (rel(pos, spread), from), + (rel(rel(pos, spread), from), spread.opposite()), + ] + } + /// `DefaultSpreaderConfig.canSpreadInto`. + fn lichen_can_spread_into( + &self, + block: super::states::BlockId, + at: BlockPos, + face: Direction, + ) -> bool { + let b = self.b; + let existing = self.state(at); + let replaceable = b.is_air(existing) + || b.is_block(existing, block) + || (b.is_block(existing, b.named.water) && b.fluid(existing).is_source()); + replaceable + && !(b.is_block(existing, block) && self.multiface_has_face(existing, face)) + && b.multiface_can_attach(self.state(rel(at, face)), face) + } + /// `MultifaceSpreader.getSpreadFromFaceTowardDirection`. + fn lichen_spread_target( + &self, + state: BlockStateId, + pos: BlockPos, + from: Direction, + spread: Direction, + ) -> Option<(BlockPos, Direction)> { + if crate::level::query::axis_of(spread) == crate::level::query::axis_of(from) { + return None; + } + if !(self.multiface_has_face(state, from) && !self.multiface_has_face(state, spread)) { + return None; + } + let block = self.b.block(state); + Self::spread_positions(pos, spread, from) + .into_iter() + .find(|&(at, face)| self.lichen_can_spread_into(block, at, face)) + } + fn lichen_can_spread_in_any_direction( + &self, + state: BlockStateId, + pos: BlockPos, + from: Direction, + ) -> bool { + Direction::ALL.iter().any(|&spread| { + self.lichen_spread_target(state, pos, from, spread) + .is_some() + }) + } + fn shuffled_directions(&mut self) -> [Direction; 6] { + let mut directions = Direction::ALL; + for i in (2..=directions.len()).rev() { + let swap = self.next_int(i as i32) as usize; + directions.swap(i - 1, swap); + } + directions + } + /// `MultifaceSpreader.spreadFromRandomFaceTowardRandomDirection`. + fn lichen_spread_random(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let block = b.block(state); + for from in self.shuffled_directions() { + if !self.multiface_has_face(state, from) { + continue; + } + for spread in self.shuffled_directions() { + let Some((at, face)) = self.lichen_spread_target(state, pos, from, spread) else { + continue; + }; + let old = self.state(at); + // MultifaceBlock.getStateForPlacement then setBlock(..., 2). + let base = if b.is_block(old, block) { + old + } else if b.fluid(old) == FluidState::WATER { + b.table + .set_bool(b.default_of(block), b.props.waterlogged, true) + } else { + b.default_of(block) + }; + let placed = b.table.set_bool(base, self.direction_prop(face), true); + if self.set_block(at, placed, 2) { + return; + } + } + } + } + + // ---- water plants and grass ---- + + /// `BoneMealItem.growWaterPlant`. + pub(crate) fn grow_water_plant(&mut self, pos: BlockPos, face: Option) -> bool { + let b = self.b; + let start = self.state(pos); + if !(b.is_block(start, b.named.water) && b.fluid(start).amount() == 8) { + return false; + } + let seagrass = b.default_of(b.named.seagrass); + let features = b.live_features(); + 'attempts: for j in 0..128 { + let mut test = pos; + let mut grow = seagrass; + for _ in 0..j / 16 { + let dx = self.next_int(3) - 1; + let dy = (self.next_int(3) - 1) * self.next_int(3) / 2; + let dz = self.next_int(3) - 1; + test = test.offset(dx, dy, dz); + if b.full_collision(self.state(test)) { + continue 'attempts; + } + } + let corals = match (features, self.level.biome_name(test)) { + (Some(f), Some(biome)) => { + f.biome_in_tag(biome, "minecraft:produces_corals_from_bonemeal") + } + _ => false, + }; + if corals { + if j == 0 && face.is_some_and(|f| !matches!(f, Direction::Up | Direction::Down)) { + if let Some(coral) = self.random_tag_element("minecraft:wall_corals") { + grow = coral; + if b.table.has(grow, b.props.facing) { + grow = b.table.set_dir(grow, b.props.facing, face.unwrap()); + } + } + } else if self.next_int(4) == 0 + && let Some(plant) = self.random_tag_element("minecraft:underwater_bonemeals") + { + grow = plant; + } + } + if self.in_tag(grow, "minecraft:wall_corals") && b.table.has(grow, b.props.facing) { + let mut d = 0; + while !self.can_survive(grow, test) && d < 4 { + let facing = HORIZONTAL[self.next_int(4) as usize]; + grow = b.table.set_dir(grow, b.props.facing, facing); + d += 1; + } + } + if self.can_survive(grow, test) { + let test_state = self.state(test); + if b.is_block(test_state, b.named.water) && b.fluid(test_state).amount() == 8 { + self.set_block_and_update(test, grow); + } else if b.is_block(test_state, b.named.seagrass) + && b.is_block(self.state(above(test)), b.named.water) + && self.next_int(10) == 0 + { + self.perform_bonemeal(Kind::Seagrass, test, test_state); + } + } + } + true + } + /// `Registry.getRandomElementOf(tag, random)`: default state of a random member. + fn random_tag_element(&mut self, tag: &str) -> Option { + let features = self.b.live_features()?; + let entries = features.block_tag_entries(tag); + if entries.is_empty() { + return None; + } + let index = self.next_int(entries.len() as i32) as usize; + self.block_named(&entries[index]) + } + /// `GrassBlock.performBonemeal`. + fn grass_bonemeal(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let block = b.block(state); + let start = above(pos); + 'attempts: for attempt in 0..128 { + let mut test = start; + for _ in 0..attempt / 16 { + let dx = self.next_int(3) - 1; + let dy = (self.next_int(3) - 1) * self.next_int(3) / 2; + let dz = self.next_int(3) - 1; + test = test.offset(dx, dy, dz); + // stopBonemealSpread + if !b.is_block(self.below_state(test), block) || b.full_collision(self.state(test)) + { + continue 'attempts; + } + } + self.grass_bonemeal_effect(test); + } + } + /// `GrassBlock.placeBonemealEffect`. + fn grass_bonemeal_effect(&mut self, test: BlockPos) { + let b = self.b; + let test_state = self.state(test); + if b.table.name(test_state) == "minecraft:short_grass" + && self.random().next_float() < 0.1 + && self.bonemeal_valid(Kind::TallGrass, test, test_state) + { + self.perform_bonemeal(Kind::TallGrass, test, test_state); + } + if b.is_air(test_state) && self.is_inside_build_height(test.y) { + if self.random().next_float() < 0.125 { + let Some(features) = b.live_features() else { + return; + }; + let Some(biome) = self + .level + .biome_name(test) + .and_then(|name| features.biome_id(name)) + else { + return; + }; + let list = features.bone_meal_features(biome); + if list.is_empty() { + return; + } + let feature = list[self.next_int(list.len() as i32) as usize].clone(); + self.place_configured_feature(&feature, test); + } else { + self.place_placed_feature("minecraft:grass_bonemeal", test); + } + } + } +} diff --git a/crates/horizon-world/src/level/data.rs b/crates/horizon-world/src/level/data.rs index 854248aa7..73efe9158 100644 --- a/crates/horizon-world/src/level/data.rs +++ b/crates/horizon-world/src/level/data.rs @@ -1084,6 +1084,7 @@ pub(super) fn load(registry: &BlockRegistry, root: &Path) -> io::Result { + pub sim: &'s mut Sim<'a, L>, + pub features: &'s LiveFeatures, +} + +fn pos([x, y, z]: [i32; 3]) -> BlockPos { + BlockPos::new(x, y, z) +} + +impl LevelFeatureWorld<'_, '_, L> { + fn sea(&self) -> i32 { + match self.sim.level.dimension() { + super::Dimension::Nether => 32, + super::Dimension::End => 0, + super::Dimension::Overworld => 63, + } + } + fn in_tag(&self, state: BlockStateId, tag: &str) -> bool { + let name = tag.trim_start_matches('#'); + self.sim + .b + .tag(name) + .is_some_and(|set| set.contains(self.sim.b.block(state))) + } +} + +impl FeatureWorld for LevelFeatureWorld<'_, '_, L> { + type Error = PlacementQueryError; + fn block(&mut self, position: [i32; 3]) -> Result { + Ok(self.sim.state(pos(position))) + } + fn set_block( + &mut self, + position: [i32; 3], + state: BlockStateId, + flags: i32, + ) -> Result { + Ok(self.sim.set_block(pos(position), state, flags)) + } +} + +impl PlacementContext for LevelFeatureWorld<'_, '_, L> { + /// `StructureTemplate.updateShapeAtEdge` for one face. + fn update_shape_at_face( + &mut self, + position: [i32; 3], + direction: Direction, + flags: i32, + ) -> Result<(), PlacementQueryError> { + let place = pos(position); + let neighbour_pos = rel(place, direction); + let state = self.sim.state(place); + let neighbour = self.sim.state(neighbour_pos); + let new_state = self + .sim + .update_shape(state, place, direction, neighbour_pos, neighbour); + if new_state != state { + self.sim.set_block(place, new_state, flags & !1); + } + let new_neighbour = self.sim.update_shape( + neighbour, + neighbour_pos, + direction.opposite(), + place, + new_state, + ); + if new_neighbour != neighbour { + self.sim.set_block(neighbour_pos, new_neighbour, flags & !1); + } + Ok(()) + } + fn set_section_block( + &mut self, + position: [i32; 3], + state: BlockStateId, + ) -> Result<(), PlacementQueryError> { + self.sim.level.set_raw(pos(position), state); + Ok(()) + } + fn collision_full_block( + &mut self, + state: BlockStateId, + _position: [i32; 3], + ) -> Result { + Ok(self.sim.b.full_collision(state)) + } + fn world_seed(&mut self) -> Result { + Ok(self.sim.level.world_seed()) + } + fn state_collision_empty( + &mut self, + state: BlockStateId, + _position: [i32; 3], + ) -> Result { + Ok(self.sim.b.has_flag(state, state_flags::COLLISION_EMPTY)) + } + /// Live levels hold no loot-table containers placed by these features. + fn set_block_entity_loot_table( + &mut self, + _position: [i32; 3], + _table: &str, + _random: &mut impl RandomSource, + ) -> Result<(), PlacementQueryError> { + Ok(()) + } + fn block_brightness(&mut self, position: [i32; 3]) -> Result { + Ok(self.sim.level.block_light(pos(position))) + } + fn fluid_state(&mut self, position: [i32; 3]) -> Result { + Ok(self.sim.fluid_at(pos(position))) + } + fn destroy_block_without_entity( + &mut self, + position: [i32; 3], + drop_resources: bool, + ) -> Result { + Ok(self + .sim + .destroy_block(pos(position), drop_resources, super::flags::UPDATE_LIMIT)) + } + fn sea_level(&mut self) -> Result { + Ok(self.sea()) + } + fn schedule_fluid_tick( + &mut self, + position: [i32; 3], + fluid: FluidKind, + delay: i32, + ) -> Result<(), PlacementQueryError> { + self.sim.schedule_fluid_tick(pos(position), fluid, delay); + Ok(()) + } + /// Live chunks are already post-processed. + fn mark_postprocessing(&mut self, _position: [i32; 3]) -> Result<(), PlacementQueryError> { + Ok(()) + } + fn water_at(&mut self, position: [i32; 3]) -> Result { + let kind = self.sim.fluid_at(pos(position)).kind(); + Ok(self.sim.b.is_water_fluid(kind)) + } + fn attachment_at( + &mut self, + position: [i32; 3], + direction: Direction, + ) -> Result { + let neighbour = self.sim.state(rel(pos(position), direction)); + Ok(self.sim.b.multiface_can_attach(neighbour, direction)) + } + fn next_world_boolean(&mut self) -> Result { + Ok(self.sim.random().next_boolean()) + } + fn next_world_float(&mut self) -> Result { + Ok(self.sim.random().next_float()) + } + fn next_world_int(&mut self, bound: i32) -> Result { + self.sim + .random() + .next_int_bound(bound) + .map_err(|e| PlacementQueryError::Failed(e.to_string())) + } + fn schedule_block_tick( + &mut self, + position: [i32; 3], + block: BlockStateId, + delay: i32, + ) -> Result<(), PlacementQueryError> { + let block = self.sim.b.block(block); + self.sim.schedule_tick(pos(position), block, delay); + Ok(()) + } + fn block_survives( + &mut self, + state: BlockStateId, + position: [i32; 3], + ) -> Result { + Ok(self.sim.can_survive(state, pos(position))) + } + fn state_face_sturdy( + &mut self, + state: BlockStateId, + _position: [i32; 3], + direction: Direction, + ) -> Result { + Ok(self.sim.b.is_face_sturdy(state, direction)) + } + fn face_sturdy( + &mut self, + position: [i32; 3], + direction: Direction, + ) -> Result { + let state = self.sim.state(pos(position)); + Ok(self.sim.b.is_face_sturdy(state, direction)) + } + fn center_sturdy( + &mut self, + position: [i32; 3], + direction: Direction, + ) -> Result { + let state = self.sim.state(pos(position)); + Ok(self.sim.b.is_face_sturdy_center(state, direction)) + } + fn unobstructed_block(&mut self, position: [i32; 3]) -> Result { + let stone = self.sim.b.default_of(self.sim.b.named.stone); + Ok(self.sim.level.is_unobstructed(pos(position), stone)) + } + fn biome_identity(&mut self, position: [i32; 3]) -> Result { + self.sim + .level + .biome_name(pos(position)) + .and_then(|name| self.features.biome_id(name)) + .ok_or(PlacementQueryError::Unavailable) + } + fn block_state(&mut self, position: [i32; 3]) -> Result { + Ok(self.sim.state(pos(position))) + } + fn block_matches_tag( + &mut self, + position: [i32; 3], + tag: &str, + ) -> Result { + let state = self.sim.state(pos(position)); + Ok(self.in_tag(state, tag)) + } + fn max_y(&mut self) -> Result { + Ok(self.sim.level.max_y() - 1) + } + fn layer_block(&mut self, position: [i32; 3]) -> Result { + let state = self.sim.state(pos(position)); + let b = self.sim.b; + let block = b.block(state); + Ok( + if b.is_air(state) || block == b.named.water || block == b.named.lava { + LayerBlock::Empty + } else if b.table.name(state) == "minecraft:bedrock" { + LayerBlock::Bedrock + } else { + LayerBlock::Ground + }, + ) + } + fn generation(&self) -> WorldGenerationContext { + let min_y = self.sim.level.min_y(); + WorldGenerationContext::new(min_y, self.sim.level.max_y() - min_y, self.sea()) + } + fn min_y(&mut self) -> Result { + Ok(self.sim.level.min_y()) + } + /// `Level.getHeight(type, x, z)`: one above the highest matching block. + fn height(&mut self, kind: HeightmapType, x: i32, z: i32) -> Result { + let (min, max) = (self.sim.level.min_y(), self.sim.level.max_y()); + for y in (min..max).rev() { + let state = self.sim.state(BlockPos::new(x, y, z)); + let fluid = self.sim.b.fluid(state).kind() != FluidKind::Empty; + let matches = match kind { + HeightmapType::WorldSurface | HeightmapType::WorldSurfaceWg => { + !self.sim.b.is_air(state) + } + HeightmapType::OceanFloor | HeightmapType::OceanFloorWg => { + self.in_tag(state, "minecraft:blocks_motion_in_heightmap") + } + HeightmapType::MotionBlocking => { + fluid || self.in_tag(state, "minecraft:blocks_motion_in_heightmap") + } + HeightmapType::MotionBlockingNoLeaves => { + fluid || self.in_tag(state, "minecraft:blocks_motion_in_heightmap_no_leaves") + } + }; + if matches { + return Ok(y + 1); + } + } + Ok(min) + } +} diff --git a/crates/horizon-world/src/level/growth.rs b/crates/horizon-world/src/level/growth.rs new file mode 100644 index 000000000..bfc1d4482 --- /dev/null +++ b/crates/horizon-world/src/level/growth.rs @@ -0,0 +1,342 @@ +//! Feature-placing growth: `TreeGrower.growTree` (saplings, mangrove +//! propagules, azaleas), huge mushrooms and nether fungi, run on the live level +//! through [`LiveFeatures`]. +use super::{Behaviours, LevelAccess, LevelEvent, Sim, feature_world::LevelFeatureWorld, flags}; +use crate::{registry::BlockStateId, worldgen::live::LiveFeatures}; +use horizon_core::{position::BlockPos, random::RandomSource}; +use std::sync::{Arc, OnceLock}; + +/// Runtime extensions of [`Behaviours`] that depend on the worldgen bundle. +#[derive(Default)] +pub struct Growth { + features: OnceLock>, +} + +impl Behaviours { + /// Install the live feature registry used by sapling growth and bone meal. + /// Without it, saplings report [`LevelEvent::GrowTree`] instead of growing. + pub fn set_live_features(&self, features: Arc) -> bool { + self.growth.features.set(features).is_ok() + } + pub fn live_features(&self) -> Option<&Arc> { + self.growth.features.get() + } +} + +/// `TreeGrower` (vanilla's registered growers, by name). +pub(crate) struct TreeGrower { + pub name: &'static str, + trees: &'static [(&'static str, i32)], + mega_trees: &'static [(&'static str, i32)], + flower_trees: &'static [(&'static str, i32)], + shortest: Option<&'static str>, +} + +pub(crate) const GROWERS: &[TreeGrower] = &[ + TreeGrower { + name: "oak", + trees: &[("minecraft:oak", 9), ("minecraft:fancy_oak", 1)], + mega_trees: &[], + flower_trees: &[ + ("minecraft:oak_bees_005", 9), + ("minecraft:fancy_oak_bees_005", 1), + ], + shortest: Some("minecraft:oak"), + }, + TreeGrower { + name: "spruce", + trees: &[("minecraft:spruce", 1)], + mega_trees: &[("minecraft:mega_spruce", 1), ("minecraft:mega_pine", 1)], + flower_trees: &[], + shortest: Some("minecraft:spruce"), + }, + TreeGrower { + name: "mangrove", + trees: &[("minecraft:mangrove", 15), ("minecraft:tall_mangrove", 85)], + mega_trees: &[], + flower_trees: &[], + shortest: Some("minecraft:mangrove"), + }, + TreeGrower { + name: "azalea", + trees: &[("minecraft:azalea_tree", 1)], + mega_trees: &[], + flower_trees: &[], + shortest: Some("minecraft:azalea_tree"), + }, + TreeGrower { + name: "birch", + trees: &[("minecraft:birch", 1)], + mega_trees: &[], + flower_trees: &[("minecraft:birch_bees_005", 1)], + shortest: Some("minecraft:birch"), + }, + TreeGrower { + name: "jungle", + trees: &[("minecraft:jungle_tree_no_vine", 1)], + mega_trees: &[("minecraft:mega_jungle_tree", 1)], + flower_trees: &[], + shortest: Some("minecraft:jungle_tree_no_vine"), + }, + TreeGrower { + name: "acacia", + trees: &[("minecraft:acacia", 1)], + mega_trees: &[], + flower_trees: &[], + shortest: Some("minecraft:acacia"), + }, + TreeGrower { + name: "cherry", + trees: &[("minecraft:cherry", 1)], + mega_trees: &[], + flower_trees: &[("minecraft:cherry_bees_005", 1)], + shortest: Some("minecraft:cherry"), + }, + TreeGrower { + name: "dark_oak", + trees: &[], + mega_trees: &[("minecraft:dark_oak", 1)], + flower_trees: &[], + shortest: None, + }, + TreeGrower { + name: "pale_oak", + trees: &[], + mega_trees: &[("minecraft:pale_oak_bonemeal", 1)], + flower_trees: &[], + shortest: None, + }, + TreeGrower { + name: "poplar", + trees: &[ + ("minecraft:red_poplar", 1), + ("minecraft:orange_poplar", 1), + ("minecraft:yellow_poplar", 1), + ], + mega_trees: &[], + flower_trees: &[], + shortest: Some("minecraft:red_poplar"), + }, +]; + +pub(crate) fn grower(name: &str) -> Option<&'static TreeGrower> { + GROWERS.iter().find(|g| g.name == name) +} + +/// `WeightedList.getRandom`: no draw for an empty list. +fn weighted( + list: &'static [(&'static str, i32)], + random: &mut R, +) -> Option<&'static str> { + let total: i32 = list.iter().map(|e| e.1).sum(); + if total == 0 { + return None; + } + let mut selection = random.next_int_bound(total).unwrap_or(0); + for &(name, weight) in list { + if selection < weight { + return Some(name); + } + selection -= weight; + } + None +} + +impl Sim<'_, L> { + /// `ConfiguredFeature.place(level, generator, level.random, pos)`. The + /// feature draws from a copy of the level random that replaces it after. + pub(crate) fn place_configured_feature(&mut self, name: &str, pos: BlockPos) -> bool { + let b = self.b; + let Some(features) = b.live_features() else { + return false; + }; + let mut random = self.random().clone(); + let placed = { + let mut world = LevelFeatureWorld { + sim: self, + features, + }; + features.place_configured(name, &mut world, &mut random, [pos.x, pos.y, pos.z]) + }; + *self.random() = random; + placed + } + /// `PlacedFeature.place(level, generator, level.random, pos)`. + pub(crate) fn place_placed_feature(&mut self, name: &str, pos: BlockPos) -> bool { + let b = self.b; + let Some(features) = b.live_features() else { + return false; + }; + let mut random = self.random().clone(); + let placed = { + let mut world = LevelFeatureWorld { + sim: self, + features, + }; + features.place_placed(name, &mut world, &mut random, [pos.x, pos.y, pos.z]) + }; + *self.random() = random; + placed + } + fn feature_exists(&self, name: &str) -> bool { + self.b + .live_features() + .is_some_and(|f| f.configured(name).is_some()) + } + + /// `TreeGrower.hasFlowers`: a flower within 2 blocks horizontally, 1 vertically. + fn tree_has_flowers(&self, pos: BlockPos) -> bool { + let b = self.b; + let Some(flowers) = b.tag("minecraft:flowers") else { + return false; + }; + for y in -1..=1 { + for z in -2..=2 { + for x in -2..=2 { + if b.in_set(self.state(pos.offset(x, y, z)), flowers) { + return true; + } + } + } + } + false + } + /// `TreeGrower.findTwoByTwoSaplingPos`. + fn two_by_two( + &self, + state: BlockStateId, + pos: BlockPos, + ) -> Option<(i32, i32, [(BlockStateId, BlockPos); 4])> { + let block = self.b.block(state); + for dx in [0, -1] { + for dz in [0, -1] { + let at = |x: i32, z: i32| { + let p = pos.offset(dx + x, 0, dz + z); + (self.state(p), p) + }; + let around = [at(0, 0), at(1, 0), at(0, 1), at(1, 1)]; + if around.iter().all(|(s, _)| self.b.is_block(*s, block)) { + return Some((dx, dz, around)); + } + } + } + None + } + /// `TreeGrower.removeSapling`: the fluid's legacy block, flags 818. + fn remove_sapling(&mut self, pos: BlockPos) { + let empty = self.b.legacy_block(self.fluid_at(pos)); + self.set_block( + pos, + empty, + flags::UPDATE_SKIP_ALL_SIDEEFFECTS | flags::UPDATE_CLIENTS, + ); + } + /// `TreeGrower.growTree`. + pub(crate) fn grow_tree( + &mut self, + grower: &TreeGrower, + pos: BlockPos, + state: BlockStateId, + ) -> bool { + if let Some(mega) = weighted(grower.mega_trees, self.random()) + && self.feature_exists(mega) + && let Some((dx, dz, around)) = self.two_by_two(state, pos) + { + for &(_, p) in &around { + self.remove_sapling(p); + } + if self.place_configured_feature(mega, pos.offset(dx, 0, dz)) { + return true; + } + for &(s, p) in &around { + self.set_block(p, s, flags::UPDATE_NONE); + } + return false; + } + let flowers = self.tree_has_flowers(pos); + let list = if flowers && !grower.flower_trees.is_empty() { + grower.flower_trees + } else { + grower.trees + }; + let Some(feature) = weighted(list, self.random()) else { + return false; + }; + if !self.feature_exists(feature) { + return false; + } + self.remove_sapling(pos); + if self.place_configured_feature(feature, pos) { + return true; + } + self.set_block(pos, state, flags::UPDATE_NONE); + false + } + /// `TreeGrower.canGrow` (draws as vanilla: feature, then mega feature). + pub(crate) fn tree_can_grow( + &mut self, + grower: &TreeGrower, + pos: BlockPos, + state: BlockStateId, + ) -> bool { + let flowers = self.tree_has_flowers(pos); + let list = if flowers && !grower.flower_trees.is_empty() { + grower.flower_trees + } else { + grower.trees + }; + let feature = weighted(list, self.random()); + let mega = weighted(grower.mega_trees, self.random()); + if feature.is_none() && mega.is_some() { + self.two_by_two(state, pos).is_some() + } else { + true + } + } + /// `TreeGrower.getMinimumHeight`: the shortest tree's trunk base height. + pub(crate) fn tree_minimum_height(&self, grower: &TreeGrower) -> i32 { + grower + .shortest + .and_then(|name| self.b.live_features()?.configured_json(name)) + .filter(|json| json["type"] == "minecraft:tree") + .and_then(|json| json["trunk_placer"]["base_height"].as_i64()) + .map_or(0, |h| h as i32) + } + /// `SaplingBlock.advanceTree` with the grower run inline when features are + /// installed; otherwise reported as [`LevelEvent::GrowTree`]. + pub(crate) fn advance_tree(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + if b.table.int(state, b.props.stage) == 0 { + self.set_block(pos, b.table.cycle(state, b.props.stage), flags::UPDATE_NONE); + return; + } + let Some(name) = b.data(state).feature.clone() else { + return; + }; + match grower(&name) { + Some(g) if b.live_features().is_some() => { + self.grow_tree(g, pos, state); + } + _ => self.emit(LevelEvent::GrowTree { + pos, + state, + grower: name, + }), + } + } + /// `MushroomBlock.growMushroom`. + pub(crate) fn grow_mushroom(&mut self, pos: BlockPos, state: BlockStateId) -> bool { + let Some(feature) = self.b.data(state).feature.clone() else { + return false; + }; + if !self.feature_exists(&feature) { + return false; + } + self.remove_block(pos, false); + if self.place_configured_feature(&feature, pos) { + return true; + } + self.set_block_and_update(pos, state); + false + } +} diff --git a/crates/horizon-world/src/level/growth_tests.rs b/crates/horizon-world/src/level/growth_tests.rs new file mode 100644 index 000000000..2d120335c --- /dev/null +++ b/crates/horizon-world/src/level/growth_tests.rs @@ -0,0 +1,342 @@ +//! Sapling growth and bone meal through live feature placement. Needs the +//! prepared client resources and worldgen bundle (skipped when absent). +use super::*; +use crate::{chunk::BlockState, worldgen::generator::GeneratorData, worldgen::live::LiveFeatures}; +use std::{ + collections::{BTreeMap, HashMap}, + path::PathBuf, + sync::OnceLock, +}; + +struct Fixture { + registry: &'static BlockRegistry, + behaviours: Behaviours, +} + +fn fixture() -> Option<&'static Fixture> { + static FIXTURE: OnceLock> = OnceLock::new(); + FIXTURE + .get_or_init(|| { + let root = std::env::var_os("HORIZON_RESOURCES") + .map(PathBuf::from) + .unwrap_or_else(|| { + PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("../../.local/horizon-client/26.3") + }); + // Trees need the feature block-behaviour exports in the worldgen bundle. + if !root.join("block-behaviours.json").exists() + || !root.join("worldgen/blocks/block-properties.nbt").exists() + { + eprintln!("skipping growth tests: no resources at {}", root.display()); + return None; + } + let registry: &'static BlockRegistry = + Box::leak(Box::new(data::load_registry(&root).expect("registry"))); + let behaviours = Behaviours::load(registry, &root).expect("behaviours"); + let data = + GeneratorData::load(&root.join("worldgen"), registry).expect("worldgen data"); + let features = LiveFeatures::new(&data) + .expect("features") + .expect("feature bundle"); + behaviours.set_live_features(Arc::new(features)); + Some(Fixture { + registry, + behaviours, + }) + }) + .as_ref() +} + +struct Level { + blocks: HashMap, + air: BlockStateId, + random: LegacyRandom, + events: Vec, + biome: &'static str, +} +impl LevelAccess for Level { + fn block_state(&self, pos: BlockPos) -> BlockStateId { + self.blocks.get(&pos).copied().unwrap_or(self.air) + } + fn set_raw(&mut self, pos: BlockPos, state: BlockStateId) -> Option { + Some(self.blocks.insert(pos, state).unwrap_or(self.air)) + } + fn is_loaded(&self, _pos: BlockPos) -> bool { + true + } + fn random(&mut self) -> &mut LegacyRandom { + &mut self.random + } + fn game_time(&self) -> i64 { + 0 + } + fn block_light(&self, _pos: BlockPos) -> i32 { + 15 + } + fn emit(&mut self, event: LevelEvent) { + self.events.push(event); + } + fn biome_name(&self, _pos: BlockPos) -> Option<&str> { + Some(self.biome) + } +} + +struct World { + f: &'static Fixture, + level: Level, + ticks: Ticks, +} +impl World { + fn new(f: &'static Fixture, seed: i64) -> Self { + let mut ticks = Ticks::new(0); + for x in -4..4 { + for z in -4..4 { + ticks.add_empty_chunk(ChunkPos::new(x, z)).unwrap(); + } + } + Self { + level: Level { + blocks: HashMap::new(), + air: f.behaviours.air(), + random: LegacyRandom::new(seed), + events: Vec::new(), + biome: "minecraft:plains", + }, + f, + ticks, + } + } + fn id(&self, name: &str, props: &[(&str, &str)]) -> BlockStateId { + let state = BlockState { + name: format!("minecraft:{name}"), + properties: props + .iter() + .map(|(k, v)| (k.to_string(), v.to_string())) + .collect::>(), + }; + self.f + .registry + .resolve(&state) + .unwrap_or_else(|_| panic!("unknown state {name} {props:?}")) + } + fn floor(&mut self, name: &str, radius: i32) { + let state = self.id(name, &[]); + let stone = self.id("stone", &[]); + for x in -radius..=radius { + for z in -radius..=radius { + self.level.blocks.insert(BlockPos::new(x, 63, z), state); + self.level.blocks.insert(BlockPos::new(x, 62, z), stone); + } + } + } + fn put(&mut self, pos: BlockPos, state: BlockStateId) { + self.level.blocks.insert(pos, state); + } + fn name(&self, pos: BlockPos) -> String { + let state = self.level.block_state(pos); + self.f.registry.state(state).unwrap().name.clone() + } + fn bone_meal(&mut self, pos: BlockPos) -> bool { + self.f + .behaviours + .use_bone_meal(&mut self.level, &mut self.ticks, pos, Direction::Up) + } + fn count(&self, suffix: &str) -> usize { + self.level + .blocks + .values() + .filter(|&&s| self.f.registry.state(s).unwrap().name.ends_with(suffix)) + .count() + } +} + +fn grow(sapling: &str, soil: &str, positions: &[(i32, i32)], log: &str) { + let Some(f) = fixture() else { return }; + let mut grown = 0; + for seed in 0..6 { + let mut w = World::new(f, seed); + w.floor(soil, 12); + let state = w.id(sapling, &[]); + for &(x, z) in positions { + w.put(BlockPos::new(x, 64, z), state); + } + let origin = BlockPos::new(0, 64, 0); + let mut uses = 0; + while w.name(origin) == format!("minecraft:{sapling}") && uses < 64 { + assert!(w.bone_meal(origin), "{sapling} is a bone meal target"); + uses += 1; + } + if w.count(log) > 0 { + grown += 1; + assert_eq!( + w.name(origin), + format!("minecraft:{log}"), + "{sapling} trunk at origin" + ); + } + } + assert!(grown >= 5, "{sapling}: grew {grown} of 6 times"); +} + +#[test] +fn oak_sapling_grows_with_bone_meal() { + grow("oak_sapling", "grass_block", &[(0, 0)], "oak_log"); +} +#[test] +fn single_saplings_grow() { + grow("birch_sapling", "dirt", &[(0, 0)], "birch_log"); + grow("spruce_sapling", "dirt", &[(0, 0)], "spruce_log"); + grow("jungle_sapling", "dirt", &[(0, 0)], "jungle_log"); + grow("acacia_sapling", "dirt", &[(0, 0)], "acacia_log"); + grow("cherry_sapling", "grass_block", &[(0, 0)], "cherry_log"); + grow("poplar_sapling", "grass_block", &[(0, 0)], "poplar_log"); +} +#[test] +fn two_by_two_saplings_grow() { + let square = [(0, 0), (1, 0), (0, 1), (1, 1)]; + grow("dark_oak_sapling", "grass_block", &square, "dark_oak_log"); + grow("pale_oak_sapling", "grass_block", &square, "pale_oak_log"); + grow("spruce_sapling", "podzol", &square, "spruce_log"); + grow("jungle_sapling", "grass_block", &square, "jungle_log"); +} +#[test] +fn lone_dark_oak_sapling_cannot_grow() { + let Some(f) = fixture() else { return }; + let mut w = World::new(f, 1); + w.floor("grass_block", 4); + let sapling = w.id("dark_oak_sapling", &[]); + w.put(BlockPos::new(0, 64, 0), sapling); + assert!(!w.bone_meal(BlockPos::new(0, 64, 0))); +} +#[test] +fn azalea_and_mangrove_grow() { + let Some(f) = fixture() else { return }; + for (block, soil, log) in [ + ("azalea", "grass_block", "oak_log"), + ("mangrove_propagule", "mud", "mangrove_log"), + ] { + let mut grew = false; + for seed in 0..6 { + let mut w = World::new(f, seed); + w.floor(soil, 12); + let state = w.id(block, &[]); + w.put(BlockPos::new(0, 64, 0), state); + for _ in 0..64 { + if w.count(log) > 0 { + break; + } + w.bone_meal(BlockPos::new(0, 64, 0)); + } + grew |= w.count(log) > 0; + } + assert!(grew, "{block} grows into a tree"); + } +} +#[test] +fn random_ticks_advance_sapling_stage_then_grow() { + let Some(f) = fixture() else { return }; + let mut w = World::new(f, 3); + w.floor("grass_block", 8); + let sapling = w.id("oak_sapling", &[]); + let pos = BlockPos::new(0, 64, 0); + w.put(pos, sapling); + for _ in 0..2000 { + let state = w.level.block_state(pos); + if !f.behaviours.is_randomly_ticking(state) { + break; + } + f.behaviours.random_tick(&mut w.level, &mut w.ticks, pos); + } + assert_eq!(w.name(pos), "minecraft:oak_log"); +} +#[test] +fn grass_bone_meal_places_grass_and_flowers() { + let Some(f) = fixture() else { return }; + let mut w = World::new(f, 7); + w.floor("grass_block", 8); + assert!(w.bone_meal(BlockPos::new(0, 63, 0))); + let plants = w.count("short_grass") + w.count("tall_grass"); + let flowers = w.count("dandelion") + + w.count("poppy") + + w.count("cornflower") + + w.count("oxeye_daisy") + + w.count("azure_bluet") + + w.count("_tulip"); + assert!(plants > 10, "grass placed: {plants}"); + assert!(plants + flowers > 15); + assert!( + w.level + .events + .iter() + .any(|e| matches!(e, LevelEvent::LevelEvent { id: 1505, .. })) + ); +} +#[test] +fn huge_mushroom_and_fungus_grow() { + let Some(f) = fixture() else { return }; + let mut grew = (false, false); + for seed in 0..8 { + let mut w = World::new(f, seed); + w.floor("mycelium", 8); + let mushroom = w.id("red_mushroom", &[]); + w.put(BlockPos::new(0, 64, 0), mushroom); + for _ in 0..16 { + w.bone_meal(BlockPos::new(0, 64, 0)); + } + grew.0 |= w.count("red_mushroom_block") > 0 && w.count("mushroom_stem") > 0; + let mut w = World::new(f, seed); + w.floor("crimson_nylium", 8); + let fungus = w.id("crimson_fungus", &[]); + w.put(BlockPos::new(0, 64, 0), fungus); + for _ in 0..16 { + if w.count("crimson_stem") > 0 { + break; + } + w.bone_meal(BlockPos::new(0, 64, 0)); + } + grew.1 |= w.count("crimson_stem") > 0 && w.count("nether_wart_block") > 0; + } + assert!(grew.0, "huge red mushroom"); + assert!(grew.1, "huge crimson fungus"); +} +#[test] +fn crops_age_with_bone_meal() { + let Some(f) = fixture() else { return }; + let mut w = World::new(f, 11); + let farmland = w.id("farmland", &[]); + let pos = BlockPos::new(0, 64, 0); + w.put(BlockPos::new(0, 63, 0), farmland); + w.put(pos, w.id("wheat", &[])); + let mut uses = 0; + while w.bone_meal(pos) { + uses += 1; + } + assert!((2..=4).contains(&uses), "wheat matured after {uses} uses"); + assert_eq!(w.level.block_state(pos), w.id("wheat", &[("age", "7")])); + w.put(pos, w.id("torchflower_crop", &[])); + assert!(w.bone_meal(pos)); + assert!(w.bone_meal(pos)); + assert_eq!(w.name(pos), "minecraft:torchflower"); + assert!(!w.bone_meal(pos), "torchflowers are not bonemealable"); +} +#[test] +fn tall_flowers_and_seagrass() { + let Some(f) = fixture() else { return }; + let mut w = World::new(f, 5); + w.floor("dirt", 2); + let fern = w.id("fern", &[]); + w.put(BlockPos::new(0, 64, 0), fern); + assert!(w.bone_meal(BlockPos::new(0, 64, 0))); + assert_eq!(w.name(BlockPos::new(0, 64, 0)), "minecraft:large_fern"); + assert_eq!(w.name(BlockPos::new(0, 65, 0)), "minecraft:large_fern"); + let lilac = w.id("lilac", &[("half", "lower")]); + w.put(BlockPos::new(1, 64, 0), lilac); + assert!(w.bone_meal(BlockPos::new(1, 64, 0))); + assert!(w.level.events.iter().any(|e| matches!( + e, + LevelEvent::BlockEvent { + kind: "pop_block_item", + .. + } + ))); +} diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs index ee7dca6b9..45b6ebaaf 100644 --- a/crates/horizon-world/src/level/mod.rs +++ b/crates/horizon-world/src/level/mod.rs @@ -100,8 +100,11 @@ pub mod data; pub mod states; pub mod ticks; +mod bonemeal; mod falling; +mod feature_world; mod fluids; +mod growth; mod hooks; mod interact; pub mod pistons; @@ -115,6 +118,8 @@ mod survive; mod tick; mod update; +#[cfg(test)] +mod growth_tests; #[cfg(test)] mod tests; @@ -337,6 +342,15 @@ pub trait LevelAccess { true } fn emit(&mut self, _event: LevelEvent) {} + /// Biome identifier at `pos` (`minecraft:plains`), for features placed by + /// block behaviour (bone meal flowers). None when unknown. + fn biome_name(&self, _pos: BlockPos) -> Option<&str> { + None + } + /// World seed (`WorldGenLevel.getSeed`) for seed-derived feature noise. + fn world_seed(&self) -> i64 { + 0 + } } /// Raw brightness as `Level.getRawBrightness(pos, skyDarken)`. @@ -361,6 +375,7 @@ pub struct Behaviours { /// Uncached (position- or block-entity-dependent) collision shapes. dynamic: HashMap, occlusion_cache: Mutex>, + growth: growth::Growth, } impl Behaviours { diff --git a/crates/horizon-world/src/level/tick.rs b/crates/horizon-world/src/level/tick.rs index 555ba2a85..548ba97da 100644 --- a/crates/horizon-world/src/level/tick.rs +++ b/crates/horizon-world/src/level/tick.rs @@ -708,11 +708,12 @@ impl Sim<'_, L> { return; } let age = b.table.int(state, b.props.age); - let max = b.table.int_range(state, b.props.age).map_or(7, |r| r.1); + let max = self.crop_max_age(state); if age < max { let speed = self.crop_growth_speed(b.block(state), pos); if self.rand_int((25.0 / speed) as i32 + 1) == 0 { - self.set_block(pos, b.table.set_int(state, b.props.age, age + 1), 2); + let next = self.crop_state_for_age(state, age + 1); + self.set_block(pos, next, 2); } } } @@ -789,11 +790,12 @@ impl Sim<'_, L> { self.set_block(upper_pos, upper, 3); } } - fn growing_plant_can_grow_into(&self, plant: BlockStateId, state: BlockStateId) -> bool { + pub(crate) fn growing_plant_can_grow_into(&self, plant: BlockStateId, state: BlockStateId) -> bool { let b = self.b; let data = b.data(plant); if data.is(Class::Kelp) { - b.is_block(state, b.named.water) && b.fluid(state).amount() == 8 + // KelpBlock.canGrowInto: any water block state. + b.is_block(state, b.named.water) } else { // NetherVines.isValidGrowthState / CaveVines: air only. b.is_air(state) @@ -868,12 +870,7 @@ impl Sim<'_, L> { } /// `SaplingBlock.advanceTree`. pub(crate) fn sapling_advance_tree(&mut self, pos: BlockPos, state: BlockStateId) { - let b = self.b; - if b.table.int(state, b.props.stage) == 0 { - self.set_block(pos, b.table.cycle(state, b.props.stage), 260); - } else if let Some(grower) = b.data(state).feature.clone() { - self.emit(LevelEvent::GrowTree { pos, state, grower }); - } + self.advance_tree(pos, state); } fn mushroom_random_tick(&mut self, state: BlockStateId, mut pos: BlockPos) { let b = self.b; @@ -1013,13 +1010,13 @@ impl Sim<'_, L> { self.set_block_and_update(grow, state); } } - fn bamboo_sapling_grow(&mut self, pos: BlockPos) { + pub(crate) fn bamboo_sapling_grow(&mut self, pos: BlockPos) { let b = self.b; let bamboo = b.default_of(b.named.bamboo); let state = b.table.set_text(bamboo, b.props.leaves, "small"); self.set_block(above(pos), state, 3); } - fn bamboo_height_below(&self, pos: BlockPos) -> i32 { + pub(crate) fn bamboo_height_below(&self, pos: BlockPos) -> i32 { let mut height = 0; while height < 16 && self.b.is_block( @@ -1031,7 +1028,7 @@ impl Sim<'_, L> { } height } - fn bamboo_height_above(&self, pos: BlockPos) -> i32 { + pub(crate) fn bamboo_height_above(&self, pos: BlockPos) -> i32 { let mut height = 0; while height < 16 && self.b.is_block( @@ -1044,7 +1041,7 @@ impl Sim<'_, L> { height } /// `BambooStalkBlock.growBamboo`. - fn bamboo_grow(&mut self, state: BlockStateId, pos: BlockPos, height: i32) { + pub(crate) fn bamboo_grow(&mut self, state: BlockStateId, pos: BlockPos, height: i32) { let b = self.b; let p = b.props; let below_state = self.below_state(pos); diff --git a/crates/horizon-world/src/worldgen.rs b/crates/horizon-world/src/worldgen.rs index ec7eeda6f..36fb43fb3 100644 --- a/crates/horizon-world/src/worldgen.rs +++ b/crates/horizon-world/src/worldgen.rs @@ -43,6 +43,7 @@ mod generator_decoration; mod generator_structures; pub mod height_provider; pub mod iceberg; +pub mod live; pub mod material_condition; pub mod material_extensions; pub mod material_stage; diff --git a/crates/horizon-world/src/worldgen/live.rs b/crates/horizon-world/src/worldgen/live.rs new file mode 100644 index 000000000..7460d1450 --- /dev/null +++ b/crates/horizon-world/src/worldgen/live.rs @@ -0,0 +1,316 @@ +//! Configured and placed features for a live level: what vanilla block +//! behaviour reaches through `Feature.place(level, generator, random, pos)` +//! on a `ServerLevel` (sapling and fungus growth, bone meal on grass, nylium, +//! moss, huge mushrooms). Definitions are decoded lazily by name from the same +//! worldgen bundle as decoration and cached. +use super::{ + biome::BiomeId, + biome_predicate::BiomePredicateBindings, + block_feature::FeatureBlockBindings, + feature::{FeatureBlocks, FeatureWorld}, + feature_catalog::FeatureCatalog, + feature_graph::{FeatureDefinition, PlacedFeatureDefinition}, + generator::{GeneratorData, GeneratorError}, + placement::PlacementContext, + state_provider::{StateProviderBindings, StateProviderCatalog}, + tags::TagDefinitions, +}; +use crate::block_placement::BlockPlacementBindings; +use horizon_core::random::RandomSource; +use serde_json::Value; +use std::{ + collections::{BTreeSet, HashMap}, + sync::{Arc, Mutex}, +}; + +type Cache = Mutex>>>; + +pub struct LiveFeatures { + data: Arc, + catalog: FeatureCatalog, + bindings: FeatureBlockBindings<'static>, + blocks: FeatureBlocks, + configured: Cache, + placed: Cache, + /// `BiomeGenerationSettings.getBoneMealFeatures` per biome, in vanilla order. + bone_meal: Vec>, +} + +fn resource(message: impl Into) -> GeneratorError { + GeneratorError::Resource(message.into()) +} + +/// `ConfiguredFeature.getFeatures`: nested configured-feature references of a +/// feature JSON, depth first (each reference followed by its own children). +fn nested_features( + json: &Value, + features: &std::collections::BTreeMap, + depth: usize, + out: &mut Vec, +) { + if depth > 64 { + return; + } + match json { + Value::Object(map) => { + for (key, value) in map { + if key == "feature" + && let Some(name) = value.as_str() + { + let name = super::tags::identifier(name).unwrap_or_else(|_| name.to_owned()); + out.push(name.clone()); + if let Some(child) = features + .get(&name) + .and_then(|text| serde_json::from_str::(text).ok()) + { + nested_features(&child, features, depth + 1, out); + } + } else { + nested_features(value, features, depth + 1, out); + } + } + } + Value::Array(values) => { + for value in values { + nested_features(value, features, depth + 1, out); + } + } + _ => {} + } +} + +impl LiveFeatures { + /// None when the bundle carries no feature resources. + pub fn new(data: &Arc) -> Result, GeneratorError> { + let Some(resources) = &data.feature_resources else { + return Ok(None); + }; + let registry = data.registry(); + let mut feature_tags = TagDefinitions::default(); + for (name, json) in &resources.feature_tags { + feature_tags.apply_json(name, "vanilla", json)?; + } + let catalog = + FeatureCatalog::from_resources(&resources.features, &resources.placed, &feature_tags)?; + let biomes = Arc::new(BiomePredicateBindings::new( + &data + .biome_names() + .iter() + .enumerate() + .map(|(i, name)| (name.to_string(), BiomeId(i as u32))) + .collect(), + &data.biome_tags, + )?); + let mut bindings = + FeatureBlockBindings::with_tags(registry, data.integers().clone(), &data.block_tags)? + .with_fluid_tags(&resources.fluid_tags)? + .with_biomes(biomes.clone()); + if let Some(structures) = &data.structures { + bindings = bindings.with_structures(structures.clone()); + } + if let Some(blocks) = &resources.blocks { + bindings = bindings + .with_block_properties(&blocks.properties)? + .with_state_providers( + StateProviderBindings::new( + registry, + data.integers().clone(), + &data.block_tags, + )? + .with_block_properties(&blocks.properties)? + .with_fluid_tags(&resources.fluid_tags)? + .with_biomes(biomes), + StateProviderCatalog::from_resources(&resources.state_providers)?, + BlockPlacementBindings::new( + registry, + &blocks.properties, + &blocks.double_plants, + &blocks.mossy_carpets, + )?, + )?; + } + // Configured-feature tag membership (feature_tags names configured features). + let mut bone_meal_tag = BTreeSet::new(); + if let Some(json) = resources + .feature_tags + .get("minecraft:can_spawn_from_bone_meal") + { + let value: Value = serde_json::from_str(json)?; + for entry in value["values"].as_array().into_iter().flatten() { + if let Some(name) = entry.as_str() { + bone_meal_tag.insert(super::tags::identifier(name)?); + } + } + } + let placed_tags = feature_tags + .build(|name, _| resources.placed.contains_key(name).then(|| name.to_owned())) + .map_err(|e| resource(format!("feature tags: {e:?}")))? + .tags; + let mut bone_meal = Vec::with_capacity(data.biome_names().len()); + for i in 0..data.biome_names().len() { + let biome: Value = serde_json::from_str(data.biome_json(BiomeId(i as u32)))?; + let mut list = Vec::new(); + for step in biome["features"].as_array().into_iter().flatten() { + let entries: Vec = match step { + Value::String(tag) if tag.starts_with('#') => placed_tags + .get(&super::tags::identifier(&tag[1..])?) + .cloned() + .unwrap_or_default(), + Value::String(name) => vec![name.clone()], + Value::Array(values) => values + .iter() + .filter_map(|v| v.as_str().map(str::to_owned)) + .collect(), + _ => Vec::new(), + }; + for entry in entries { + let name = super::tags::identifier(&entry)?; + let Some(placed) = resources + .placed + .get(&name) + .and_then(|text| serde_json::from_str::(text).ok()) + else { + continue; + }; + // PlacedFeature.getFeatures: its feature, then that feature's children. + let mut found = Vec::new(); + match &placed["feature"] { + Value::String(feature) => { + let feature = super::tags::identifier(feature)?; + found.push(feature.clone()); + if let Some(child) = resources + .features + .get(&feature) + .and_then(|text| serde_json::from_str::(text).ok()) + { + nested_features(&child, &resources.features, 0, &mut found); + } + } + inline => nested_features(inline, &resources.features, 0, &mut found), + } + list.extend(found.into_iter().filter(|f| bone_meal_tag.contains(f))); + } + } + bone_meal.push(list); + } + Ok(Some(Self { + data: data.clone(), + catalog, + bindings, + blocks: FeatureBlocks::from_registry(registry)?, + configured: Mutex::new(HashMap::new()), + placed: Mutex::new(HashMap::new()), + bone_meal, + })) + } + pub fn data(&self) -> &Arc { + &self.data + } + pub fn biome_id(&self, name: &str) -> Option { + self.data.biome_id(name) + } + /// Raw JSON of a configured feature (for configuration values such as a + /// trunk placer's base height). + pub fn configured_json(&self, name: &str) -> Option { + let resources = self.data.feature_resources.as_ref()?; + serde_json::from_str(resources.features.get(name)?).ok() + } + pub fn configured(&self, name: &str) -> Option> { + let mut cache = self.configured.lock().unwrap(); + cache + .entry(name.to_owned()) + .or_insert_with(|| { + match self + .catalog + .feature_with_blocks(&Value::from(name).to_string(), &self.bindings) + { + Ok(f) => Some(Arc::new(f)), + Err(e) => { + eprintln!("Horizon: feature {name} cannot be placed: {e}"); + None + } + } + }) + .clone() + } + pub fn placed(&self, name: &str) -> Option> { + let mut cache = self.placed.lock().unwrap(); + cache + .entry(name.to_owned()) + .or_insert_with(|| { + match self + .catalog + .placed_feature_with_blocks(&Value::from(name).to_string(), &self.bindings) + { + Ok(f) => Some(Arc::new(f)), + Err(e) => { + eprintln!("Horizon: placed feature {name} cannot be placed: {e}"); + None + } + } + }) + .clone() + } + /// `ConfiguredFeature.place`. Unknown or unsupported features and + /// execution errors report failure. + pub fn place_configured( + &self, + name: &str, + world: &mut W, + random: &mut impl RandomSource, + origin: [i32; 3], + ) -> bool + where + W::Error: std::fmt::Display, + { + let Some(feature) = self.configured(name) else { + return false; + }; + match feature.place(world, random, origin, self.blocks) { + Ok(placed) => placed, + Err(e) => { + eprintln!("Horizon: placing {name} failed: {e}"); + false + } + } + } + /// `PlacedFeature.place` (placement modifiers, then the feature). + pub fn place_placed( + &self, + name: &str, + world: &mut W, + random: &mut impl RandomSource, + origin: [i32; 3], + ) -> bool + where + W::Error: std::fmt::Display, + { + let Some(feature) = self.placed(name) else { + return false; + }; + match feature.place(world, random, origin, self.blocks) { + Ok(placed) => placed, + Err(e) => { + eprintln!("Horizon: placing {name} failed: {e}"); + false + } + } + } + /// Whether the named biome is in a biome tag (`minecraft:...`). + pub fn biome_in_tag(&self, biome: &str, tag: &str) -> bool { + self.data + .biome_tags + .get(tag) + .is_some_and(|members| members.iter().any(|m| m == biome)) + } + /// A block tag's members in registry tag order (for `getRandomElementOf`). + pub fn block_tag_entries(&self, tag: &str) -> &[String] { + self.data.block_tags.get(tag).map_or(&[], Vec::as_slice) + } + /// `BiomeGenerationSettings.getBoneMealFeatures` of a biome. + pub fn bone_meal_features(&self, biome: BiomeId) -> &[String] { + self.bone_meal + .get(biome.0 as usize) + .map_or(&[], Vec::as_slice) + } +}