Merge vanilla feature algorithms into chunk decoration
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -29,6 +29,9 @@ pub trait RandomSource: Sized {
|
||||
fn next_boolean(&mut self) -> bool;
|
||||
fn next_float(&mut self) -> f32;
|
||||
fn next_double(&mut self) -> f64;
|
||||
/// MarsagliaPolarGaussian over this source; the cached second value is
|
||||
/// part of the source state (reset by `set_seed` where vanilla resets it).
|
||||
fn next_gaussian(&mut self) -> f64;
|
||||
fn fork_positional(&mut self) -> Self::Positional;
|
||||
fn fork(&mut self) -> Self
|
||||
where
|
||||
@@ -61,6 +64,7 @@ pub trait RandomSource: Sized {
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct LegacyRandom {
|
||||
state: u64,
|
||||
gaussian: Option<f64>,
|
||||
}
|
||||
|
||||
impl LegacyRandom {
|
||||
@@ -70,6 +74,7 @@ impl LegacyRandom {
|
||||
pub fn new(seed: i64) -> Self {
|
||||
Self {
|
||||
state: (seed as u64 ^ Self::MULTIPLIER) & Self::MASK,
|
||||
gaussian: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -125,6 +130,12 @@ impl RandomSource for LegacyRandom {
|
||||
let value = (i64::from(self.bits(26)) << 27) + i64::from(self.bits(27));
|
||||
value as f64 * (1.0 / 9_007_199_254_740_992.0)
|
||||
}
|
||||
fn next_gaussian(&mut self) -> f64 {
|
||||
let mut cache = self.gaussian.take();
|
||||
let value = marsaglia_polar(&mut cache, || self.next_double());
|
||||
self.gaussian = cache;
|
||||
value
|
||||
}
|
||||
|
||||
fn fork(&mut self) -> Self {
|
||||
Self::new(self.next_long())
|
||||
@@ -135,6 +146,7 @@ impl RandomSource for LegacyRandom {
|
||||
pub struct XoroshiroRandom {
|
||||
lo: u64,
|
||||
hi: u64,
|
||||
gaussian: Option<f64>,
|
||||
}
|
||||
|
||||
impl XoroshiroRandom {
|
||||
@@ -154,9 +166,14 @@ impl XoroshiroRandom {
|
||||
Self {
|
||||
lo: Self::GOLDEN_RATIO,
|
||||
hi: Self::SILVER_RATIO,
|
||||
gaussian: None,
|
||||
}
|
||||
} else {
|
||||
Self { lo, hi }
|
||||
Self {
|
||||
lo,
|
||||
hi,
|
||||
gaussian: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -207,6 +224,12 @@ impl RandomSource for XoroshiroRandom {
|
||||
fn next_double(&mut self) -> f64 {
|
||||
((self.next_long() as u64) >> 11) as f64 * (1.0 / 9_007_199_254_740_992.0)
|
||||
}
|
||||
fn next_gaussian(&mut self) -> f64 {
|
||||
let mut cache = self.gaussian.take();
|
||||
let value = marsaglia_polar(&mut cache, || self.next_double());
|
||||
self.gaussian = cache;
|
||||
value
|
||||
}
|
||||
fn fork(&mut self) -> Self {
|
||||
let lo = self.next_long() as u64;
|
||||
let hi = self.next_long() as u64;
|
||||
@@ -214,6 +237,24 @@ impl RandomSource for XoroshiroRandom {
|
||||
}
|
||||
}
|
||||
|
||||
/// MarsagliaPolarGaussian.nextGaussian with an external second-value cache.
|
||||
pub fn marsaglia_polar(cache: &mut Option<f64>, mut next_double: impl FnMut() -> f64) -> f64 {
|
||||
if let Some(value) = cache.take() {
|
||||
return value;
|
||||
}
|
||||
loop {
|
||||
let x = 2.0 * next_double() - 1.0;
|
||||
let y = 2.0 * next_double() - 1.0;
|
||||
let radius = x * x + y * y;
|
||||
if radius >= 1.0 || radius == 0.0 {
|
||||
continue;
|
||||
}
|
||||
let multiplier = (-2.0 * radius.ln() / radius).sqrt();
|
||||
*cache = Some(y * multiplier);
|
||||
return x * multiplier;
|
||||
}
|
||||
}
|
||||
|
||||
pub const fn mix_stafford13(mut value: u64) -> u64 {
|
||||
value = (value ^ (value >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
|
||||
value = (value ^ (value >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
|
||||
|
||||
@@ -28,6 +28,8 @@ pub struct WorldgenRandom<R: WorldgenSource> {
|
||||
source: R,
|
||||
count: i32,
|
||||
wrapped: bool,
|
||||
/// The adapter's own Gaussian cache; native setSeed does not reset it.
|
||||
gaussian: Option<f64>,
|
||||
}
|
||||
impl<R: WorldgenSource> WorldgenRandom<R> {
|
||||
pub fn new(source: R) -> Self {
|
||||
@@ -35,6 +37,7 @@ impl<R: WorldgenSource> WorldgenRandom<R> {
|
||||
source,
|
||||
count: 0,
|
||||
wrapped: true,
|
||||
gaussian: None,
|
||||
}
|
||||
}
|
||||
fn plain(source: R) -> Self {
|
||||
@@ -42,6 +45,7 @@ impl<R: WorldgenSource> WorldgenRandom<R> {
|
||||
source,
|
||||
count: 0,
|
||||
wrapped: false,
|
||||
gaussian: None,
|
||||
}
|
||||
}
|
||||
pub fn count(&self) -> i32 {
|
||||
@@ -150,6 +154,15 @@ impl<R: WorldgenSource> RandomSource for WorldgenRandom<R> {
|
||||
let bits = ((self.next_bits(26) as i64) << 27) + self.next_bits(27) as i64;
|
||||
bits as f64 * (1.0 / 9007199254740992.0)
|
||||
}
|
||||
fn next_gaussian(&mut self) -> f64 {
|
||||
if !self.wrapped {
|
||||
return self.source.next_gaussian();
|
||||
}
|
||||
let mut cache = self.gaussian.take();
|
||||
let value = super::marsaglia_polar(&mut cache, || self.next_double());
|
||||
self.gaussian = cache;
|
||||
value
|
||||
}
|
||||
/// Native forks return the underlying source, not another bit adapter.
|
||||
/// The returned value keeps that behavior through a transparent variant.
|
||||
fn fork(&mut self) -> Self {
|
||||
|
||||
@@ -0,0 +1,623 @@
|
||||
//! 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<String, BTreeSet<BlockStateId>>,
|
||||
support: &'a BlockSupportRegistry<'r>,
|
||||
survival: &'a BlockSurvivalRegistry<'r>,
|
||||
collision: &'a BlockCollisionRegistry<'r>,
|
||||
seed: i64,
|
||||
chest: BlockStateId,
|
||||
world_random: LegacyRandom,
|
||||
water_mask: u8,
|
||||
}
|
||||
impl<W: Write> 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<W: Write> FeatureWorld for World<'_, '_, W> {
|
||||
type Error = io::Error;
|
||||
fn block(&mut self, p: [i32; 3]) -> io::Result<BlockStateId> {
|
||||
Ok(self.get(p))
|
||||
}
|
||||
fn set_block(&mut self, p: [i32; 3], state: BlockStateId, flags: i32) -> io::Result<bool> {
|
||||
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<W: Write> DynamicSupportWorld for World<'_, '_, W> {
|
||||
type Error = io::Error;
|
||||
fn shulker_is_closed(&mut self, _: [i32; 3]) -> io::Result<Option<bool>> {
|
||||
Ok(None)
|
||||
}
|
||||
fn moving_piston_shape(&mut self, _: [i32; 3]) -> io::Result<Option<VoxelShape>> {
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
impl<W: Write> DynamicCollisionWorld for World<'_, '_, W> {
|
||||
fn shulker_collision_state(
|
||||
&mut self,
|
||||
_: [i32; 3],
|
||||
) -> io::Result<Option<ShulkerCollisionState>> {
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
impl<W: Write> SurvivalWorld for World<'_, '_, W> {
|
||||
fn block_state(&mut self, p: [i32; 3]) -> io::Result<BlockStateId> {
|
||||
Ok(self.get(p))
|
||||
}
|
||||
fn fluid_state(&mut self, p: [i32; 3]) -> io::Result<FluidState> {
|
||||
self.fluids
|
||||
.get(self.get(p))
|
||||
.ok_or_else(|| io::Error::other("unknown fluid"))
|
||||
}
|
||||
fn raw_brightness(&mut self, _: [i32; 3], _: i32) -> io::Result<i32> {
|
||||
Ok(15)
|
||||
}
|
||||
}
|
||||
impl<W: Write> PlacementContext for World<'_, '_, W> {
|
||||
fn collision_full_block(
|
||||
&mut self,
|
||||
state: BlockStateId,
|
||||
p: [i32; 3],
|
||||
) -> Result<bool, PlacementQueryError> {
|
||||
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<i64, PlacementQueryError> {
|
||||
Ok(self.seed)
|
||||
}
|
||||
fn next_world_boolean(&mut self) -> Result<bool, PlacementQueryError> {
|
||||
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<i32, PlacementQueryError> {
|
||||
Ok(15)
|
||||
}
|
||||
fn sea_level(&mut self) -> Result<i32, PlacementQueryError> {
|
||||
Ok(63)
|
||||
}
|
||||
fn water_at(&mut self, p: [i32; 3]) -> Result<bool, PlacementQueryError> {
|
||||
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<bool, PlacementQueryError> {
|
||||
let survival = self.survival;
|
||||
survival.can_survive(self, state, p).map_err(query)
|
||||
}
|
||||
fn attachment_at(
|
||||
&mut self,
|
||||
p: [i32; 3],
|
||||
direction: Direction,
|
||||
) -> Result<bool, PlacementQueryError> {
|
||||
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<bool, PlacementQueryError> {
|
||||
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<i32, PlacementQueryError> {
|
||||
Ok(MIN_Y)
|
||||
}
|
||||
fn max_y(&mut self) -> Result<i32, PlacementQueryError> {
|
||||
Ok(MIN_Y + HEIGHT - 1)
|
||||
}
|
||||
fn height(&mut self, _: HeightmapType, _: i32, _: i32) -> Result<i32, PlacementQueryError> {
|
||||
Ok(self.height)
|
||||
}
|
||||
fn block_state(&mut self, p: [i32; 3]) -> Result<BlockStateId, PlacementQueryError> {
|
||||
Ok(self.get(p))
|
||||
}
|
||||
fn fluid_state(&mut self, p: [i32; 3]) -> Result<FluidState, PlacementQueryError> {
|
||||
self.fluids
|
||||
.get(self.get(p))
|
||||
.ok_or_else(|| query("unknown fluid"))
|
||||
}
|
||||
fn block_matches_tag(&mut self, p: [i32; 3], tag: &str) -> Result<bool, PlacementQueryError> {
|
||||
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<bool, PlacementQueryError> {
|
||||
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<bool, PlacementQueryError> {
|
||||
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<R: RandomSource>(
|
||||
f: &Value,
|
||||
mut random: R,
|
||||
catalog: &FeatureCatalog,
|
||||
features: &BTreeMap<String, String>,
|
||||
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<dyn std::error::Error>> {
|
||||
let arg = std::env::args().nth(1).expect("private fixture directory");
|
||||
let dir = Path::new(&arg);
|
||||
let read = |name: &str| -> Result<Tag, Box<dyn std::error::Error>> {
|
||||
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<String, String> =
|
||||
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<String, String> =
|
||||
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<String, String> = serde_json::from_value(bundle["providers"].clone())?;
|
||||
let features: BTreeMap<String, String> = serde_json::from_value(bundle["features"].clone())?;
|
||||
let placed: BTreeMap<String, String> = 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::<String, Vec<BlockStateId>>::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<String, BTreeSet<BlockStateId>> = 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<String, String> =
|
||||
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 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,
|
||||
};
|
||||
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(())
|
||||
}
|
||||
@@ -19,33 +19,41 @@ pub mod bonus_chest;
|
||||
pub mod bulk_section;
|
||||
pub mod carver;
|
||||
pub mod carving;
|
||||
pub mod cave;
|
||||
pub mod chorus_plant;
|
||||
pub mod climate;
|
||||
pub mod decoration;
|
||||
pub mod delta;
|
||||
pub mod density;
|
||||
pub mod disk;
|
||||
pub mod dripstone;
|
||||
pub mod end_gateway;
|
||||
pub mod end_podium;
|
||||
pub mod end_spike;
|
||||
pub mod feature;
|
||||
pub mod feature_catalog;
|
||||
pub mod feature_graph;
|
||||
pub mod feature_region;
|
||||
pub mod feature_sort;
|
||||
pub mod fluid_predicate;
|
||||
pub mod fungus;
|
||||
pub mod generator;
|
||||
mod generator_blocks;
|
||||
mod generator_decoration;
|
||||
pub mod height_provider;
|
||||
pub mod iceberg;
|
||||
pub mod material_condition;
|
||||
pub mod material_extensions;
|
||||
pub mod material_stage;
|
||||
pub mod material_surface;
|
||||
pub mod ore_feature;
|
||||
pub mod placement;
|
||||
pub mod projected;
|
||||
pub mod replace_blobs;
|
||||
pub mod root_system;
|
||||
pub mod router;
|
||||
pub mod rule_test;
|
||||
pub mod sculk;
|
||||
pub mod settings;
|
||||
pub mod simple_block;
|
||||
pub mod snow_freeze;
|
||||
@@ -55,8 +63,11 @@ pub mod spring;
|
||||
pub mod state_provider;
|
||||
pub mod tags;
|
||||
pub mod terrain;
|
||||
pub mod tree;
|
||||
pub(crate) mod tree_blocks;
|
||||
pub mod underwater_magma;
|
||||
pub mod value_provider;
|
||||
pub mod vegetation;
|
||||
pub mod vines;
|
||||
pub mod weighted;
|
||||
pub mod write_zone;
|
||||
|
||||
@@ -29,8 +29,18 @@ pub struct FeatureBlockBindings<'r> {
|
||||
pub(crate) blocks: BTreeMap<String, Arc<BTreeSet<BlockStateId>>>,
|
||||
pub(crate) tags: BTreeMap<String, Arc<BTreeSet<BlockStateId>>>,
|
||||
pub(crate) air: [BlockStateId; 3],
|
||||
tree_blocks: std::sync::OnceLock<Arc<super::tree_blocks::TreeBlocks>>,
|
||||
}
|
||||
impl<'r> FeatureBlockBindings<'r> {
|
||||
/// Shared tree/vegetation classifications, built on first use. Requires
|
||||
/// state-provider and block-property bindings.
|
||||
pub(crate) fn tree_blocks(&self) -> Result<Arc<super::tree_blocks::TreeBlocks>, DecodeError> {
|
||||
if let Some(blocks) = self.tree_blocks.get() {
|
||||
return Ok(blocks.clone());
|
||||
}
|
||||
let blocks = Arc::new(super::tree_blocks::TreeBlocks::build(self)?);
|
||||
Ok(self.tree_blocks.get_or_init(|| blocks).clone())
|
||||
}
|
||||
pub fn registry(&self) -> &'r BlockRegistry {
|
||||
self.registry
|
||||
}
|
||||
@@ -143,6 +153,7 @@ impl<'r> FeatureBlockBindings<'r> {
|
||||
.map(|(name, states)| (name, Arc::new(states)))
|
||||
.collect(),
|
||||
tags: bound_tags,
|
||||
tree_blocks: std::sync::OnceLock::new(),
|
||||
air: [
|
||||
get("minecraft:air")?,
|
||||
get("minecraft:cave_air")?,
|
||||
|
||||
@@ -0,0 +1,700 @@
|
||||
//! Underground structures expressed as features: lakes, monster rooms
|
||||
//! (dungeons) and geodes.
|
||||
use super::{
|
||||
DecodeError, Object,
|
||||
block_feature::FeatureBlockBindings,
|
||||
block_predicate::BlockPredicate,
|
||||
double_range,
|
||||
feature::FeatureWorld,
|
||||
feature_graph::FeatureExecutionError,
|
||||
int_range, optional,
|
||||
placement::{PlacementContext, PlacementQueryError},
|
||||
required,
|
||||
state_provider::BlockStateProvider,
|
||||
tree::{TreeDecoder, TreeResult, kind, read, sample_state, write},
|
||||
tree_blocks::{self as tb, TreeBlocks},
|
||||
value_provider::IntProvider,
|
||||
};
|
||||
use crate::registry::BlockStateId;
|
||||
use horizon_core::{
|
||||
geometry::Direction,
|
||||
noise::{Noise, NormalNoise},
|
||||
random::{LegacyRandom, RandomSource},
|
||||
};
|
||||
use std::{collections::BTreeSet, sync::Arc};
|
||||
|
||||
fn query<E>(error: PlacementQueryError) -> FeatureExecutionError<E> {
|
||||
FeatureExecutionError::Query(error)
|
||||
}
|
||||
fn state<E>(blocks: &TreeBlocks, name: &str) -> TreeResult<BlockStateId, E> {
|
||||
blocks
|
||||
.default_state(name)
|
||||
.ok_or(FeatureExecutionError::InvalidState)
|
||||
}
|
||||
/// Feature.safeSetBlock.
|
||||
fn safe_set<W: FeatureWorld>(
|
||||
world: &mut W,
|
||||
p: [i32; 3],
|
||||
value: BlockStateId,
|
||||
cannot_replace: impl Fn(BlockStateId) -> bool,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
if !cannot_replace(read(world, p)?) {
|
||||
write(world, p, value, 2)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// Feature.markAboveForPostProcessing.
|
||||
fn mark_above<W: FeatureWorld + PlacementContext>(
|
||||
world: &mut W,
|
||||
blocks: &TreeBlocks,
|
||||
p: [i32; 3],
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let mut above = p;
|
||||
for _ in 0..2 {
|
||||
above = tb::offset(above, 0, 1, 0);
|
||||
if blocks.is_air(read(world, above)?) {
|
||||
return Ok(());
|
||||
}
|
||||
world.mark_postprocessing(above).map_err(query)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct LakeFeature {
|
||||
fluid: BlockStateProvider,
|
||||
barrier: BlockStateProvider,
|
||||
can_place: BlockPredicate,
|
||||
can_replace_air_or_fluid: BlockPredicate,
|
||||
can_replace_barrier: BlockPredicate,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
impl LakeFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:lake" {
|
||||
return Err(DecodeError::Field("lake type"));
|
||||
}
|
||||
let blocks = bindings.tree_blocks()?;
|
||||
let mut decoder = TreeDecoder {
|
||||
bindings,
|
||||
depth,
|
||||
remaining,
|
||||
};
|
||||
let fluid = decoder.provider(required(&object, "fluid")?)?;
|
||||
let barrier = decoder.provider(required(&object, "barrier")?)?;
|
||||
let mut predicate = |name: &'static str| {
|
||||
BlockPredicate::decode_with_blocks(
|
||||
required(&object, name)?.get(),
|
||||
depth + 1,
|
||||
decoder.remaining,
|
||||
Some(bindings),
|
||||
)
|
||||
};
|
||||
Ok(Self {
|
||||
fluid,
|
||||
barrier,
|
||||
can_place: predicate("can_place_feature")?,
|
||||
can_replace_air_or_fluid: predicate("can_replace_with_air_or_fluid")?,
|
||||
can_replace_barrier: predicate("can_replace_with_barrier")?,
|
||||
blocks,
|
||||
})
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if origin[1] <= world.min_y().map_err(query)?.wrapping_add(4) {
|
||||
return Ok(false);
|
||||
}
|
||||
let origin = tb::offset(origin, -8, -4, -8);
|
||||
let mut grid = [false; 2048];
|
||||
let spots = random.next_int_bound(4)? + 4;
|
||||
for _ in 0..spots {
|
||||
let xr = random.next_double() * 6.0 + 3.0;
|
||||
let yr = random.next_double() * 4.0 + 2.0;
|
||||
let zr = random.next_double() * 6.0 + 3.0;
|
||||
let xp = random.next_double() * (16.0 - xr - 2.0) + 1.0 + xr / 2.0;
|
||||
let yp = random.next_double() * (8.0 - yr - 4.0) + 2.0 + yr / 2.0;
|
||||
let zp = random.next_double() * (16.0 - zr - 2.0) + 1.0 + zr / 2.0;
|
||||
for xx in 1..15 {
|
||||
for zz in 1..15 {
|
||||
for yy in 1..7 {
|
||||
let xd = (f64::from(xx) - xp) / (xr / 2.0);
|
||||
let yd = (f64::from(yy) - yp) / (yr / 2.0);
|
||||
let zd = (f64::from(zz) - zp) / (zr / 2.0);
|
||||
if xd * xd + yd * yd + zd * zd < 1.0 {
|
||||
grid[((xx * 16 + zz) * 8 + yy) as usize] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let at = |x: i32, y: i32, z: i32| grid[((x * 16 + z) * 8 + y) as usize];
|
||||
let edge = |x: i32, y: i32, z: i32| {
|
||||
!at(x, y, z)
|
||||
&& ((x < 15 && at(x + 1, y, z))
|
||||
|| (x > 0 && at(x - 1, y, z))
|
||||
|| (z < 15 && at(x, y, z + 1))
|
||||
|| (z > 0 && at(x, y, z - 1))
|
||||
|| (y < 7 && at(x, y + 1, z))
|
||||
|| (y > 0 && at(x, y - 1, z)))
|
||||
};
|
||||
let fluid = sample_state(&self.fluid, world, random, origin)?;
|
||||
for xx in 0..16 {
|
||||
for zz in 0..16 {
|
||||
for yy in 0..8 {
|
||||
if edge(xx, yy, zz) {
|
||||
let p = tb::offset(origin, xx, yy, zz);
|
||||
let state = read(world, p)?;
|
||||
if yy >= 4 && self.blocks.has(state, tb::LIQUID) {
|
||||
return Ok(false);
|
||||
}
|
||||
if yy < 4 && !self.blocks.has(state, tb::SOLID) && state != fluid {
|
||||
return Ok(false);
|
||||
}
|
||||
if !self.can_place.test(world, p).map_err(query)? {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let cave_air = state(&self.blocks, "minecraft:cave_air")?;
|
||||
for xx in 0..16 {
|
||||
for zz in 0..16 {
|
||||
for yy in 0..8 {
|
||||
if at(xx, yy, zz) {
|
||||
let p = tb::offset(origin, xx, yy, zz);
|
||||
if self
|
||||
.can_replace_air_or_fluid
|
||||
.test(world, p)
|
||||
.map_err(query)?
|
||||
{
|
||||
let air = yy >= 4;
|
||||
write(world, p, if air { cave_air } else { fluid }, 2)?;
|
||||
if air {
|
||||
world.schedule_block_tick(p, cave_air, 0).map_err(query)?;
|
||||
mark_above(world, &self.blocks, p)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let barrier = sample_state(&self.barrier, world, random, origin)?;
|
||||
if !self.blocks.is_air(barrier) {
|
||||
for xx in 0..16 {
|
||||
for zz in 0..16 {
|
||||
for yy in 0..8 {
|
||||
if edge(xx, yy, zz) && (yy < 4 || random.next_int_bound(2)? != 0) {
|
||||
let p = tb::offset(origin, xx, yy, zz);
|
||||
let state = read(world, p)?;
|
||||
if self.blocks.has(state, tb::SOLID)
|
||||
&& self.can_replace_barrier.test(world, p).map_err(query)?
|
||||
{
|
||||
write(world, p, barrier, 2)?;
|
||||
mark_above(world, &self.blocks, p)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if self.blocks.has(fluid, tb::WATER_FLUID) {
|
||||
let ice = state(&self.blocks, "minecraft:ice")?;
|
||||
for xx in 0..16 {
|
||||
for zz in 0..16 {
|
||||
let p = tb::offset(origin, xx, 4, zz);
|
||||
let biome = world.biome_identity(p).map_err(query)?;
|
||||
if world.biome_should_freeze(biome, p, false).map_err(query)?
|
||||
&& self
|
||||
.can_replace_air_or_fluid
|
||||
.test(world, p)
|
||||
.map_err(query)?
|
||||
{
|
||||
write(world, p, ice, 2)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
const DUNGEON_MOBS: [&str; 4] = [
|
||||
"minecraft:skeleton",
|
||||
"minecraft:zombie",
|
||||
"minecraft:zombie",
|
||||
"minecraft:spider",
|
||||
];
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct MonsterRoomFeature {
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
impl MonsterRoomFeature {
|
||||
pub(crate) fn new(bindings: &FeatureBlockBindings<'_>) -> Result<Self, DecodeError> {
|
||||
Ok(Self {
|
||||
blocks: bindings.tree_blocks()?,
|
||||
})
|
||||
}
|
||||
fn solid<W: FeatureWorld>(&self, world: &mut W, p: [i32; 3]) -> TreeResult<bool, W::Error> {
|
||||
Ok(self.blocks.has(read(world, p)?, tb::SOLID))
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let blocks = &*self.blocks;
|
||||
let cannot = |s: BlockStateId| blocks.has(s, tb::FEATURES_CANNOT_REPLACE);
|
||||
let xr = random.next_int_bound(2)? + 2;
|
||||
let (min_x, max_x) = (-xr - 1, xr + 1);
|
||||
let zr = random.next_int_bound(2)? + 2;
|
||||
let (min_z, max_z) = (-zr - 1, zr + 1);
|
||||
let mut holes = 0;
|
||||
for dx in min_x..=max_x {
|
||||
for dy in -1..=4 {
|
||||
for dz in min_z..=max_z {
|
||||
let p = tb::offset(origin, dx, dy, dz);
|
||||
let solid = self.solid(world, p)?;
|
||||
if (dy == -1 || dy == 4) && !solid {
|
||||
return Ok(false);
|
||||
}
|
||||
if (dx == min_x || dx == max_x || dz == min_z || dz == max_z)
|
||||
&& dy == 0
|
||||
&& blocks.is_air(read(world, p)?)
|
||||
&& blocks.is_air(read(world, tb::offset(p, 0, 1, 0))?)
|
||||
{
|
||||
holes += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if !(1..=5).contains(&holes) {
|
||||
return Ok(false);
|
||||
}
|
||||
let cave_air = state(blocks, "minecraft:cave_air")?;
|
||||
let cobble = state(blocks, "minecraft:cobblestone")?;
|
||||
let mossy = state(blocks, "minecraft:mossy_cobblestone")?;
|
||||
let min_y = world.min_y().map_err(query)?;
|
||||
for dx in min_x..=max_x {
|
||||
for dy in (-1..=3).rev() {
|
||||
for dz in min_z..=max_z {
|
||||
let p = tb::offset(origin, dx, dy, dz);
|
||||
let wall = read(world, p)?;
|
||||
if dx == min_x
|
||||
|| dy == -1
|
||||
|| dz == min_z
|
||||
|| dx == max_x
|
||||
|| dy == 4
|
||||
|| dz == max_z
|
||||
{
|
||||
if p[1] >= min_y && !self.solid(world, tb::offset(p, 0, -1, 0))? {
|
||||
write(world, p, cave_air, 2)?;
|
||||
} else if blocks.has(wall, tb::SOLID) && !blocks.has(wall, tb::CHEST) {
|
||||
let value = if dy == -1 && random.next_int_bound(4)? != 0 {
|
||||
mossy
|
||||
} else {
|
||||
cobble
|
||||
};
|
||||
safe_set(world, p, value, cannot)?;
|
||||
}
|
||||
} else if !blocks.has(wall, tb::CHEST | tb::SPAWNER) {
|
||||
safe_set(world, p, cave_air, cannot)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let chest = state(blocks, "minecraft:chest")?;
|
||||
for _ in 0..2 {
|
||||
for _ in 0..3 {
|
||||
let x = origin[0]
|
||||
.wrapping_add(random.next_int_bound(xr * 2 + 1)?)
|
||||
.wrapping_sub(xr);
|
||||
let z = origin[2]
|
||||
.wrapping_add(random.next_int_bound(zr * 2 + 1)?)
|
||||
.wrapping_sub(zr);
|
||||
let p = [x, origin[1], z];
|
||||
if !blocks.is_air(read(world, p)?) {
|
||||
continue;
|
||||
}
|
||||
let mut walls = 0;
|
||||
for direction in tb::HORIZONTAL {
|
||||
if self.solid(world, tb::relative(p, direction, 1))? {
|
||||
walls += 1;
|
||||
}
|
||||
}
|
||||
if walls == 1 {
|
||||
let oriented = self.reorient(world, p, chest)?;
|
||||
safe_set(world, p, oriented, cannot)?;
|
||||
world
|
||||
.set_block_entity_loot_table(p, "minecraft:chests/simple_dungeon", random)
|
||||
.map_err(query)?;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
let spawner = state(blocks, "minecraft:spawner")?;
|
||||
safe_set(world, origin, spawner, cannot)?;
|
||||
if read(world, origin)? == spawner {
|
||||
let mob = DUNGEON_MOBS[random.next_int_bound(4)? as usize];
|
||||
world.configure_spawner(origin, mob).map_err(query)?;
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
/// StructurePiece.reorient for the chest's horizontal facing.
|
||||
fn reorient<W: FeatureWorld>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
p: [i32; 3],
|
||||
chest: BlockStateId,
|
||||
) -> TreeResult<BlockStateId, W::Error> {
|
||||
let blocks = &*self.blocks;
|
||||
let mut solid_neighbor = None;
|
||||
for direction in tb::HORIZONTAL {
|
||||
let state = read(world, tb::relative(p, direction, 1))?;
|
||||
if blocks.has(state, tb::CHEST) {
|
||||
return Ok(chest);
|
||||
}
|
||||
if blocks.has(state, tb::SOLID_RENDER) {
|
||||
if solid_neighbor.is_some() {
|
||||
solid_neighbor = None;
|
||||
break;
|
||||
}
|
||||
solid_neighbor = Some(direction);
|
||||
}
|
||||
}
|
||||
let facing = |d: Direction| {
|
||||
blocks
|
||||
.with(chest, "facing", tb::direction_name(d))
|
||||
.ok_or(FeatureExecutionError::InvalidState)
|
||||
};
|
||||
if let Some(direction) = solid_neighbor {
|
||||
return facing(direction.opposite());
|
||||
}
|
||||
let mut lock = blocks
|
||||
.properties
|
||||
.value(chest, "facing")
|
||||
.and_then(|v| tb::decode_direction(v).ok())
|
||||
.ok_or(FeatureExecutionError::InvalidState)?;
|
||||
let mut rel = tb::relative(p, lock, 1);
|
||||
if blocks.has(read(world, rel)?, tb::SOLID_RENDER) {
|
||||
lock = lock.opposite();
|
||||
rel = tb::relative(p, lock, 1);
|
||||
}
|
||||
if blocks.has(read(world, rel)?, tb::SOLID_RENDER) {
|
||||
lock = tb::clockwise(lock);
|
||||
rel = tb::relative(p, lock, 1);
|
||||
}
|
||||
if blocks.has(read(world, rel)?, tb::SOLID_RENDER) {
|
||||
lock = lock.opposite();
|
||||
}
|
||||
facing(lock)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct GeodeFeature {
|
||||
filling: BlockStateProvider,
|
||||
inner: BlockStateProvider,
|
||||
alternate_inner: BlockStateProvider,
|
||||
middle: BlockStateProvider,
|
||||
outer: BlockStateProvider,
|
||||
inner_placements: Vec<BlockStateId>,
|
||||
cannot_replace: Arc<BTreeSet<BlockStateId>>,
|
||||
invalid_blocks: Arc<BTreeSet<BlockStateId>>,
|
||||
layers: [f64; 4],
|
||||
crack_chance: f64,
|
||||
base_crack_size: f64,
|
||||
crack_point_offset: i32,
|
||||
potential_chance: f64,
|
||||
alternate_chance: f64,
|
||||
require_alternate: bool,
|
||||
outer_wall_distance: IntProvider,
|
||||
distribution_points: IntProvider,
|
||||
point_offset: IntProvider,
|
||||
min_gen_offset: i32,
|
||||
max_gen_offset: i32,
|
||||
noise_multiplier: f64,
|
||||
invalid_threshold: i32,
|
||||
noise: NormalNoise,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
fn chance(object: &Object, name: &'static str, default: f64) -> Result<f64, DecodeError> {
|
||||
optional(object, name)
|
||||
.map(|raw| double_range(raw, name, 0.0, 1.0))
|
||||
.transpose()
|
||||
.map(|v| v.unwrap_or(default))
|
||||
}
|
||||
impl GeodeFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:geode" {
|
||||
return Err(DecodeError::Field("geode type"));
|
||||
}
|
||||
let blocks = bindings.tree_blocks()?;
|
||||
let mut decoder = TreeDecoder {
|
||||
bindings,
|
||||
depth,
|
||||
remaining,
|
||||
};
|
||||
let settings: Object = serde_json::from_str(required(&object, "blocks")?.get())?;
|
||||
let placements: Vec<Box<serde_json::value::RawValue>> =
|
||||
serde_json::from_str(required(&settings, "inner_placements")?.get())?;
|
||||
if placements.is_empty() || placements.len() > 8192 {
|
||||
return Err(DecodeError::Field("geode inner placements"));
|
||||
}
|
||||
let inner_placements = placements
|
||||
.iter()
|
||||
.map(|raw| {
|
||||
bindings
|
||||
.codec
|
||||
.decode(raw.get(), false)
|
||||
.map_err(|e| DecodeError::Registry(e.to_string()))
|
||||
})
|
||||
.collect::<Result<_, _>>()?;
|
||||
let layers: Object = serde_json::from_str(required(&object, "layers")?.get())?;
|
||||
let layer = |name: &'static str, default: f64| {
|
||||
optional(&layers, name)
|
||||
.map(|raw| double_range(raw, name, 0.01, 50.0))
|
||||
.transpose()
|
||||
.map(|v| v.unwrap_or(default))
|
||||
};
|
||||
let crack: Object = serde_json::from_str(required(&object, "crack")?.get())?;
|
||||
let mut provider =
|
||||
|name: &'static str, default: [i32; 2], low: i32, high: i32| match optional(
|
||||
&object, name,
|
||||
) {
|
||||
Some(raw) => decoder.int_provider(raw, low, high),
|
||||
None => Ok(IntProvider::Uniform {
|
||||
min: default[0],
|
||||
max: default[1],
|
||||
}),
|
||||
};
|
||||
let outer_wall_distance = provider("outer_wall_distance", [4, 5], 1, 20)?;
|
||||
let distribution_points = provider("distribution_points", [3, 4], 1, 20)?;
|
||||
let point_offset = provider("point_offset", [1, 2], 0, 10)?;
|
||||
let int_or = |name: &'static str, default: i32| {
|
||||
optional(&object, name)
|
||||
.map(super::integer)
|
||||
.transpose()
|
||||
.map(|v| v.unwrap_or(default))
|
||||
};
|
||||
Ok(Self {
|
||||
filling: decoder.provider(required(&settings, "filling_provider")?)?,
|
||||
inner: decoder.provider(required(&settings, "inner_layer_provider")?)?,
|
||||
alternate_inner: decoder
|
||||
.provider(required(&settings, "alternate_inner_layer_provider")?)?,
|
||||
middle: decoder.provider(required(&settings, "middle_layer_provider")?)?,
|
||||
outer: decoder.provider(required(&settings, "outer_layer_provider")?)?,
|
||||
inner_placements,
|
||||
cannot_replace: decoder.block_set(required(&settings, "cannot_replace")?)?,
|
||||
invalid_blocks: decoder.block_set(required(&settings, "invalid_blocks")?)?,
|
||||
layers: [
|
||||
layer("filling", 1.7)?,
|
||||
layer("inner_layer", 2.2)?,
|
||||
layer("middle_layer", 3.2)?,
|
||||
layer("outer_layer", 4.2)?,
|
||||
],
|
||||
crack_chance: chance(&crack, "generate_crack_chance", 1.0)?,
|
||||
base_crack_size: optional(&crack, "base_crack_size")
|
||||
.map(|raw| double_range(raw, "base_crack_size", 0.0, 5.0))
|
||||
.transpose()?
|
||||
.unwrap_or(2.0),
|
||||
crack_point_offset: optional(&crack, "crack_point_offset")
|
||||
.map(|raw| int_range(raw, "crack_point_offset", 0, 10))
|
||||
.transpose()?
|
||||
.unwrap_or(2),
|
||||
potential_chance: chance(&object, "use_potential_placements_chance", 0.35)?,
|
||||
alternate_chance: chance(&object, "use_alternate_layer0_chance", 0.0)?,
|
||||
require_alternate: optional(&object, "placements_require_layer0_alternate")
|
||||
.map(|raw| serde_json::from_str::<bool>(raw.get()))
|
||||
.transpose()?
|
||||
.unwrap_or(true),
|
||||
outer_wall_distance,
|
||||
distribution_points,
|
||||
point_offset,
|
||||
min_gen_offset: int_or("min_gen_offset", -16)?,
|
||||
max_gen_offset: int_or("max_gen_offset", 16)?,
|
||||
noise_multiplier: chance(&object, "noise_multiplier", 0.05)?,
|
||||
invalid_threshold: super::integer(required(&object, "invalid_blocks_threshold")?)?,
|
||||
noise: NormalNoise::create_parity(-4, &[1.0])?,
|
||||
blocks,
|
||||
})
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let blocks = &*self.blocks;
|
||||
let cannot = |s: BlockStateId| self.cannot_replace.contains(&s);
|
||||
let num_points = self.distribution_points.sample(random)?;
|
||||
let seed = world.world_seed().map_err(query)?;
|
||||
let noise = self
|
||||
.noise
|
||||
.create(&mut LegacyRandom::new(seed))
|
||||
.map_err(|_| FeatureExecutionError::InvalidState)?;
|
||||
let crack_adjust = f64::from(num_points) / f64::from(self.outer_wall_distance.bounds()[1]);
|
||||
let [filling, inner, middle, outer] = self.layers;
|
||||
let inner_air = 1.0 / filling.sqrt();
|
||||
let innermost = 1.0 / (inner + crack_adjust).sqrt();
|
||||
let inner_crust = 1.0 / (middle + crack_adjust).sqrt();
|
||||
let outer_crust = 1.0 / (outer + crack_adjust).sqrt();
|
||||
let crack_size = 1.0
|
||||
/ (self.base_crack_size
|
||||
+ random.next_double() / 2.0
|
||||
+ if num_points > 3 { crack_adjust } else { 0.0 })
|
||||
.sqrt();
|
||||
let crack = f64::from(random.next_float()) < self.crack_chance;
|
||||
let mut invalid = 0;
|
||||
let mut points = Vec::new();
|
||||
for _ in 0..num_points {
|
||||
let x = self.outer_wall_distance.sample(random)?;
|
||||
let y = self.outer_wall_distance.sample(random)?;
|
||||
let z = self.outer_wall_distance.sample(random)?;
|
||||
let p = tb::offset(origin, x, y, z);
|
||||
let state = read(world, p)?;
|
||||
if blocks.is_air(state) || self.invalid_blocks.contains(&state) {
|
||||
invalid += 1;
|
||||
if invalid > self.invalid_threshold {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
points.push((p, self.point_offset.sample(random)?));
|
||||
}
|
||||
let mut crack_points = Vec::new();
|
||||
if crack {
|
||||
let index = random.next_int_bound(4)?;
|
||||
let o = num_points * 2 + 1;
|
||||
let (cx, cz) = match index {
|
||||
0 => (o, 0),
|
||||
1 => (0, o),
|
||||
2 => (o, o),
|
||||
_ => (0, 0),
|
||||
};
|
||||
for y in [7, 5, 1] {
|
||||
crack_points.push(tb::offset(origin, cx, y, cz));
|
||||
}
|
||||
}
|
||||
let dist_sqr = |a: [i32; 3], b: [i32; 3]| -> f64 {
|
||||
(0..3)
|
||||
.map(|i| {
|
||||
let d = f64::from(a[i]) - f64::from(b[i]);
|
||||
d * d
|
||||
})
|
||||
.sum()
|
||||
};
|
||||
let mut potential = Vec::new();
|
||||
let air_state = blocks
|
||||
.default_state("minecraft:air")
|
||||
.ok_or(FeatureExecutionError::InvalidState)?;
|
||||
let (lo, hi) = (self.min_gen_offset, self.max_gen_offset);
|
||||
// BlockPos.betweenClosed iterates x fastest, then y, then z.
|
||||
for dz in lo..=hi {
|
||||
for dy in lo..=hi {
|
||||
for dx in lo..=hi {
|
||||
let p = tb::offset(origin, dx, dy, dz);
|
||||
let noise_offset =
|
||||
f64::from(noise.get3(f64::from(p[0]), f64::from(p[1]), f64::from(p[2])))
|
||||
* self.noise_multiplier;
|
||||
let mut shell = 0.0;
|
||||
for (point, offset) in &points {
|
||||
shell +=
|
||||
1.0 / (dist_sqr(p, *point) + f64::from(*offset)).sqrt() + noise_offset;
|
||||
}
|
||||
if shell < outer_crust {
|
||||
continue;
|
||||
}
|
||||
if shell >= inner_air {
|
||||
let value = sample_state(&self.filling, world, random, p)?;
|
||||
safe_set(world, p, value, cannot)?;
|
||||
continue;
|
||||
}
|
||||
let mut crack_sum = 0.0;
|
||||
for point in &crack_points {
|
||||
crack_sum += 1.0
|
||||
/ (dist_sqr(p, *point) + f64::from(self.crack_point_offset)).sqrt()
|
||||
+ noise_offset;
|
||||
}
|
||||
if crack && crack_sum >= crack_size {
|
||||
safe_set(world, p, air_state, cannot)?;
|
||||
for direction in Direction::ALL {
|
||||
let q = tb::relative(p, direction, 1);
|
||||
let fluid = world.fluid_state(q).map_err(query)?;
|
||||
if fluid.kind() != crate::fluid::FluidKind::Empty {
|
||||
world
|
||||
.schedule_fluid_tick(q, fluid.kind(), 0)
|
||||
.map_err(query)?;
|
||||
}
|
||||
}
|
||||
} else if shell >= innermost {
|
||||
let alternate = f64::from(random.next_float()) < self.alternate_chance;
|
||||
let provider = if alternate {
|
||||
&self.alternate_inner
|
||||
} else {
|
||||
&self.inner
|
||||
};
|
||||
let value = sample_state(provider, world, random, p)?;
|
||||
safe_set(world, p, value, cannot)?;
|
||||
if (!self.require_alternate || alternate)
|
||||
&& f64::from(random.next_float()) < self.potential_chance
|
||||
{
|
||||
potential.push(p);
|
||||
}
|
||||
} else if shell >= inner_crust {
|
||||
let value = sample_state(&self.middle, world, random, p)?;
|
||||
safe_set(world, p, value, cannot)?;
|
||||
} else if shell >= outer_crust {
|
||||
let value = sample_state(&self.outer, world, random, p)?;
|
||||
safe_set(world, p, value, cannot)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for crystal in potential {
|
||||
let index = random.next_int_bound(self.inner_placements.len() as i32)? as usize;
|
||||
let mut state = self.inner_placements[index];
|
||||
for direction in Direction::ALL {
|
||||
if blocks
|
||||
.properties
|
||||
.values(state, "facing")
|
||||
.is_some_and(|v| v.len() == 6)
|
||||
{
|
||||
state = blocks
|
||||
.with(state, "facing", tb::direction_name(direction))
|
||||
.ok_or(FeatureExecutionError::InvalidState)?;
|
||||
}
|
||||
let target = tb::relative(crystal, direction, 1);
|
||||
let existing = read(world, target)?;
|
||||
if blocks.has(state, tb::WATERLOGGABLE) {
|
||||
state = blocks.waterlogged(state, blocks.has(existing, tb::FLUID_SOURCE));
|
||||
}
|
||||
// BuddingAmethystBlock.canClusterGrowAtState.
|
||||
if blocks.is_air(existing)
|
||||
|| (blocks.has(existing, tb::WATER_BLOCK)
|
||||
&& blocks.has(existing, tb::FLUID_FULL))
|
||||
{
|
||||
safe_set(world, target, state, cannot)?;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,803 @@
|
||||
//! `minecraft:speleothem_cluster` and `minecraft:large_dripstone`
|
||||
//! (SpeleothemClusterFeature, LargeDripstoneFeature and SpeleothemUtils).
|
||||
use super::{
|
||||
DecodeError, Object,
|
||||
block_feature::FeatureBlockBindings,
|
||||
feature::FeatureWorld,
|
||||
feature_graph::FeatureExecutionError,
|
||||
int_range, number_text, optional,
|
||||
placement::{PlacementContext, PlacementQueryError},
|
||||
required,
|
||||
tree::{TreeDecoder, TreeResult, kind, read, unit_float, write},
|
||||
tree_blocks::{self as tb, TreeBlocks},
|
||||
value_provider::{FloatProvider, IntProvider},
|
||||
};
|
||||
use crate::{heightmap::HeightmapType, registry::BlockStateId};
|
||||
use horizon_core::{geometry::trig, random::RandomSource};
|
||||
use std::{collections::BTreeSet, sync::Arc};
|
||||
|
||||
fn query<E>(error: PlacementQueryError) -> FeatureExecutionError<E> {
|
||||
FeatureExecutionError::Query(error)
|
||||
}
|
||||
/// Column.scan result: optional floor and ceiling edge heights.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
struct Column {
|
||||
floor: Option<i32>,
|
||||
ceiling: Option<i32>,
|
||||
}
|
||||
impl Column {
|
||||
fn height(&self) -> Option<i32> {
|
||||
match (self.floor, self.ceiling) {
|
||||
(Some(floor), Some(ceiling)) => Some(ceiling - floor - 1),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Shared speleothem block classification.
|
||||
#[derive(Clone, Debug)]
|
||||
struct Speleothem {
|
||||
base: BlockStateId,
|
||||
pointed: BlockStateId,
|
||||
replaceable: Arc<BTreeSet<BlockStateId>>,
|
||||
lava: BlockStateId,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
impl Speleothem {
|
||||
fn new(
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
base: BlockStateId,
|
||||
pointed: BlockStateId,
|
||||
replaceable: Arc<BTreeSet<BlockStateId>>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let registry = bindings.registry();
|
||||
let default = |state: BlockStateId| {
|
||||
registry
|
||||
.default_state(®istry.state(state).unwrap().name)
|
||||
.ok_or(DecodeError::Field("speleothem block"))
|
||||
};
|
||||
Ok(Self {
|
||||
base: default(base)?,
|
||||
pointed: default(pointed)?,
|
||||
replaceable,
|
||||
lava: registry
|
||||
.default_state("minecraft:lava")
|
||||
.ok_or(DecodeError::Field("lava"))?,
|
||||
blocks: bindings.tree_blocks()?,
|
||||
})
|
||||
}
|
||||
fn empty_or_water(&self, s: BlockStateId) -> bool {
|
||||
self.blocks.is_air(s) || self.blocks.has(s, tb::WATER_BLOCK)
|
||||
}
|
||||
fn empty_water_or_lava(&self, s: BlockStateId) -> bool {
|
||||
self.empty_or_water(s) || self.blocks.same_block(s, self.lava)
|
||||
}
|
||||
fn is_base(&self, s: BlockStateId) -> bool {
|
||||
self.blocks.same_block(s, self.base) || self.replaceable.contains(&s)
|
||||
}
|
||||
fn scan<W: FeatureWorld>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
pos: [i32; 3],
|
||||
range: i32,
|
||||
edge: impl Fn(&Self, BlockStateId) -> bool,
|
||||
) -> TreeResult<Option<Column>, W::Error> {
|
||||
if !self.empty_or_water(read(world, pos)?) {
|
||||
return Ok(None);
|
||||
}
|
||||
let mut scan = |step: i32| -> TreeResult<Option<i32>, W::Error> {
|
||||
let mut p = pos;
|
||||
let mut i = 1;
|
||||
while i < range && self.empty_or_water(read(world, p)?) {
|
||||
p[1] = p[1].wrapping_add(step);
|
||||
i += 1;
|
||||
}
|
||||
Ok(edge(self, read(world, p)?).then_some(p[1]))
|
||||
};
|
||||
let ceiling = scan(1)?;
|
||||
let floor = scan(-1)?;
|
||||
Ok(Some(Column { floor, ceiling }))
|
||||
}
|
||||
fn pointed_state(&self, up: bool, thickness: &str) -> Option<BlockStateId> {
|
||||
let state = self.blocks.with(
|
||||
self.pointed,
|
||||
"vertical_direction",
|
||||
if up { "up" } else { "down" },
|
||||
)?;
|
||||
self.blocks.with(state, "thickness", thickness)
|
||||
}
|
||||
/// SpeleothemUtils.growSpeleothem.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn grow<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
start: [i32; 3],
|
||||
up: bool,
|
||||
height: i32,
|
||||
merged: bool,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let step = if up { 1 } else { -1 };
|
||||
if !self.is_base(read(world, tb::offset(start, 0, -step, 0))?) {
|
||||
return Ok(());
|
||||
}
|
||||
let mut sequence = Vec::new();
|
||||
if height >= 3 {
|
||||
sequence.push("base");
|
||||
sequence.extend(std::iter::repeat_n("middle", (height - 3) as usize));
|
||||
}
|
||||
if height >= 2 {
|
||||
sequence.push("frustum");
|
||||
}
|
||||
if height >= 1 {
|
||||
sequence.push(if merged { "tip_merge" } else { "tip" });
|
||||
}
|
||||
let mut p = start;
|
||||
for thickness in sequence {
|
||||
let mut state = self
|
||||
.pointed_state(up, thickness)
|
||||
.ok_or(FeatureExecutionError::InvalidState)?;
|
||||
let water = self.blocks.has(read(world, p)?, tb::WATER_FLUID);
|
||||
state = self.blocks.waterlogged(state, water);
|
||||
write(world, p, state, 2)?;
|
||||
p[1] = p[1].wrapping_add(step);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn place_base_if_possible<W: FeatureWorld>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
p: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if self.replaceable.contains(&read(world, p)?) {
|
||||
write(world, p, self.base, 2)?;
|
||||
return Ok(true);
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
}
|
||||
|
||||
fn float_provider(
|
||||
raw: &serde_json::value::RawValue,
|
||||
low: f32,
|
||||
high: f32,
|
||||
) -> Result<FloatProvider, DecodeError> {
|
||||
let value = FloatProvider::from_json(raw.get())?;
|
||||
let [min, max] = value.bounds();
|
||||
if min < low || max > high {
|
||||
return Err(DecodeError::Field("float provider bounds"));
|
||||
}
|
||||
Ok(value)
|
||||
}
|
||||
fn float_range(
|
||||
raw: &serde_json::value::RawValue,
|
||||
name: &'static str,
|
||||
low: f32,
|
||||
high: f32,
|
||||
) -> Result<f32, DecodeError> {
|
||||
let value: f32 = number_text(raw)?
|
||||
.parse()
|
||||
.map_err(|_| DecodeError::Field(name))?;
|
||||
if !(low..=high).contains(&value) {
|
||||
return Err(DecodeError::Field(name));
|
||||
}
|
||||
Ok(value)
|
||||
}
|
||||
fn block_state(
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
raw: &serde_json::value::RawValue,
|
||||
) -> Result<BlockStateId, DecodeError> {
|
||||
bindings
|
||||
.codec
|
||||
.decode(raw.get(), false)
|
||||
.map_err(|e| DecodeError::Registry(e.to_string()))
|
||||
}
|
||||
fn clamped_lerp(factor: f64, min: f64, max: f64) -> f64 {
|
||||
if factor < 0.0 {
|
||||
min
|
||||
} else if factor > 1.0 {
|
||||
max
|
||||
} else {
|
||||
min + factor * (max - min)
|
||||
}
|
||||
}
|
||||
fn clamped_lerp_f32(factor: f32, min: f32, max: f32) -> f32 {
|
||||
if factor < 0.0 {
|
||||
min
|
||||
} else if factor > 1.0 {
|
||||
max
|
||||
} else {
|
||||
min + factor * (max - min)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SpeleothemClusterFeature {
|
||||
speleothem: Speleothem,
|
||||
search_range: i32,
|
||||
height: IntProvider,
|
||||
radius: IntProvider,
|
||||
max_height_diff: i32,
|
||||
height_deviation: i32,
|
||||
layer_thickness: IntProvider,
|
||||
density: FloatProvider,
|
||||
wetness: FloatProvider,
|
||||
chance_at_max_distance: f32,
|
||||
max_distance_from_edge: i32,
|
||||
max_distance_from_center: i32,
|
||||
}
|
||||
impl SpeleothemClusterFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:speleothem_cluster" {
|
||||
return Err(DecodeError::Field("speleothem cluster type"));
|
||||
}
|
||||
let mut decoder = TreeDecoder {
|
||||
bindings,
|
||||
depth,
|
||||
remaining,
|
||||
};
|
||||
let int = |name: &'static str, low: i32, high: i32| {
|
||||
int_range(required(&object, name)?, name, low, high)
|
||||
};
|
||||
Ok(Self {
|
||||
speleothem: Speleothem::new(
|
||||
bindings,
|
||||
block_state(bindings, required(&object, "base_block")?)?,
|
||||
block_state(bindings, required(&object, "pointed_block")?)?,
|
||||
decoder.block_set(required(&object, "replaceable_blocks")?)?,
|
||||
)?,
|
||||
search_range: int("floor_to_ceiling_search_range", 1, 512)?,
|
||||
height: decoder.int_provider(required(&object, "height")?, 1, 128)?,
|
||||
radius: decoder.int_provider(required(&object, "radius")?, 1, 128)?,
|
||||
max_height_diff: int("max_stalagmite_stalactite_height_diff", 0, 64)?,
|
||||
height_deviation: int("height_deviation", 1, 64)?,
|
||||
layer_thickness: decoder.int_provider(
|
||||
required(&object, "speleothem_block_layer_thickness")?,
|
||||
0,
|
||||
128,
|
||||
)?,
|
||||
density: float_provider(required(&object, "density")?, 0.0, 2.0)?,
|
||||
wetness: float_provider(required(&object, "wetness")?, 0.0, 2.0)?,
|
||||
chance_at_max_distance: unit_float(
|
||||
required(&object, "chance_of_speleothem_at_max_distance_from_center")?,
|
||||
"chance_of_speleothem_at_max_distance_from_center",
|
||||
)?,
|
||||
max_distance_from_edge: int(
|
||||
"max_distance_from_edge_affecting_chance_of_speleothem",
|
||||
1,
|
||||
64,
|
||||
)?,
|
||||
max_distance_from_center: int("max_distance_from_center_affecting_height_bias", 1, 64)?,
|
||||
})
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if !self.speleothem.empty_or_water(read(world, origin)?) {
|
||||
return Ok(false);
|
||||
}
|
||||
let height = self.height.sample(random)?;
|
||||
let wetness = self.wetness.sample(random);
|
||||
let density = self.density.sample(random);
|
||||
let x_radius = self.radius.sample(random)?;
|
||||
let z_radius = self.radius.sample(random)?;
|
||||
for dx in -x_radius..=x_radius {
|
||||
for dz in -z_radius..=z_radius {
|
||||
let distance = (x_radius - dx.abs()).min(z_radius - dz.abs());
|
||||
let chance = f64::from(clamped_lerp_f32(
|
||||
(distance as f32 - 0.0) / (self.max_distance_from_edge as f32 - 0.0),
|
||||
self.chance_at_max_distance,
|
||||
1.0,
|
||||
));
|
||||
let p = tb::offset(origin, dx, 0, dz);
|
||||
self.column(world, random, p, dx, dz, wetness, chance, height, density)?;
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn column<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
pos: [i32; 3],
|
||||
dx: i32,
|
||||
dz: i32,
|
||||
chance_of_water: f32,
|
||||
chance: f64,
|
||||
cluster_height: i32,
|
||||
density: f32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let s = &self.speleothem;
|
||||
let Some(base_column) =
|
||||
s.scan(world, pos, self.search_range, |s, st| !s.empty_or_water(st))?
|
||||
else {
|
||||
return Ok(());
|
||||
};
|
||||
let ceiling = base_column.ceiling;
|
||||
let base_floor = base_column.floor;
|
||||
if ceiling.is_none() && base_floor.is_none() {
|
||||
return Ok(());
|
||||
}
|
||||
let want_pool = random.next_float() < chance_of_water;
|
||||
let column = match base_floor {
|
||||
Some(floor_y)
|
||||
if want_pool && self.can_place_pool(world, [pos[0], floor_y, pos[2]])? =>
|
||||
{
|
||||
let water = s
|
||||
.blocks
|
||||
.default_state("minecraft:water")
|
||||
.ok_or(FeatureExecutionError::InvalidState)?;
|
||||
write(world, [pos[0], floor_y, pos[2]], water, 2)?;
|
||||
Column {
|
||||
floor: Some(floor_y - 1),
|
||||
ceiling,
|
||||
}
|
||||
}
|
||||
_ => base_column,
|
||||
};
|
||||
let floor = column.floor;
|
||||
let want_stalactite = random.next_double() < chance;
|
||||
let stalactite_height = match ceiling {
|
||||
Some(c)
|
||||
if want_stalactite
|
||||
&& !s
|
||||
.blocks
|
||||
.same_block(read(world, [pos[0], c, pos[2]])?, s.lava) =>
|
||||
{
|
||||
let thickness = self.layer_thickness.sample(random)?;
|
||||
self.replace_with_base(world, [pos[0], c, pos[2]], thickness, 1)?;
|
||||
let max = match floor {
|
||||
Some(f) => cluster_height.min(c - f),
|
||||
None => cluster_height,
|
||||
};
|
||||
self.speleothem_height(random, dx, dz, density, max)?
|
||||
}
|
||||
_ => 0,
|
||||
};
|
||||
let want_stalagmite = random.next_double() < chance;
|
||||
let stalagmite_height = match floor {
|
||||
Some(f)
|
||||
if want_stalagmite
|
||||
&& !s
|
||||
.blocks
|
||||
.same_block(read(world, [pos[0], f, pos[2]])?, s.lava) =>
|
||||
{
|
||||
let thickness = self.layer_thickness.sample(random)?;
|
||||
self.replace_with_base(world, [pos[0], f, pos[2]], thickness, -1)?;
|
||||
if ceiling.is_some() {
|
||||
let diff = self.max_height_diff;
|
||||
0.max(stalactite_height + random.next_int_bound(diff * 2 + 1)? - diff)
|
||||
} else {
|
||||
self.speleothem_height(random, dx, dz, density, cluster_height)?
|
||||
}
|
||||
}
|
||||
_ => 0,
|
||||
};
|
||||
let (actual_stalactite, actual_stalagmite) = match (ceiling, floor) {
|
||||
(Some(c), Some(f)) if c - stalactite_height <= f + stalagmite_height => {
|
||||
let lowest_bottom = (c - stalactite_height).max(f + 1);
|
||||
let highest_top = (f + stalagmite_height).min(c - 1);
|
||||
let bottom =
|
||||
random.next_int_bound(highest_top + 1 - lowest_bottom + 1)? + lowest_bottom;
|
||||
(c - bottom, bottom - 1 - f)
|
||||
}
|
||||
_ => (stalactite_height, stalagmite_height),
|
||||
};
|
||||
let merge = random.next_boolean()
|
||||
&& actual_stalactite > 0
|
||||
&& actual_stalagmite > 0
|
||||
&& column
|
||||
.height()
|
||||
.is_some_and(|h| actual_stalactite + actual_stalagmite == h);
|
||||
if let Some(c) = ceiling {
|
||||
s.grow(
|
||||
world,
|
||||
[pos[0], c - 1, pos[2]],
|
||||
false,
|
||||
actual_stalactite,
|
||||
merge,
|
||||
)?;
|
||||
}
|
||||
if let Some(f) = floor {
|
||||
s.grow(
|
||||
world,
|
||||
[pos[0], f + 1, pos[2]],
|
||||
true,
|
||||
actual_stalagmite,
|
||||
merge,
|
||||
)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn speleothem_height<E>(
|
||||
&self,
|
||||
random: &mut impl RandomSource,
|
||||
dx: i32,
|
||||
dz: i32,
|
||||
density: f32,
|
||||
max_height: i32,
|
||||
) -> TreeResult<i32, E> {
|
||||
if random.next_float() > density {
|
||||
return Ok(0);
|
||||
}
|
||||
let distance = dx.abs() + dz.abs();
|
||||
let mean = clamped_lerp(
|
||||
(f64::from(distance) - 0.0) / (f64::from(self.max_distance_from_center) - 0.0),
|
||||
f64::from(max_height) / 2.0,
|
||||
0.0,
|
||||
) as f32;
|
||||
let value = mean + random.next_gaussian() as f32 * self.height_deviation as f32;
|
||||
let clamped = if value < 0.0 {
|
||||
0.0
|
||||
} else {
|
||||
value.min(max_height as f32)
|
||||
};
|
||||
Ok(clamped as i32)
|
||||
}
|
||||
fn can_place_pool<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
p: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let s = &self.speleothem;
|
||||
let state = read(world, p)?;
|
||||
if s.blocks.has(state, tb::WATER_BLOCK)
|
||||
|| s.blocks.same_block(state, s.base)
|
||||
|| s.blocks.same_block(state, s.pointed)
|
||||
{
|
||||
return Ok(false);
|
||||
}
|
||||
if s.blocks
|
||||
.has(read(world, tb::offset(p, 0, 1, 0))?, tb::WATER_FLUID)
|
||||
{
|
||||
return Ok(false);
|
||||
}
|
||||
for direction in tb::HORIZONTAL {
|
||||
if !self.adjacent_ok(world, tb::relative(p, direction, 1))? {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
self.adjacent_ok(world, tb::offset(p, 0, -1, 0))
|
||||
}
|
||||
fn adjacent_ok<W: FeatureWorld>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
p: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let state = read(world, p)?;
|
||||
let b = &self.speleothem.blocks;
|
||||
Ok(b.has(state, tb::BASE_STONE_OVERWORLD) || b.has(state, tb::WATER_FLUID))
|
||||
}
|
||||
fn replace_with_base<W: FeatureWorld>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
first: [i32; 3],
|
||||
count: i32,
|
||||
step: i32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let mut p = first;
|
||||
for _ in 0..count {
|
||||
if !self.speleothem.place_base_if_possible(world, p)? {
|
||||
return Ok(());
|
||||
}
|
||||
p[1] = p[1].wrapping_add(step);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct LargeDripstoneFeature {
|
||||
speleothem: Speleothem,
|
||||
search_range: i32,
|
||||
column_radius: IntProvider,
|
||||
height_scale: FloatProvider,
|
||||
max_radius_ratio: f32,
|
||||
stalactite_bluntness: FloatProvider,
|
||||
stalagmite_bluntness: FloatProvider,
|
||||
wind_speed: FloatProvider,
|
||||
min_radius_for_wind: i32,
|
||||
min_bluntness_for_wind: f32,
|
||||
}
|
||||
struct LargeDripstone {
|
||||
root: [i32; 3],
|
||||
up: bool,
|
||||
radius: i32,
|
||||
bluntness: f64,
|
||||
scale: f64,
|
||||
}
|
||||
#[derive(Clone, Copy)]
|
||||
struct Wind {
|
||||
origin_y: i32,
|
||||
speed: Option<[f64; 3]>,
|
||||
max_offset: i32,
|
||||
}
|
||||
impl Wind {
|
||||
fn offset(&self, p: [i32; 3]) -> [i32; 3] {
|
||||
let Some(speed) = self.speed else {
|
||||
return p;
|
||||
};
|
||||
let dy = f64::from(self.origin_y.wrapping_sub(p[1]));
|
||||
let clamp = |v: f64| {
|
||||
let v = v.floor() as i32;
|
||||
if v < -self.max_offset {
|
||||
-self.max_offset
|
||||
} else {
|
||||
v.min(self.max_offset)
|
||||
}
|
||||
};
|
||||
tb::offset(p, clamp(speed[0] * dy), 0, clamp(speed[2] * dy))
|
||||
}
|
||||
}
|
||||
fn speleothem_height(distance: f64, radius: f64, scale: f64, bluntness: f64) -> f64 {
|
||||
let distance = if distance < bluntness {
|
||||
bluntness
|
||||
} else {
|
||||
distance
|
||||
};
|
||||
let r = distance / radius * 0.384;
|
||||
let part1 = 0.75 * r.powf(1.3333333333333333);
|
||||
let part2 = r.powf(0.6666666666666666);
|
||||
let part3 = 0.3333333333333333 * r.ln();
|
||||
let height = (scale * (part1 - part2 - part3)).max(0.0);
|
||||
height / 0.384 * radius
|
||||
}
|
||||
impl LargeDripstone {
|
||||
fn height_at(&self, radius: f32) -> i32 {
|
||||
speleothem_height(
|
||||
f64::from(radius),
|
||||
f64::from(self.radius),
|
||||
self.scale,
|
||||
self.bluntness,
|
||||
) as i32
|
||||
}
|
||||
}
|
||||
impl LargeDripstoneFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:large_dripstone" {
|
||||
return Err(DecodeError::Field("large dripstone type"));
|
||||
}
|
||||
let registry = bindings.registry();
|
||||
let dripstone = registry
|
||||
.default_state("minecraft:dripstone_block")
|
||||
.ok_or(DecodeError::Field("dripstone block"))?;
|
||||
let pointed = registry
|
||||
.default_state("minecraft:pointed_dripstone")
|
||||
.ok_or(DecodeError::Field("pointed dripstone"))?;
|
||||
let mut decoder = TreeDecoder {
|
||||
bindings,
|
||||
depth,
|
||||
remaining,
|
||||
};
|
||||
Ok(Self {
|
||||
speleothem: Speleothem::new(
|
||||
bindings,
|
||||
dripstone,
|
||||
pointed,
|
||||
decoder.block_set(required(&object, "replaceable_blocks")?)?,
|
||||
)?,
|
||||
search_range: optional(&object, "floor_to_ceiling_search_range")
|
||||
.map(|raw| int_range(raw, "floor_to_ceiling_search_range", 1, 512))
|
||||
.transpose()?
|
||||
.unwrap_or(30),
|
||||
column_radius: decoder.int_provider(required(&object, "column_radius")?, 1, 16)?,
|
||||
height_scale: float_provider(required(&object, "height_scale")?, 0.0, 20.0)?,
|
||||
max_radius_ratio: float_range(
|
||||
required(&object, "max_column_radius_to_cave_height_ratio")?,
|
||||
"max_column_radius_to_cave_height_ratio",
|
||||
0.1,
|
||||
1.0,
|
||||
)?,
|
||||
stalactite_bluntness: float_provider(
|
||||
required(&object, "stalactite_bluntness")?,
|
||||
0.1,
|
||||
10.0,
|
||||
)?,
|
||||
stalagmite_bluntness: float_provider(
|
||||
required(&object, "stalagmite_bluntness")?,
|
||||
0.1,
|
||||
10.0,
|
||||
)?,
|
||||
wind_speed: float_provider(required(&object, "wind_speed")?, 0.0, 2.0)?,
|
||||
min_radius_for_wind: int_range(
|
||||
required(&object, "min_radius_for_wind")?,
|
||||
"min_radius_for_wind",
|
||||
0,
|
||||
100,
|
||||
)?,
|
||||
min_bluntness_for_wind: float_range(
|
||||
required(&object, "min_bluntness_for_wind")?,
|
||||
"min_bluntness_for_wind",
|
||||
0.0,
|
||||
5.0,
|
||||
)?,
|
||||
})
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let s = &self.speleothem;
|
||||
if !s.empty_or_water(read(world, origin)?) {
|
||||
return Ok(false);
|
||||
}
|
||||
let Some(column) = s.scan(world, origin, self.search_range, |s, st| {
|
||||
s.is_base(st) || s.blocks.same_block(st, s.lava)
|
||||
})?
|
||||
else {
|
||||
return Ok(false);
|
||||
};
|
||||
let (Some(floor), Some(ceiling)) = (column.floor, column.ceiling) else {
|
||||
return Ok(false);
|
||||
};
|
||||
let height = ceiling - floor - 1;
|
||||
if height < 4 {
|
||||
return Ok(false);
|
||||
}
|
||||
let by_height = (height as f32 * self.max_radius_ratio) as i32;
|
||||
let [min_r, max_r] = self.column_radius.bounds();
|
||||
let max_radius = if by_height < min_r {
|
||||
min_r
|
||||
} else {
|
||||
by_height.min(max_r)
|
||||
};
|
||||
let radius = random.next_int_bound(max_radius - min_r + 1)? + min_r;
|
||||
let mut stalactite = LargeDripstone {
|
||||
root: [origin[0], ceiling - 1, origin[2]],
|
||||
up: false,
|
||||
radius,
|
||||
bluntness: f64::from(self.stalactite_bluntness.sample(random)),
|
||||
scale: f64::from(self.height_scale.sample(random)),
|
||||
};
|
||||
let mut stalagmite = LargeDripstone {
|
||||
root: [origin[0], floor + 1, origin[2]],
|
||||
up: true,
|
||||
radius,
|
||||
bluntness: f64::from(self.stalagmite_bluntness.sample(random)),
|
||||
scale: f64::from(self.height_scale.sample(random)),
|
||||
};
|
||||
let suitable = |d: &LargeDripstone| {
|
||||
d.radius >= self.min_radius_for_wind
|
||||
&& d.bluntness >= f64::from(self.min_bluntness_for_wind)
|
||||
};
|
||||
let wind = if suitable(&stalactite) && suitable(&stalagmite) {
|
||||
let speed = self.wind_speed.sample(random);
|
||||
let direction = random.next_float() * (std::f32::consts::PI - 0.0) + 0.0;
|
||||
Wind {
|
||||
origin_y: origin[1],
|
||||
speed: Some([
|
||||
f64::from(trig::cos(f64::from(direction)) * speed),
|
||||
0.0,
|
||||
f64::from(trig::sin(f64::from(direction)) * speed),
|
||||
]),
|
||||
max_offset: 16 - radius,
|
||||
}
|
||||
} else {
|
||||
Wind {
|
||||
origin_y: 0,
|
||||
speed: None,
|
||||
max_offset: 0,
|
||||
}
|
||||
};
|
||||
let top = self.move_back(world, &mut stalactite, wind)?;
|
||||
let bottom = self.move_back(world, &mut stalagmite, wind)?;
|
||||
if top {
|
||||
self.place_blocks(world, random, &stalactite, wind)?;
|
||||
}
|
||||
if bottom {
|
||||
self.place_blocks(world, random, &stalagmite, wind)?;
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
fn move_back<W: FeatureWorld>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
d: &mut LargeDripstone,
|
||||
wind: Wind,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let s = &self.speleothem;
|
||||
while d.radius > 1 {
|
||||
let mut root = d.root;
|
||||
let tries = 10.min(d.height_at(0.0));
|
||||
for _ in 0..tries {
|
||||
if s.blocks.same_block(read(world, root)?, s.lava) {
|
||||
return Ok(false);
|
||||
}
|
||||
if self.circle_embedded(world, wind.offset(root), d.radius)? {
|
||||
d.root = root;
|
||||
return Ok(true);
|
||||
}
|
||||
root[1] = root[1].wrapping_add(if d.up { -1 } else { 1 });
|
||||
}
|
||||
d.radius /= 2;
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
fn circle_embedded<W: FeatureWorld>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
center: [i32; 3],
|
||||
radius: i32,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let s = &self.speleothem;
|
||||
if s.empty_water_or_lava(read(world, center)?) {
|
||||
return Ok(false);
|
||||
}
|
||||
let increment = 6.0f32 / radius as f32;
|
||||
let mut angle = 0.0f32;
|
||||
while angle < (std::f64::consts::PI * 2.0) as f32 {
|
||||
let dx = (trig::cos(f64::from(angle)) * radius as f32) as i32;
|
||||
let dz = (trig::sin(f64::from(angle)) * radius as f32) as i32;
|
||||
if s.empty_water_or_lava(read(world, tb::offset(center, dx, 0, dz))?) {
|
||||
return Ok(false);
|
||||
}
|
||||
angle += increment;
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
fn place_blocks<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
d: &LargeDripstone,
|
||||
wind: Wind,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let s = &self.speleothem;
|
||||
for dx in -d.radius..=d.radius {
|
||||
for dz in -d.radius..=d.radius {
|
||||
let current = ((dx * dx + dz * dz) as f32).sqrt();
|
||||
if current > d.radius as f32 {
|
||||
continue;
|
||||
}
|
||||
let mut height = d.height_at(current);
|
||||
if height <= 0 {
|
||||
continue;
|
||||
}
|
||||
if f64::from(random.next_float()) < 0.2 {
|
||||
let factor = random.next_float() * (1.0f32 - 0.8f32) + 0.8f32;
|
||||
height = (height as f32 * factor) as i32;
|
||||
}
|
||||
let mut pos = tb::offset(d.root, dx, 0, dz);
|
||||
let mut out_of_stone = false;
|
||||
let max_y = if d.up {
|
||||
world
|
||||
.height(HeightmapType::WorldSurfaceWg, pos[0], pos[2])
|
||||
.map_err(query)?
|
||||
} else {
|
||||
i32::MAX
|
||||
};
|
||||
let mut i = 0;
|
||||
while i < height && pos[1] < max_y {
|
||||
let adjusted = wind.offset(pos);
|
||||
let state = read(world, adjusted)?;
|
||||
if s.empty_water_or_lava(state) {
|
||||
out_of_stone = true;
|
||||
write(world, adjusted, s.base, 2)?;
|
||||
} else if out_of_stone && s.blocks.has(state, tb::BASE_STONE_OVERWORLD) {
|
||||
break;
|
||||
}
|
||||
pos[1] = pos[1].wrapping_add(if d.up { 1 } else { -1 });
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,243 @@
|
||||
//! `minecraft:end_spike`: the obsidian pillars around the main End island.
|
||||
use super::{
|
||||
DecodeError, Object,
|
||||
block_feature::FeatureBlockBindings,
|
||||
feature::FeatureWorld,
|
||||
feature_graph::FeatureExecutionError,
|
||||
integer, optional,
|
||||
placement::{PlacementContext, PlacementQueryError},
|
||||
required,
|
||||
tree::{TreeResult, kind, write},
|
||||
tree_blocks::{self as tb, TreeBlocks},
|
||||
};
|
||||
use crate::registry::BlockStateId;
|
||||
use horizon_core::random::{LegacyRandom, RandomSource};
|
||||
use std::sync::Arc;
|
||||
|
||||
fn query<E>(error: PlacementQueryError) -> FeatureExecutionError<E> {
|
||||
FeatureExecutionError::Query(error)
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub struct EndSpike {
|
||||
pub center_x: i32,
|
||||
pub center_z: i32,
|
||||
pub radius: i32,
|
||||
pub height: i32,
|
||||
pub guarded: bool,
|
||||
}
|
||||
/// EndSpikeFeature.getSpikesForLevel (SpikeCacheLoader), from the world seed.
|
||||
pub fn spikes_for_seed(seed: i64) -> Vec<EndSpike> {
|
||||
let key = LegacyRandom::new(seed).next_long() & 65535;
|
||||
let mut random = LegacyRandom::new(key);
|
||||
let mut sizes: Vec<i32> = (0..10).collect();
|
||||
tb::shuffle(&mut sizes, &mut random).expect("positive shuffle bounds");
|
||||
(0..10)
|
||||
.map(|i| {
|
||||
let angle =
|
||||
2.0 * (-std::f64::consts::PI + (std::f64::consts::PI / 10.0) * f64::from(i));
|
||||
let size = sizes[i as usize];
|
||||
EndSpike {
|
||||
center_x: (42.0 * angle.cos()).floor() as i32,
|
||||
center_z: (42.0 * angle.sin()).floor() as i32,
|
||||
radius: 2 + size / 3,
|
||||
height: 76 + size * 3,
|
||||
guarded: size == 1 || size == 2,
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct EndSpikeFeature {
|
||||
spikes: Vec<EndSpike>,
|
||||
crystal_invulnerable: bool,
|
||||
beam_target: Option<[i32; 3]>,
|
||||
obsidian: BlockStateId,
|
||||
air: BlockStateId,
|
||||
iron_bars: BlockStateId,
|
||||
bedrock: BlockStateId,
|
||||
fire: BlockStateId,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
impl EndSpikeFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:end_spike" {
|
||||
return Err(DecodeError::Field("end spike type"));
|
||||
}
|
||||
let raw: Vec<Object> = serde_json::from_str(required(&object, "spikes")?.get())?;
|
||||
let int = |o: &Object, name: &str| -> Result<i32, DecodeError> {
|
||||
optional(o, name)
|
||||
.map(integer)
|
||||
.transpose()
|
||||
.map(|v| v.unwrap_or(0))
|
||||
};
|
||||
let spikes = raw
|
||||
.iter()
|
||||
.map(|o| {
|
||||
Ok(EndSpike {
|
||||
center_x: int(o, "centerX")?,
|
||||
center_z: int(o, "centerZ")?,
|
||||
radius: int(o, "radius")?,
|
||||
height: int(o, "height")?,
|
||||
guarded: optional(o, "guarded")
|
||||
.map(|v| serde_json::from_str::<bool>(v.get()))
|
||||
.transpose()?
|
||||
.unwrap_or(false),
|
||||
})
|
||||
})
|
||||
.collect::<Result<_, DecodeError>>()?;
|
||||
let beam_target = optional(&object, "crystal_beam_target")
|
||||
.map(|raw| -> Result<[i32; 3], DecodeError> {
|
||||
let v: Vec<Box<serde_json::value::RawValue>> = serde_json::from_str(raw.get())?;
|
||||
if v.len() != 3 {
|
||||
return Err(DecodeError::Field("beam target"));
|
||||
}
|
||||
Ok([integer(&v[0])?, integer(&v[1])?, integer(&v[2])?])
|
||||
})
|
||||
.transpose()?;
|
||||
let registry = bindings.registry();
|
||||
let default = |name: &str| {
|
||||
registry
|
||||
.default_state(name)
|
||||
.ok_or_else(|| DecodeError::Registry(format!("missing spike block {name}")))
|
||||
};
|
||||
Ok(Self {
|
||||
spikes,
|
||||
crystal_invulnerable: optional(&object, "crystal_invulnerable")
|
||||
.map(|v| serde_json::from_str::<bool>(v.get()))
|
||||
.transpose()?
|
||||
.unwrap_or(false),
|
||||
beam_target,
|
||||
obsidian: default("minecraft:obsidian")?,
|
||||
air: default("minecraft:air")?,
|
||||
iron_bars: default("minecraft:iron_bars")?,
|
||||
bedrock: default("minecraft:bedrock")?,
|
||||
fire: default("minecraft:fire")?,
|
||||
blocks: bindings.tree_blocks()?,
|
||||
})
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let spikes = if self.spikes.is_empty() {
|
||||
spikes_for_seed(world.world_seed().map_err(query)?)
|
||||
} else {
|
||||
self.spikes.clone()
|
||||
};
|
||||
for spike in spikes {
|
||||
if origin[0] >> 4 == spike.center_x >> 4 && origin[2] >> 4 == spike.center_z >> 4 {
|
||||
self.place_spike(world, random, spike)?;
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
fn bars<E>(
|
||||
&self,
|
||||
north: bool,
|
||||
south: bool,
|
||||
west: bool,
|
||||
east: bool,
|
||||
) -> TreeResult<BlockStateId, E> {
|
||||
let mut state = self.iron_bars;
|
||||
for (name, value) in [
|
||||
("north", north),
|
||||
("south", south),
|
||||
("west", west),
|
||||
("east", east),
|
||||
] {
|
||||
state = self
|
||||
.blocks
|
||||
.with(state, name, if value { "true" } else { "false" })
|
||||
.ok_or(FeatureExecutionError::InvalidState)?;
|
||||
}
|
||||
Ok(state)
|
||||
}
|
||||
fn place_spike<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
spike: EndSpike,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let r = spike.radius;
|
||||
let min_y = world.min_y().map_err(query)?;
|
||||
let (cx, cz) = (spike.center_x, spike.center_z);
|
||||
for z in cz - r..=cz + r {
|
||||
for y in min_y..=spike.height + 10 {
|
||||
for x in cx - r..=cx + r {
|
||||
let dx = f64::from(x) - f64::from(cx);
|
||||
let dz = f64::from(z) - f64::from(cz);
|
||||
let p = [x, y, z];
|
||||
if dx * dx + dz * dz <= f64::from(r * r + 1) && y < spike.height {
|
||||
write(world, p, self.obsidian, 3)?;
|
||||
} else if y > 65 {
|
||||
write(world, p, self.air, 3)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if spike.guarded {
|
||||
for dx in -2i32..=2 {
|
||||
for dz in -2i32..=2 {
|
||||
for dy in 0..=3 {
|
||||
let x_side = dx.abs() == 2;
|
||||
let z_side = dz.abs() == 2;
|
||||
let top = dy == 3;
|
||||
if x_side || z_side || top {
|
||||
let x_edge = dx == -2 || dx == 2 || top;
|
||||
let z_edge = dz == -2 || dz == 2 || top;
|
||||
let state = self.bars(
|
||||
x_edge && dz != -2,
|
||||
x_edge && dz != 2,
|
||||
z_edge && dx != -2,
|
||||
z_edge && dx != 2,
|
||||
)?;
|
||||
write(world, [cx + dx, spike.height + dy, cz + dz], state, 3)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let yaw = random.next_float() * 360.0;
|
||||
world
|
||||
.spawn_end_crystal(
|
||||
[
|
||||
f64::from(cx) + 0.5,
|
||||
f64::from(spike.height + 1),
|
||||
f64::from(cz) + 0.5,
|
||||
],
|
||||
yaw,
|
||||
self.beam_target,
|
||||
self.crystal_invulnerable,
|
||||
)
|
||||
.map_err(query)?;
|
||||
let crystal = [cx, spike.height + 1, cz];
|
||||
write(world, tb::offset(crystal, 0, -1, 0), self.bedrock, 3)?;
|
||||
// FireBlock.getState above sturdy bedrock is the plain fire default.
|
||||
write(world, crystal, self.fire, 3)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn spike_layout_is_a_permutation_of_sizes() {
|
||||
let spikes = spikes_for_seed(0);
|
||||
assert_eq!(spikes.len(), 10);
|
||||
let mut heights: Vec<i32> = spikes.iter().map(|s| s.height).collect();
|
||||
heights.sort_unstable();
|
||||
assert_eq!(heights, (0..10).map(|s| 76 + s * 3).collect::<Vec<_>>());
|
||||
assert_eq!(spikes.iter().filter(|s| s.guarded).count(), 2);
|
||||
assert_eq!((spikes[0].center_x, spikes[0].center_z), (42, 0));
|
||||
assert_eq!(spikes_for_seed(0), spikes_for_seed(0));
|
||||
}
|
||||
}
|
||||
@@ -234,6 +234,38 @@ impl FeatureCatalog {
|
||||
object.insert("cap_feature".into(), raw(expanded)?);
|
||||
}
|
||||
}
|
||||
"minecraft:vegetation_patch" | "minecraft:waterlogged_vegetation_patch" => {
|
||||
let expanded =
|
||||
self.expand_placed(required(&object, "vegetation_feature")?, depth + 1, work)?;
|
||||
object.insert("vegetation_feature".into(), raw(expanded)?);
|
||||
}
|
||||
"minecraft:coral_tree" | "minecraft:coral_claw" | "minecraft:root_system" => {
|
||||
let expanded =
|
||||
self.expand_placed(required(&object, "feature")?, depth + 1, work)?;
|
||||
object.insert("feature".into(), raw(expanded)?);
|
||||
}
|
||||
"minecraft:tree" => {
|
||||
// PaleMossDecorator places the registry's pale_moss_patch by key.
|
||||
let pale_moss = super::optional(&object, "decorators")
|
||||
.map(|raw| serde_json::from_str::<Vec<Object>>(raw.get()))
|
||||
.transpose()?
|
||||
.unwrap_or_default()
|
||||
.iter()
|
||||
.any(|d| {
|
||||
d.get("type").is_some_and(|t| {
|
||||
serde_json::from_str::<String>(t.get())
|
||||
.ok()
|
||||
.and_then(|t| identifier(&t).ok())
|
||||
.as_deref()
|
||||
== Some("minecraft:pale_moss")
|
||||
})
|
||||
});
|
||||
const PATCH: &str = "minecraft:pale_moss_patch";
|
||||
if pale_moss && self.features.contains_key(PATCH) {
|
||||
let expanded = self.named(PATCH, false, depth, work)?;
|
||||
object.insert(super::tree::GROUND_FEATURE_KEY.into(), raw(expanded)?);
|
||||
}
|
||||
}
|
||||
"minecraft:sequence" | "minecraft:overlay" | "minecraft:simple_random_selector" => {
|
||||
let expanded = self.expand_set(required(&object, "features")?, depth + 1, work)?;
|
||||
object.insert("features".into(), raw(expanded)?);
|
||||
|
||||
@@ -66,6 +66,25 @@ pub enum FeatureDefinition {
|
||||
FillLayer(FillLayerFeature),
|
||||
ReplaceBlock(ReplaceBlockFeature),
|
||||
ScatteredOre(ScatteredOreFeature),
|
||||
Ore(super::ore_feature::OreFeature),
|
||||
Tree(Box<super::tree::TreeFeature>),
|
||||
VegetationPatch(Box<super::vegetation::VegetationPatchFeature>),
|
||||
Coral(Box<super::vegetation::CoralFeature>),
|
||||
HugeMushroom(Box<super::vegetation::HugeMushroomFeature>),
|
||||
MultifaceGrowth(Box<super::vegetation::MultifaceGrowthFeature>),
|
||||
Lake(Box<super::cave::LakeFeature>),
|
||||
MonsterRoom(Box<super::cave::MonsterRoomFeature>),
|
||||
Geode(Box<super::cave::GeodeFeature>),
|
||||
Iceberg(Box<super::iceberg::IcebergFeature>),
|
||||
RootSystem(Box<super::root_system::RootSystemFeature>),
|
||||
SpeleothemCluster(Box<super::dripstone::SpeleothemClusterFeature>),
|
||||
LargeDripstone(Box<super::dripstone::LargeDripstoneFeature>),
|
||||
HugeFungus(Box<super::fungus::HugeFungusFeature>),
|
||||
SculkPatch(Box<super::sculk::SculkPatchFeature>),
|
||||
EndSpike(Box<super::end_spike::EndSpikeFeature>),
|
||||
ProjectedPatchySquare(Box<super::projected::ProjectedPatchySquareFeature>),
|
||||
SteppedColumnCluster(Box<super::projected::SteppedColumnClusterFeature>),
|
||||
FallenTree(Box<super::tree::FallenTreeFeature>),
|
||||
NoOp,
|
||||
WeightedChoice(OptionalWeightedList<PlacedFeatureDefinition>),
|
||||
Sequence(Vec<PlacedFeatureDefinition>),
|
||||
@@ -102,6 +121,8 @@ pub enum FeatureExecutionError<E> {
|
||||
Query(PlacementQueryError),
|
||||
WorkLimit,
|
||||
InvalidPendingIndex,
|
||||
/// A block-state transition required by a feature is absent from the registry.
|
||||
InvalidState,
|
||||
}
|
||||
impl<E: std::fmt::Display> std::fmt::Display for FeatureExecutionError<E> {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
@@ -129,6 +150,7 @@ impl<E: std::fmt::Display> std::fmt::Display for FeatureExecutionError<E> {
|
||||
Self::Query(e) => e.fmt(f),
|
||||
Self::WorkLimit => f.write_str("feature graph work limit exceeded"),
|
||||
Self::InvalidPendingIndex => f.write_str("invalid pending modifier index"),
|
||||
Self::InvalidState => f.write_str("feature block state outside registry"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -525,6 +547,15 @@ impl FeatureDefinition {
|
||||
remaining,
|
||||
)
|
||||
.map(Self::ReplaceBlock),
|
||||
"minecraft:ore" => super::ore_feature::OreFeature::decode(
|
||||
json,
|
||||
blocks.ok_or_else(|| {
|
||||
DecodeError::Registry("feature block bindings unavailable".into())
|
||||
})?,
|
||||
depth,
|
||||
remaining,
|
||||
)
|
||||
.map(Self::Ore),
|
||||
"minecraft:scattered_ore" => ScatteredOreFeature::decode(
|
||||
json,
|
||||
blocks.ok_or_else(|| {
|
||||
@@ -534,6 +565,134 @@ impl FeatureDefinition {
|
||||
remaining,
|
||||
)
|
||||
.map(Self::ScatteredOre),
|
||||
"minecraft:vegetation_patch" | "minecraft:waterlogged_vegetation_patch" => {
|
||||
let bindings = blocks.ok_or(DecodeError::Field("vegetation patch bindings"))?;
|
||||
let nested = |json: &str, depth: usize, remaining: &mut usize| {
|
||||
PlacedFeatureDefinition::decode(json, depth, remaining, empty_tags, blocks)
|
||||
};
|
||||
super::vegetation::VegetationPatchFeature::decode(
|
||||
json, bindings, depth, remaining, &nested,
|
||||
)
|
||||
.map(|f| Self::VegetationPatch(Box::new(f)))
|
||||
}
|
||||
"minecraft:root_system" => {
|
||||
let bindings = blocks.ok_or(DecodeError::Field("root system bindings"))?;
|
||||
let nested = |json: &str, depth: usize, remaining: &mut usize| {
|
||||
PlacedFeatureDefinition::decode(json, depth, remaining, empty_tags, blocks)
|
||||
};
|
||||
super::root_system::RootSystemFeature::decode(
|
||||
json, bindings, depth, remaining, &nested,
|
||||
)
|
||||
.map(|f| Self::RootSystem(Box::new(f)))
|
||||
}
|
||||
"minecraft:coral_tree" | "minecraft:coral_claw" => {
|
||||
let nested = |json: &str, depth: usize, remaining: &mut usize| {
|
||||
PlacedFeatureDefinition::decode(json, depth, remaining, empty_tags, blocks)
|
||||
};
|
||||
super::vegetation::CoralFeature::decode(json, depth, remaining, &nested)
|
||||
.map(|f| Self::Coral(Box::new(f)))
|
||||
}
|
||||
"minecraft:huge_red_mushroom" | "minecraft:huge_brown_mushroom" => {
|
||||
super::vegetation::HugeMushroomFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("huge mushroom bindings"))?,
|
||||
depth,
|
||||
remaining,
|
||||
)
|
||||
.map(|f| Self::HugeMushroom(Box::new(f)))
|
||||
}
|
||||
"minecraft:lake" => super::cave::LakeFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("lake bindings"))?,
|
||||
depth,
|
||||
remaining,
|
||||
)
|
||||
.map(|f| Self::Lake(Box::new(f))),
|
||||
"minecraft:monster_room" => super::cave::MonsterRoomFeature::new(
|
||||
blocks.ok_or(DecodeError::Field("monster room bindings"))?,
|
||||
)
|
||||
.map(|f| Self::MonsterRoom(Box::new(f))),
|
||||
"minecraft:geode" => super::cave::GeodeFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("geode bindings"))?,
|
||||
depth,
|
||||
remaining,
|
||||
)
|
||||
.map(|f| Self::Geode(Box::new(f))),
|
||||
"minecraft:speleothem_cluster" => super::dripstone::SpeleothemClusterFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("speleothem cluster bindings"))?,
|
||||
depth,
|
||||
remaining,
|
||||
)
|
||||
.map(|f| Self::SpeleothemCluster(Box::new(f))),
|
||||
"minecraft:large_dripstone" => super::dripstone::LargeDripstoneFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("large dripstone bindings"))?,
|
||||
depth,
|
||||
remaining,
|
||||
)
|
||||
.map(|f| Self::LargeDripstone(Box::new(f))),
|
||||
"minecraft:projected_random_patchy_square" => {
|
||||
super::projected::ProjectedPatchySquareFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("patchy square bindings"))?,
|
||||
depth,
|
||||
remaining,
|
||||
)
|
||||
.map(|f| Self::ProjectedPatchySquare(Box::new(f)))
|
||||
}
|
||||
"minecraft:stepped_column_cluster" => {
|
||||
super::projected::SteppedColumnClusterFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("column cluster bindings"))?,
|
||||
depth,
|
||||
remaining,
|
||||
)
|
||||
.map(|f| Self::SteppedColumnCluster(Box::new(f)))
|
||||
}
|
||||
"minecraft:end_spike" => super::end_spike::EndSpikeFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("end spike bindings"))?,
|
||||
)
|
||||
.map(|f| Self::EndSpike(Box::new(f))),
|
||||
"minecraft:sculk_patch" => super::sculk::SculkPatchFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("sculk patch bindings"))?,
|
||||
)
|
||||
.map(|f| Self::SculkPatch(Box::new(f))),
|
||||
"minecraft:huge_fungus" => super::fungus::HugeFungusFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("huge fungus bindings"))?,
|
||||
depth,
|
||||
remaining,
|
||||
)
|
||||
.map(|f| Self::HugeFungus(Box::new(f))),
|
||||
"minecraft:iceberg" => super::iceberg::IcebergFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("iceberg bindings"))?,
|
||||
)
|
||||
.map(|f| Self::Iceberg(Box::new(f))),
|
||||
"minecraft:multiface_growth" => super::vegetation::MultifaceGrowthFeature::decode(
|
||||
json,
|
||||
blocks.ok_or(DecodeError::Field("multiface bindings"))?,
|
||||
)
|
||||
.map(|f| Self::MultifaceGrowth(Box::new(f))),
|
||||
"minecraft:tree" | "minecraft:fallen_tree" => {
|
||||
let bindings = blocks.ok_or(DecodeError::Field("tree bindings"))?;
|
||||
let nested = |json: &str, depth: usize, remaining: &mut usize| {
|
||||
Self::decode(json, depth, remaining, empty_tags, blocks)
|
||||
};
|
||||
if kind == "minecraft:tree" {
|
||||
super::tree::TreeFeature::decode(json, bindings, depth, remaining, &nested)
|
||||
.map(|t| Self::Tree(Box::new(t)))
|
||||
} else {
|
||||
super::tree::FallenTreeFeature::decode(
|
||||
json, bindings, depth, remaining, &nested,
|
||||
)
|
||||
.map(|t| Self::FallenTree(Box::new(t)))
|
||||
}
|
||||
}
|
||||
"minecraft:weighted_random_selector" => Ok(Self::WeightedChoice(
|
||||
OptionalWeightedList::decode(required(&object, "features")?, |raw| {
|
||||
PlacedFeatureDefinition::decode(
|
||||
@@ -846,6 +1005,37 @@ impl FeatureDefinition {
|
||||
Self::ScatteredOre(feature) => feature
|
||||
.place(world, random, origin)
|
||||
.map_err(FeatureExecutionError::Basic),
|
||||
Self::Ore(feature) => feature.place(world, random, origin),
|
||||
Self::VegetationPatch(feature) => {
|
||||
feature.place(world, random, origin, &mut |f, w, r, p| {
|
||||
f.place_in(&mut placer, w, r, p, run)
|
||||
})
|
||||
}
|
||||
Self::Coral(feature) => feature.place(world, random, origin, &mut |f, w, r, p| {
|
||||
f.place_in(&mut placer, w, r, p, run)
|
||||
}),
|
||||
Self::HugeMushroom(feature) => feature.place(world, random, origin),
|
||||
Self::MultifaceGrowth(feature) => feature.place(world, random, origin),
|
||||
Self::Lake(feature) => feature.place(world, random, origin),
|
||||
Self::MonsterRoom(feature) => feature.place(world, random, origin),
|
||||
Self::Geode(feature) => feature.place(world, random, origin),
|
||||
Self::Iceberg(feature) => feature.place(world, random, origin),
|
||||
Self::SpeleothemCluster(feature) => feature.place(world, random, origin),
|
||||
Self::LargeDripstone(feature) => feature.place(world, random, origin),
|
||||
Self::HugeFungus(feature) => feature.place(world, random, origin),
|
||||
Self::SculkPatch(feature) => feature.place(world, random, origin),
|
||||
Self::EndSpike(feature) => feature.place(world, random, origin),
|
||||
Self::ProjectedPatchySquare(feature) => feature.place(world, random, origin),
|
||||
Self::SteppedColumnCluster(feature) => feature.place(world, random, origin),
|
||||
Self::RootSystem(feature) => feature.place(world, random, origin, &mut |f, w, r, p| {
|
||||
f.place_in(&mut placer, w, r, p, run)
|
||||
}),
|
||||
Self::Tree(feature) => feature.place(world, random, origin, &mut |f, w, r, p| {
|
||||
f.place_inner(w, r, p, run)
|
||||
}),
|
||||
Self::FallenTree(feature) => feature.place(world, random, origin, &mut |f, w, r, p| {
|
||||
f.place_inner(w, r, p, run)
|
||||
}),
|
||||
Self::FillLayer(feature) => feature.place(world, origin).map_err(|e| match e {
|
||||
BlockFeatureError::World(e) => FeatureExecutionError::Basic(FeatureError::World(e)),
|
||||
BlockFeatureError::Query(e) => FeatureExecutionError::Query(e),
|
||||
|
||||
@@ -66,6 +66,7 @@ pub struct TerrainRegion<'r, B: TerrainBlockStates> {
|
||||
game_time: i64,
|
||||
next_tick_order: i64,
|
||||
block_queries: Option<RegionBlockQueries>,
|
||||
world_seed: Option<i64>,
|
||||
}
|
||||
impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> {
|
||||
pub fn new(
|
||||
@@ -95,6 +96,7 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> {
|
||||
game_time: 0,
|
||||
next_tick_order: 0,
|
||||
block_queries: None,
|
||||
world_seed: None,
|
||||
min_y,
|
||||
height,
|
||||
generation: WorldGenerationContext::with_generator(
|
||||
@@ -124,6 +126,11 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> {
|
||||
});
|
||||
Ok(self)
|
||||
}
|
||||
/// Supply the world seed (WorldGenLevel.getSeed) for seed-derived features.
|
||||
pub fn with_world_seed(mut self, seed: i64) -> Self {
|
||||
self.world_seed = Some(seed);
|
||||
self
|
||||
}
|
||||
/// Supply the owning world's current time and region-local next tick order.
|
||||
pub fn with_tick_clock(mut self, game_time: i64, next_tick_order: i64) -> Self {
|
||||
self.game_time = game_time;
|
||||
@@ -324,6 +331,9 @@ impl<B: TerrainBlockStates> PlacementContext for TerrainRegion<'_, B> {
|
||||
fn sea_level(&mut self) -> Result<i32, PlacementQueryError> {
|
||||
Ok(self.sea_level)
|
||||
}
|
||||
fn world_seed(&mut self) -> Result<i64, PlacementQueryError> {
|
||||
self.world_seed.ok_or(PlacementQueryError::Unavailable)
|
||||
}
|
||||
|
||||
fn mark_postprocessing(&mut self, [x, y, z]: [i32; 3]) -> Result<(), PlacementQueryError> {
|
||||
self.chunk_mut(x >> 4, z >> 4)?.mark_postprocessing(x, y, z);
|
||||
@@ -429,6 +439,15 @@ where
|
||||
state: BlockStateId,
|
||||
flags: i32,
|
||||
) -> Result<bool, RegionError> {
|
||||
if !self.can_write(position)? {
|
||||
return Ok(false);
|
||||
}
|
||||
(self.write)(self.region, position, state, flags)
|
||||
}
|
||||
}
|
||||
impl<'r, B: TerrainBlockStates, F> TerrainFeatureAccess<'_, 'r, B, F> {
|
||||
/// WorldGenRegion.ensureCanWrite without its diagnostic logging.
|
||||
fn can_write(&mut self, position: [i32; 3]) -> Result<bool, RegionError> {
|
||||
if self.write_zone.is_some_and(|zone| {
|
||||
!zone.contains_block(BlockPos::new(position[0], position[1], position[2]))
|
||||
}) {
|
||||
@@ -445,10 +464,7 @@ where
|
||||
})
|
||||
}
|
||||
};
|
||||
if height.is_some_and(|height| !height.contains(position[1])) {
|
||||
return Ok(false);
|
||||
}
|
||||
(self.write)(self.region, position, state, flags)
|
||||
Ok(!height.is_some_and(|height| !height.contains(position[1])))
|
||||
}
|
||||
}
|
||||
impl<'r, B: TerrainBlockStates, F> PlacementContext for TerrainFeatureAccess<'_, 'r, B, F>
|
||||
@@ -480,6 +496,31 @@ where
|
||||
) -> Result<crate::fluid::FluidState, PlacementQueryError> {
|
||||
self.region.fluid_state(position)
|
||||
}
|
||||
fn ensure_can_write(&mut self, position: [i32; 3]) -> Result<bool, PlacementQueryError> {
|
||||
self.can_write(position).map_err(Into::into)
|
||||
}
|
||||
fn section_block(
|
||||
&mut self,
|
||||
position: [i32; 3],
|
||||
) -> Result<Option<BlockStateId>, PlacementQueryError> {
|
||||
if position[1] < self.region.min_y
|
||||
|| position[1] >= self.region.min_y.wrapping_add(self.region.height)
|
||||
{
|
||||
return Ok(None);
|
||||
}
|
||||
self.region.block(position).map(Some).map_err(Into::into)
|
||||
}
|
||||
fn set_section_block(
|
||||
&mut self,
|
||||
[x, y, z]: [i32; 3],
|
||||
state: BlockStateId,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
self.region
|
||||
.chunk_mut(x >> 4, z >> 4)?
|
||||
.set_block_raw(x, y, z, state)
|
||||
.map_err(RegionError::from)?;
|
||||
Ok(())
|
||||
}
|
||||
fn water_at(&mut self, position: [i32; 3]) -> Result<bool, PlacementQueryError> {
|
||||
self.region.water_at(position)
|
||||
}
|
||||
@@ -511,6 +552,9 @@ where
|
||||
fn sea_level(&mut self) -> Result<i32, PlacementQueryError> {
|
||||
self.region.sea_level()
|
||||
}
|
||||
fn world_seed(&mut self) -> Result<i64, PlacementQueryError> {
|
||||
self.region.world_seed()
|
||||
}
|
||||
|
||||
fn mark_postprocessing(&mut self, position: [i32; 3]) -> Result<(), PlacementQueryError> {
|
||||
self.region.mark_postprocessing(position)
|
||||
|
||||
@@ -0,0 +1,300 @@
|
||||
//! `minecraft:huge_fungus` (crimson and warped fungi, natural and planted).
|
||||
use super::{
|
||||
DecodeError, Object,
|
||||
block_feature::FeatureBlockBindings,
|
||||
block_predicate::BlockPredicate,
|
||||
feature::FeatureWorld,
|
||||
feature_graph::FeatureExecutionError,
|
||||
optional,
|
||||
placement::{PlacementContext, PlacementQueryError},
|
||||
required,
|
||||
tree::{TreeResult, kind, read, write},
|
||||
tree_blocks::{self as tb, TreeBlocks},
|
||||
};
|
||||
use crate::registry::BlockStateId;
|
||||
use horizon_core::random::RandomSource;
|
||||
use std::sync::Arc;
|
||||
|
||||
fn query<E>(error: PlacementQueryError) -> FeatureExecutionError<E> {
|
||||
FeatureExecutionError::Query(error)
|
||||
}
|
||||
/// Mth.nextInt(random, min, max).
|
||||
fn next_int<E>(random: &mut impl RandomSource, min: i32, max: i32) -> TreeResult<i32, E> {
|
||||
if min >= max {
|
||||
Ok(min)
|
||||
} else {
|
||||
Ok(random.next_int_bound(max - min + 1)? + min)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct HugeFungusFeature {
|
||||
valid_base: BlockStateId,
|
||||
stem: BlockStateId,
|
||||
hat: BlockStateId,
|
||||
decor: BlockStateId,
|
||||
replaceable: BlockPredicate,
|
||||
planted: bool,
|
||||
air: BlockStateId,
|
||||
weeping_vines: BlockStateId,
|
||||
weeping_vines_plant: BlockStateId,
|
||||
nether_wart_block: BlockStateId,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
impl HugeFungusFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:huge_fungus" {
|
||||
return Err(DecodeError::Field("huge fungus type"));
|
||||
}
|
||||
let state = |name: &'static str| {
|
||||
bindings
|
||||
.codec
|
||||
.decode(required(&object, name)?.get(), false)
|
||||
.map_err(|e| DecodeError::Registry(e.to_string()))
|
||||
};
|
||||
let registry = bindings.registry();
|
||||
let default = |name: &str| {
|
||||
registry
|
||||
.default_state(name)
|
||||
.ok_or_else(|| DecodeError::Registry(format!("missing fungus block {name}")))
|
||||
};
|
||||
Ok(Self {
|
||||
valid_base: state("valid_base_block")?,
|
||||
stem: state("stem_state")?,
|
||||
hat: state("hat_state")?,
|
||||
decor: state("decor_state")?,
|
||||
replaceable: BlockPredicate::decode_with_blocks(
|
||||
required(&object, "replaceable_blocks")?.get(),
|
||||
depth + 1,
|
||||
remaining,
|
||||
Some(bindings),
|
||||
)?,
|
||||
planted: optional(&object, "planted")
|
||||
.map(|raw| serde_json::from_str::<bool>(raw.get()))
|
||||
.transpose()?
|
||||
.unwrap_or(false),
|
||||
air: default("minecraft:air")?,
|
||||
weeping_vines: default("minecraft:weeping_vines")?,
|
||||
weeping_vines_plant: default("minecraft:weeping_vines_plant")?,
|
||||
nether_wart_block: default("minecraft:nether_wart_block")?,
|
||||
blocks: bindings.tree_blocks()?,
|
||||
})
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let below = read(world, tb::offset(origin, 0, -1, 0))?;
|
||||
if !self.blocks.same_block(below, self.valid_base) {
|
||||
return Ok(false);
|
||||
}
|
||||
let mut height = next_int(random, 4, 13)?;
|
||||
if random.next_int_bound(12)? == 0 {
|
||||
height *= 2;
|
||||
}
|
||||
if !self.planted {
|
||||
// ChunkGenerator.getGenDepth, compared against the absolute Y.
|
||||
let depth = world.generation().height;
|
||||
if origin[1].wrapping_add(height).wrapping_add(1) >= depth {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
let huge = !self.planted && random.next_float() < 0.06;
|
||||
write(world, origin, self.air, 260)?;
|
||||
self.stem(world, random, origin, height, huge)?;
|
||||
self.hat(world, random, origin, height, huge)?;
|
||||
Ok(true)
|
||||
}
|
||||
fn replaceable<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
p: [i32; 3],
|
||||
plants: bool,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if self.blocks.has(read(world, p)?, tb::REPLACEABLE) {
|
||||
return Ok(true);
|
||||
}
|
||||
if plants {
|
||||
return self.replaceable.test(world, p).map_err(query);
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
fn stem<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
height: i32,
|
||||
huge: bool,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let r = i32::from(huge);
|
||||
for dx in -r..=r {
|
||||
for dz in -r..=r {
|
||||
let corner = huge && dx.abs() == r && dz.abs() == r;
|
||||
for dy in 0..height {
|
||||
let p = tb::offset(origin, dx, dy, dz);
|
||||
if !self.replaceable(world, p, true)? {
|
||||
continue;
|
||||
}
|
||||
if self.planted {
|
||||
if !self.blocks.is_air(read(world, tb::offset(p, 0, -1, 0))?) {
|
||||
world.destroy_block_without_entity(p, true).map_err(query)?;
|
||||
}
|
||||
write(world, p, self.stem, 3)?;
|
||||
} else if corner {
|
||||
if random.next_float() < 0.1 {
|
||||
write(world, p, self.stem, 3)?;
|
||||
}
|
||||
} else {
|
||||
write(world, p, self.stem, 3)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn hat<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
height: i32,
|
||||
huge: bool,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let vines = self.blocks.same_block(self.hat, self.nether_wart_block);
|
||||
let hat_height = (random.next_int_bound(1 + height / 3)? + 5).min(height);
|
||||
let start = height - hat_height;
|
||||
for dy in start..=height {
|
||||
let mut radius = if dy < height - random.next_int_bound(3)? {
|
||||
2
|
||||
} else {
|
||||
1
|
||||
};
|
||||
if hat_height > 8 && dy < start + 4 {
|
||||
radius = 3;
|
||||
}
|
||||
if huge {
|
||||
radius += 1;
|
||||
}
|
||||
for dx in -radius..=radius {
|
||||
for dz in -radius..=radius {
|
||||
let edge_x = dx == -radius || dx == radius;
|
||||
let edge_z = dz == -radius || dz == radius;
|
||||
let inside = !edge_x && !edge_z && dy != height;
|
||||
let corner = edge_x && edge_z;
|
||||
let bottom = dy < start + 3;
|
||||
let p = tb::offset(origin, dx, dy, dz);
|
||||
if !self.replaceable(world, p, false)? {
|
||||
continue;
|
||||
}
|
||||
if self.planted && !self.blocks.is_air(read(world, tb::offset(p, 0, -1, 0))?) {
|
||||
world.destroy_block_without_entity(p, true).map_err(query)?;
|
||||
}
|
||||
if bottom {
|
||||
if !inside {
|
||||
self.hat_drop(world, random, p, vines)?;
|
||||
}
|
||||
} else if inside {
|
||||
self.hat_block(world, random, p, 0.1, 0.2, if vines { 0.1 } else { 0.0 })?;
|
||||
} else if corner {
|
||||
self.hat_block(
|
||||
world,
|
||||
random,
|
||||
p,
|
||||
0.01,
|
||||
0.7,
|
||||
if vines { 0.083 } else { 0.0 },
|
||||
)?;
|
||||
} else {
|
||||
self.hat_block(
|
||||
world,
|
||||
random,
|
||||
p,
|
||||
5.0e-4,
|
||||
0.98,
|
||||
if vines { 0.07 } else { 0.0 },
|
||||
)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn hat_block<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
p: [i32; 3],
|
||||
decor: f32,
|
||||
hat: f32,
|
||||
vines: f32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
if random.next_float() < decor {
|
||||
write(world, p, self.decor, 3)?;
|
||||
} else if random.next_float() < hat {
|
||||
write(world, p, self.hat, 3)?;
|
||||
if random.next_float() < vines {
|
||||
self.weeping_vines(world, random, p)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn hat_drop<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
p: [i32; 3],
|
||||
vines: bool,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let below = read(world, tb::offset(p, 0, -1, 0))?;
|
||||
if self.blocks.same_block(below, self.hat) {
|
||||
write(world, p, self.hat, 3)?;
|
||||
} else if f64::from(random.next_float()) < 0.15 {
|
||||
write(world, p, self.hat, 3)?;
|
||||
if vines && random.next_int_bound(11)? == 0 {
|
||||
self.weeping_vines(world, random, p)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn weeping_vines<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
hat: [i32; 3],
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let mut p = tb::offset(hat, 0, -1, 0);
|
||||
if !self.blocks.is_air(read(world, p)?) {
|
||||
return Ok(());
|
||||
}
|
||||
let mut goal = next_int(random, 1, 5)?;
|
||||
if random.next_int_bound(7)? == 0 {
|
||||
goal *= 2;
|
||||
}
|
||||
for height in 0..=goal {
|
||||
if self.blocks.is_air(read(world, p)?) {
|
||||
if height == goal || !self.blocks.is_air(read(world, tb::offset(p, 0, -1, 0))?) {
|
||||
let age = next_int(random, 23, 25)?;
|
||||
let state = self
|
||||
.blocks
|
||||
.with(self.weeping_vines, "age", &age.to_string())
|
||||
.ok_or(FeatureExecutionError::InvalidState)?;
|
||||
write(world, p, state, 2)?;
|
||||
break;
|
||||
}
|
||||
write(world, p, self.weeping_vines_plant, 2)?;
|
||||
}
|
||||
p = tb::offset(p, 0, -1, 0);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -43,7 +43,7 @@ use crate::{
|
||||
};
|
||||
use horizon_core::{
|
||||
biome::obfuscate_seed,
|
||||
geometry::{Direction, VoxelShape},
|
||||
geometry::{Axis, Direction, VoxelShape},
|
||||
position::{BlockPos, ChunkPos},
|
||||
};
|
||||
use serde_json::Value;
|
||||
@@ -261,7 +261,8 @@ impl Decoration {
|
||||
biomes.push(chunk.biomes().clone());
|
||||
}
|
||||
let terrain = TerrainRegion::new(chunks, generation)
|
||||
.and_then(|region| region.with_block_bindings(&self.bindings));
|
||||
.and_then(|region| region.with_block_bindings(&self.bindings))
|
||||
.map(|region| region.with_world_seed(seed));
|
||||
let terrain = match terrain {
|
||||
Ok(terrain) => terrain,
|
||||
Err(e) => return Err(resource(e.to_string())),
|
||||
@@ -478,6 +479,44 @@ impl PlacementContext for World<'_> {
|
||||
.is_face_sturdy(self, state, position, direction, SupportType::Full)
|
||||
.map_err(query)
|
||||
}
|
||||
fn collision_full_block(
|
||||
&mut self,
|
||||
state: BlockStateId,
|
||||
position: [i32; 3],
|
||||
) -> Result<bool, PlacementQueryError> {
|
||||
let collision = self.blocks()?.collision.clone();
|
||||
let shape = collision
|
||||
.collision_shape(self, state, position)
|
||||
.map_err(query)?;
|
||||
let [nx, ny, nz] = shape.sizes();
|
||||
Ok(!shape.is_empty()
|
||||
&& [Axis::X, Axis::Y, Axis::Z]
|
||||
.into_iter()
|
||||
.all(|axis| shape.min(axis) == 0.0 && shape.max(axis) == 1.0)
|
||||
&& (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 world_seed(&mut self) -> Result<i64, PlacementQueryError> {
|
||||
self.region.world_seed()
|
||||
}
|
||||
fn ensure_can_write(&mut self, position: [i32; 3]) -> Result<bool, PlacementQueryError> {
|
||||
Ok(self
|
||||
.zone
|
||||
.contains_block(BlockPos::new(position[0], position[1], position[2])))
|
||||
}
|
||||
/// BulkSectionAccess write: section storage only, no heightmap updates.
|
||||
fn set_section_block(
|
||||
&mut self,
|
||||
[x, y, z]: [i32; 3],
|
||||
state: BlockStateId,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
self.region
|
||||
.chunk_mut(x >> 4, z >> 4)?
|
||||
.set_block_raw(x, y, z, state)
|
||||
.map_err(|e| query(format!("{e:?}")))?;
|
||||
Ok(())
|
||||
}
|
||||
/// Generation regions contain no entities.
|
||||
fn unobstructed_block(&mut self, _: [i32; 3]) -> Result<bool, PlacementQueryError> {
|
||||
Ok(true)
|
||||
|
||||
@@ -0,0 +1,385 @@
|
||||
//! Vanilla `minecraft:iceberg`, with native float/double rounding and the
|
||||
//! short-circuited random draws of IcebergFeature.
|
||||
use super::{
|
||||
DecodeError, Object,
|
||||
block_feature::FeatureBlockBindings,
|
||||
feature::FeatureWorld,
|
||||
placement::PlacementContext,
|
||||
required,
|
||||
tree::{TreeResult, kind, read, write},
|
||||
tree_blocks::{self as tb, TreeBlocks},
|
||||
};
|
||||
use crate::registry::BlockStateId;
|
||||
use horizon_core::random::RandomSource;
|
||||
use std::sync::Arc;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct IcebergFeature {
|
||||
state: BlockStateId,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
air: BlockStateId,
|
||||
water: BlockStateId,
|
||||
snow_block: BlockStateId,
|
||||
ice: BlockStateId,
|
||||
packed_ice: BlockStateId,
|
||||
blue_ice: BlockStateId,
|
||||
snow: BlockStateId,
|
||||
}
|
||||
fn ceil(v: f32) -> i32 {
|
||||
f64::from(v).ceil() as i32
|
||||
}
|
||||
fn pow2(v: i32) -> f64 {
|
||||
f64::from(v).powf(2.0)
|
||||
}
|
||||
impl IcebergFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:iceberg" {
|
||||
return Err(DecodeError::Field("iceberg type"));
|
||||
}
|
||||
let state = bindings
|
||||
.codec
|
||||
.decode(required(&object, "state")?.get(), false)
|
||||
.map_err(|e| DecodeError::Registry(e.to_string()))?;
|
||||
let registry = bindings.registry();
|
||||
let get = |name: &str| {
|
||||
registry
|
||||
.default_state(name)
|
||||
.ok_or_else(|| DecodeError::Registry(format!("missing iceberg block {name}")))
|
||||
};
|
||||
Ok(Self {
|
||||
state,
|
||||
blocks: bindings.tree_blocks()?,
|
||||
air: get("minecraft:air")?,
|
||||
water: get("minecraft:water")?,
|
||||
snow_block: get("minecraft:snow_block")?,
|
||||
ice: get("minecraft:ice")?,
|
||||
packed_ice: get("minecraft:packed_ice")?,
|
||||
blue_ice: get("minecraft:blue_ice")?,
|
||||
snow: get("minecraft:snow")?,
|
||||
})
|
||||
}
|
||||
fn is(&self, a: BlockStateId, b: BlockStateId) -> bool {
|
||||
self.blocks.same_block(a, b)
|
||||
}
|
||||
fn iceberg_state(&self, s: BlockStateId) -> bool {
|
||||
self.is(s, self.packed_ice) || self.is(s, self.snow_block) || self.is(s, self.blue_ice)
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let origin = [origin[0], world.generation().sea_level, origin[2]];
|
||||
let snow_on_top = random.next_double() > 0.7;
|
||||
let angle = random.next_double() * 2.0 * std::f64::consts::PI;
|
||||
let ellipse_a = 11 - random.next_int_bound(5)?;
|
||||
let ellipse_c = 3 + random.next_int_bound(3)?;
|
||||
let is_ellipse = random.next_double() > 0.7;
|
||||
let mut over = if is_ellipse {
|
||||
random.next_int_bound(6)? + 6
|
||||
} else {
|
||||
random.next_int_bound(15)? + 3
|
||||
};
|
||||
if !is_ellipse && random.next_double() > 0.9 {
|
||||
over += random.next_int_bound(19)? + 7;
|
||||
}
|
||||
let under = (over + random.next_int_bound(11)?).min(18);
|
||||
let width = (over + random.next_int_bound(7)? - random.next_int_bound(5)?).min(11);
|
||||
let a = if is_ellipse { ellipse_a } else { 11 };
|
||||
for xo in -a..a {
|
||||
for zo in -a..a {
|
||||
for y in 0..over {
|
||||
let radius = if is_ellipse {
|
||||
let scale =
|
||||
(1.0f32 - pow2(y) as f32 / (over as f32 * 1.0f32)) * width as f32;
|
||||
ceil(scale / 2.0)
|
||||
} else {
|
||||
self.radius_round(random, y, over, width)?
|
||||
};
|
||||
if is_ellipse || xo < radius {
|
||||
self.generate_block(
|
||||
world,
|
||||
random,
|
||||
origin,
|
||||
over,
|
||||
xo,
|
||||
y,
|
||||
zo,
|
||||
radius,
|
||||
a,
|
||||
is_ellipse,
|
||||
ellipse_c,
|
||||
angle,
|
||||
snow_on_top,
|
||||
)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
self.smooth(world, origin, width, over, is_ellipse, ellipse_a)?;
|
||||
for xo in -a..a {
|
||||
for zo in -a..a {
|
||||
let mut y = -1;
|
||||
while y > -under {
|
||||
let new_a = if is_ellipse {
|
||||
ceil(a as f32 * (1.0f32 - pow2(y) as f32 / (under as f32 * 8.0f32)))
|
||||
} else {
|
||||
a
|
||||
};
|
||||
let radius = self.radius_steep(random, -y, under, width)?;
|
||||
if xo < radius {
|
||||
self.generate_block(
|
||||
world,
|
||||
random,
|
||||
origin,
|
||||
under,
|
||||
xo,
|
||||
y,
|
||||
zo,
|
||||
radius,
|
||||
new_a,
|
||||
is_ellipse,
|
||||
ellipse_c,
|
||||
angle,
|
||||
snow_on_top,
|
||||
)?;
|
||||
}
|
||||
y -= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
let cut_out = if is_ellipse {
|
||||
random.next_double() > 0.1
|
||||
} else {
|
||||
random.next_double() > 0.7
|
||||
};
|
||||
if cut_out {
|
||||
self.cut_out(
|
||||
world, random, width, over, origin, is_ellipse, ellipse_a, angle, ellipse_c,
|
||||
)?;
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn cut_out<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
width: i32,
|
||||
height: i32,
|
||||
origin: [i32; 3],
|
||||
is_ellipse: bool,
|
||||
ellipse_a: i32,
|
||||
angle: f64,
|
||||
ellipse_c: i32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let sign_x = if random.next_boolean() { -1 } else { 1 };
|
||||
let sign_z = if random.next_boolean() { -1 } else { 1 };
|
||||
let mut x_off = random.next_int_bound((width / 2 - 2).max(1))?;
|
||||
if random.next_boolean() {
|
||||
x_off = width / 2 + 1 - random.next_int_bound((width - width / 2 - 1).max(1))?;
|
||||
}
|
||||
let mut z_off = random.next_int_bound((width / 2 - 2).max(1))?;
|
||||
if random.next_boolean() {
|
||||
z_off = width / 2 + 1 - random.next_int_bound((width - width / 2 - 1).max(1))?;
|
||||
}
|
||||
if is_ellipse {
|
||||
x_off = random.next_int_bound((ellipse_a - 5).max(1))?;
|
||||
z_off = x_off;
|
||||
}
|
||||
let local = [sign_x * x_off, 0, sign_z * z_off];
|
||||
let angle = if is_ellipse {
|
||||
angle + std::f64::consts::FRAC_PI_2
|
||||
} else {
|
||||
random.next_double() * 2.0 * std::f64::consts::PI
|
||||
};
|
||||
for y in 0..height - 3 {
|
||||
let radius = self.radius_round(random, y, height, width)?;
|
||||
self.carve(
|
||||
world, radius, y, origin, false, angle, local, ellipse_a, ellipse_c,
|
||||
)?;
|
||||
}
|
||||
let mut y = -1;
|
||||
while y > -height + random.next_int_bound(5)? {
|
||||
let radius = self.radius_steep(random, -y, height, width)?;
|
||||
self.carve(
|
||||
world, radius, y, origin, true, angle, local, ellipse_a, ellipse_c,
|
||||
)?;
|
||||
y -= 1;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn carve<W: FeatureWorld>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
radius: i32,
|
||||
y: i32,
|
||||
origin: [i32; 3],
|
||||
under_water: bool,
|
||||
angle: f64,
|
||||
local: [i32; 3],
|
||||
ellipse_a: i32,
|
||||
ellipse_c: i32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let a = radius + 1 + ellipse_a / 3;
|
||||
let c = (radius - 3).min(3) + ellipse_c / 2 - 1;
|
||||
for xo in -a..a {
|
||||
for zo in -a..a {
|
||||
if signed_ellipse(xo, zo, local, a, c, angle) < 0.0 {
|
||||
let p = tb::offset(origin, xo, y, zo);
|
||||
let state = read(world, p)?;
|
||||
if self.iceberg_state(state) || self.is(state, self.snow_block) {
|
||||
if under_water {
|
||||
write(world, p, self.water, 3)?;
|
||||
} else {
|
||||
write(world, p, self.air, 3)?;
|
||||
let above = tb::offset(p, 0, 1, 0);
|
||||
if self.is(read(world, above)?, self.snow) {
|
||||
write(world, above, self.air, 3)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn generate_block<W: FeatureWorld, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
height: i32,
|
||||
xo: i32,
|
||||
y: i32,
|
||||
zo: i32,
|
||||
radius: i32,
|
||||
a: i32,
|
||||
is_ellipse: bool,
|
||||
ellipse_c: i32,
|
||||
angle: f64,
|
||||
snow_on_top: bool,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let signed = if is_ellipse {
|
||||
let mut c = ellipse_c;
|
||||
if y > 0 && height - y <= 3 {
|
||||
c -= 4 - (height - y);
|
||||
}
|
||||
signed_ellipse(xo, zo, [0; 3], a, c, angle)
|
||||
} else {
|
||||
let off = 10.0f32 * random.next_float().clamp(0.2, 0.8) / radius as f32;
|
||||
f64::from(off) + pow2(xo) + pow2(zo) - pow2(radius)
|
||||
};
|
||||
if signed >= 0.0 {
|
||||
return Ok(());
|
||||
}
|
||||
let p = tb::offset(origin, xo, y, zo);
|
||||
let compare = if is_ellipse {
|
||||
-0.5
|
||||
} else {
|
||||
f64::from(-6 - random.next_int_bound(3)?)
|
||||
};
|
||||
if signed > compare && random.next_double() > 0.9 {
|
||||
return Ok(());
|
||||
}
|
||||
let h_diff = height - y;
|
||||
let state = read(world, p)?;
|
||||
if self.blocks.is_air(state)
|
||||
|| self.is(state, self.snow_block)
|
||||
|| self.is(state, self.ice)
|
||||
|| self.is(state, self.water)
|
||||
{
|
||||
let randomness = !is_ellipse || random.next_double() > 0.05;
|
||||
let divisor = if is_ellipse { 3 } else { 2 };
|
||||
let snow = snow_on_top
|
||||
&& !self.is(state, self.water)
|
||||
&& f64::from(h_diff)
|
||||
<= f64::from(random.next_int_bound((height / divisor).max(1))?)
|
||||
+ f64::from(height) * 0.6
|
||||
&& randomness;
|
||||
write(world, p, if snow { self.snow_block } else { self.state }, 3)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn radius_round<R: RandomSource, E>(
|
||||
&self,
|
||||
random: &mut R,
|
||||
y: i32,
|
||||
height: i32,
|
||||
width: i32,
|
||||
) -> TreeResult<i32, E> {
|
||||
let k = 3.5f32 - random.next_float();
|
||||
let mut scale = (1.0f32 - pow2(y) as f32 / (height as f32 * k)) * width as f32;
|
||||
if height > 15 + random.next_int_bound(5)? {
|
||||
let temp = if y < 3 + random.next_int_bound(6)? {
|
||||
y / 2
|
||||
} else {
|
||||
y
|
||||
};
|
||||
scale = (1.0f32 - temp as f32 / (height as f32 * k * 0.4f32)) * width as f32;
|
||||
}
|
||||
Ok(ceil(scale / 2.0))
|
||||
}
|
||||
fn radius_steep<R: RandomSource, E>(
|
||||
&self,
|
||||
random: &mut R,
|
||||
y: i32,
|
||||
height: i32,
|
||||
width: i32,
|
||||
) -> TreeResult<i32, E> {
|
||||
let k = 1.0f32 + random.next_float() / 2.0;
|
||||
let scale = (1.0f32 - y as f32 / (height as f32 * k)) * width as f32;
|
||||
Ok(ceil(scale / 2.0))
|
||||
}
|
||||
fn smooth<W: FeatureWorld>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
origin: [i32; 3],
|
||||
width: i32,
|
||||
height: i32,
|
||||
is_ellipse: bool,
|
||||
ellipse_a: i32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let a = if is_ellipse { ellipse_a } else { width / 2 };
|
||||
for x in -a..=a {
|
||||
for z in -a..=a {
|
||||
for y in 0..=height {
|
||||
let p = tb::offset(origin, x, y, z);
|
||||
let state = read(world, p)?;
|
||||
if !(self.iceberg_state(state) || self.is(state, self.snow)) {
|
||||
continue;
|
||||
}
|
||||
if self.blocks.is_air(read(world, tb::offset(p, 0, -1, 0))?) {
|
||||
write(world, p, self.air, 3)?;
|
||||
write(world, tb::offset(p, 0, 1, 0), self.air, 3)?;
|
||||
} else if self.iceberg_state(state) {
|
||||
let mut counter = 0;
|
||||
for (dx, dz) in [(-1, 0), (1, 0), (0, -1), (0, 1)] {
|
||||
if !self.iceberg_state(read(world, tb::offset(p, dx, 0, dz))?) {
|
||||
counter += 1;
|
||||
}
|
||||
}
|
||||
if counter >= 3 {
|
||||
write(world, p, self.air, 3)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
fn signed_ellipse(xo: i32, zo: i32, origin: [i32; 3], a: i32, c: i32, angle: f64) -> f64 {
|
||||
let dx = f64::from(xo - origin[0]);
|
||||
let dz = f64::from(zo - origin[2]);
|
||||
((dx * angle.cos() - dz * angle.sin()) / f64::from(a)).powf(2.0)
|
||||
+ ((dx * angle.sin() + dz * angle.cos()) / f64::from(c)).powf(2.0)
|
||||
- 1.0
|
||||
}
|
||||
@@ -4,8 +4,12 @@ use super::{
|
||||
block_feature::{BlockReplacements, FeatureBlockBindings, decode_targets},
|
||||
density::identifier,
|
||||
feature::{FeatureError, FeatureWorld},
|
||||
int_range, number_text, required,
|
||||
feature_graph::FeatureExecutionError,
|
||||
int_range, number_text,
|
||||
placement::PlacementContext,
|
||||
required,
|
||||
};
|
||||
use crate::heightmap::HeightmapType;
|
||||
use crate::registry::BlockStateId;
|
||||
use horizon_core::{geometry::Direction, random::RandomSource};
|
||||
|
||||
@@ -99,3 +103,244 @@ impl ScatteredOreFeature {
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
/// Vanilla `minecraft:ore`: an interpolated chain of spheres written straight
|
||||
/// into chunk sections (BulkSectionAccess), bypassing block update effects.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct OreFeature {
|
||||
targets: BlockReplacements,
|
||||
size: i32,
|
||||
discard: f32,
|
||||
air: [BlockStateId; 3],
|
||||
}
|
||||
impl OreFeature {
|
||||
pub fn from_json(json: &str, bindings: &FeatureBlockBindings<'_>) -> Result<Self, DecodeError> {
|
||||
Self::decode(json, bindings, 0, &mut 65536)
|
||||
}
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
let kind = identifier(&serde_json::from_str::<String>(
|
||||
required(&object, "type")?.get(),
|
||||
)?)?;
|
||||
if kind != "minecraft:ore" {
|
||||
return Err(DecodeError::Field("ore type"));
|
||||
}
|
||||
let targets = decode_targets(&object, bindings, depth, remaining)?;
|
||||
let size = int_range(required(&object, "size")?, "ore size", 0, 64)?;
|
||||
let discard: f32 = number_text(required(&object, "discard_chance_on_air_exposure")?)?
|
||||
.parse()
|
||||
.map_err(|_| DecodeError::Field("ore air exposure"))?;
|
||||
if !(0.0..=1.0).contains(&discard) || discard.is_sign_negative() {
|
||||
return Err(DecodeError::Field("ore air exposure"));
|
||||
}
|
||||
Ok(Self {
|
||||
targets,
|
||||
size,
|
||||
discard,
|
||||
air: bindings.air,
|
||||
})
|
||||
}
|
||||
pub fn place<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut impl RandomSource,
|
||||
origin: [i32; 3],
|
||||
) -> Result<bool, FeatureExecutionError<W::Error>> {
|
||||
let dir = random.next_float() * std::f32::consts::PI;
|
||||
let spread_xy = self.size as f32 / 8.0;
|
||||
let max_radius = ((self.size as f32 / 16.0 * 2.0 + 1.0) / 2.0).ceil() as i32;
|
||||
let (ox, oz) = (f64::from(origin[0]), f64::from(origin[2]));
|
||||
let (sin, cos) = (f64::from(dir).sin(), f64::from(dir).cos());
|
||||
let spread = f64::from(spread_xy);
|
||||
let x0 = ox + sin * spread;
|
||||
let x1 = ox - sin * spread;
|
||||
let z0 = oz + cos * spread;
|
||||
let z1 = oz - cos * spread;
|
||||
let y0 = f64::from(
|
||||
origin[1]
|
||||
.wrapping_add(random.next_int_bound(3)?)
|
||||
.wrapping_sub(2),
|
||||
);
|
||||
let y1 = f64::from(
|
||||
origin[1]
|
||||
.wrapping_add(random.next_int_bound(3)?)
|
||||
.wrapping_sub(2),
|
||||
);
|
||||
let spread_ceil = spread.ceil() as i32;
|
||||
let x_start = origin[0].wrapping_sub(spread_ceil).wrapping_sub(max_radius);
|
||||
let y_start = origin[1].wrapping_sub(2).wrapping_sub(max_radius);
|
||||
let z_start = origin[2].wrapping_sub(spread_ceil).wrapping_sub(max_radius);
|
||||
let size_xz = 2 * (spread_ceil + max_radius);
|
||||
let size_y = 2 * (2 + max_radius);
|
||||
for x in 0..=size_xz {
|
||||
for z in 0..=size_xz {
|
||||
let (px, pz) = (x_start.wrapping_add(x), z_start.wrapping_add(z));
|
||||
let floor = world
|
||||
.height(HeightmapType::OceanFloorWg, px, pz)
|
||||
.map_err(FeatureExecutionError::Query)?;
|
||||
if y_start <= floor {
|
||||
return self.do_place(
|
||||
world,
|
||||
random,
|
||||
[x0, x1, z0, z1, y0, y1],
|
||||
[x_start, y_start, z_start],
|
||||
size_xz,
|
||||
size_y,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
fn do_place<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut impl RandomSource,
|
||||
[x0, x1, z0, z1, y0, y1]: [f64; 6],
|
||||
[x_start, y_start, z_start]: [i32; 3],
|
||||
size_xz: i32,
|
||||
size_y: i32,
|
||||
) -> Result<bool, FeatureExecutionError<W::Error>> {
|
||||
let size = self.size as usize;
|
||||
let mut data = vec![[0f64; 4]; size];
|
||||
for (i, entry) in data.iter_mut().enumerate() {
|
||||
let step = i as f32 / self.size as f32;
|
||||
let step64 = f64::from(step);
|
||||
let xx = x0 + step64 * (x1 - x0);
|
||||
let yy = y0 + step64 * (y1 - y0);
|
||||
let zz = z0 + step64 * (z1 - z0);
|
||||
let ss = random.next_double() * f64::from(self.size) / 16.0;
|
||||
let sine = horizon_core::geometry::trig::sin(f64::from(std::f32::consts::PI * step));
|
||||
let r = (f64::from(sine + 1.0) * ss + 1.0) / 2.0;
|
||||
*entry = [xx, yy, zz, r];
|
||||
}
|
||||
for i1 in 0..size.saturating_sub(1) {
|
||||
if data[i1][3] <= 0.0 {
|
||||
continue;
|
||||
}
|
||||
for i2 in i1 + 1..size {
|
||||
if data[i2][3] <= 0.0 {
|
||||
continue;
|
||||
}
|
||||
let dx = data[i1][0] - data[i2][0];
|
||||
let dy = data[i1][1] - data[i2][1];
|
||||
let dz = data[i1][2] - data[i2][2];
|
||||
let dr = data[i1][3] - data[i2][3];
|
||||
if dr * dr > dx * dx + dy * dy + dz * dz {
|
||||
if dr > 0.0 {
|
||||
data[i2][3] = -1.0;
|
||||
} else {
|
||||
data[i1][3] = -1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut tested = vec![false; (size_xz as usize) * (size_y as usize) * (size_xz as usize)];
|
||||
let mut placed = 0;
|
||||
for [xx, yy, zz, r] in data {
|
||||
if r < 0.0 {
|
||||
continue;
|
||||
}
|
||||
let x_min = ((xx - r).floor() as i32).max(x_start);
|
||||
let y_min = ((yy - r).floor() as i32).max(y_start);
|
||||
let z_min = ((zz - r).floor() as i32).max(z_start);
|
||||
let x_max = ((xx + r).floor() as i32).max(x_min);
|
||||
let y_max = ((yy + r).floor() as i32).max(y_min);
|
||||
let z_max = ((zz + r).floor() as i32).max(z_min);
|
||||
for x in x_min..=x_max {
|
||||
let xd = (f64::from(x) + 0.5 - xx) / r;
|
||||
if xd * xd >= 1.0 {
|
||||
continue;
|
||||
}
|
||||
for y in y_min..=y_max {
|
||||
let yd = (f64::from(y) + 0.5 - yy) / r;
|
||||
if xd * xd + yd * yd >= 1.0 {
|
||||
continue;
|
||||
}
|
||||
for z in z_min..=z_max {
|
||||
let zd = (f64::from(z) + 0.5 - zz) / r;
|
||||
if xd * xd + yd * yd + zd * zd >= 1.0
|
||||
|| world
|
||||
.outside_build_height(y)
|
||||
.map_err(FeatureExecutionError::Query)?
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let index = i64::from(x.wrapping_sub(x_start))
|
||||
+ i64::from(y.wrapping_sub(y_start)) * i64::from(size_xz)
|
||||
+ i64::from(z.wrapping_sub(z_start))
|
||||
* i64::from(size_xz)
|
||||
* i64::from(size_y);
|
||||
// The sphere bounds keep indices inside the native BitSet.
|
||||
let Some(bit) = usize::try_from(index)
|
||||
.ok()
|
||||
.and_then(|index| tested.get_mut(index))
|
||||
else {
|
||||
return Err(FeatureExecutionError::WorkLimit);
|
||||
};
|
||||
if *bit {
|
||||
continue;
|
||||
}
|
||||
*bit = true;
|
||||
let p = [x, y, z];
|
||||
if !world
|
||||
.ensure_can_write(p)
|
||||
.map_err(FeatureExecutionError::Query)?
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let Some(state) = world
|
||||
.section_block(p)
|
||||
.map_err(FeatureExecutionError::Query)?
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
for (rule, target) in &self.targets {
|
||||
if !rule.test(state, p, random) {
|
||||
continue;
|
||||
}
|
||||
if !skip_air_check(random, self.discard) {
|
||||
let mut exposed = false;
|
||||
for direction in Direction::ALL {
|
||||
let n = direction.normal();
|
||||
let q = std::array::from_fn(|i| p[i].wrapping_add(n[i]));
|
||||
let neighbor = world
|
||||
.section_block(q)
|
||||
.map_err(FeatureExecutionError::Query)?
|
||||
.unwrap_or(self.air[0]);
|
||||
if self.air.contains(&neighbor) {
|
||||
exposed = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if exposed {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
world
|
||||
.set_section_block(p, *target)
|
||||
.map_err(FeatureExecutionError::Query)?;
|
||||
placed += 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(placed > 0)
|
||||
}
|
||||
}
|
||||
fn skip_air_check(random: &mut impl RandomSource, discard: f32) -> bool {
|
||||
if discard <= 0.0 {
|
||||
true
|
||||
} else if discard >= 1.0 {
|
||||
false
|
||||
} else {
|
||||
random.next_float() >= discard
|
||||
}
|
||||
}
|
||||
|
||||
@@ -26,6 +26,81 @@ pub enum LayerBlock {
|
||||
Ground,
|
||||
}
|
||||
pub trait PlacementContext {
|
||||
/// StructureTemplate.updateShapeAtEdge for one outer face of a placed
|
||||
/// voxel shape: update the state at `position` against its neighbor in
|
||||
/// `direction`, then the neighbor against the (possibly new) state, writing
|
||||
/// changes with `flags & !1`. Worlds without block shape-update behavior
|
||||
/// accept this as a no-op.
|
||||
fn update_shape_at_face(
|
||||
&mut self,
|
||||
_position: [i32; 3],
|
||||
_direction: horizon_core::geometry::Direction,
|
||||
_flags: i32,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
Ok(())
|
||||
}
|
||||
/// WorldGenRegion.ensureCanWrite: horizontal write radius and upgrade height.
|
||||
fn ensure_can_write(&mut self, _position: [i32; 3]) -> Result<bool, PlacementQueryError> {
|
||||
Ok(true)
|
||||
}
|
||||
/// BulkSectionAccess read: None outside the world's section range.
|
||||
fn section_block(
|
||||
&mut self,
|
||||
position: [i32; 3],
|
||||
) -> Result<Option<crate::registry::BlockStateId>, PlacementQueryError> {
|
||||
if self.outside_build_height(position[1])? {
|
||||
return Ok(None);
|
||||
}
|
||||
self.block_state(position).map(Some)
|
||||
}
|
||||
/// Raw LevelChunkSection write: no heightmap, light, POI or neighbor effects.
|
||||
fn set_section_block(
|
||||
&mut self,
|
||||
_position: [i32; 3],
|
||||
_state: crate::registry::BlockStateId,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
Err(PlacementQueryError::Unavailable)
|
||||
}
|
||||
/// BlockState.isCollisionShapeFullBlock for an already-read state.
|
||||
fn collision_full_block(
|
||||
&mut self,
|
||||
_state: crate::registry::BlockStateId,
|
||||
_position: [i32; 3],
|
||||
) -> Result<bool, PlacementQueryError> {
|
||||
Err(PlacementQueryError::Unavailable)
|
||||
}
|
||||
/// Add an End crystal entity (structure spawn) at an entity position.
|
||||
fn spawn_end_crystal(
|
||||
&mut self,
|
||||
_position: [f64; 3],
|
||||
_yaw: f32,
|
||||
_beam_target: Option<[i32; 3]>,
|
||||
_invulnerable: bool,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
Ok(())
|
||||
}
|
||||
/// WorldGenLevel.getSeed: the world seed for seed-derived feature noise.
|
||||
fn world_seed(&mut self) -> Result<i64, PlacementQueryError> {
|
||||
Err(PlacementQueryError::Unavailable)
|
||||
}
|
||||
/// Set the entity type of the spawner block entity at `position`, when one
|
||||
/// exists. The caller has already drawn the native entity choice.
|
||||
fn configure_spawner(
|
||||
&mut self,
|
||||
_position: [i32; 3],
|
||||
_entity: &str,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
Ok(())
|
||||
}
|
||||
/// Store worldgen beehive occupants (ticks in hive per bee) in the nest
|
||||
/// block entity at `position`. Worlds without block-entity storage drop them.
|
||||
fn store_beehive_occupants(
|
||||
&mut self,
|
||||
_position: [i32; 3],
|
||||
_ticks_in_hive: &[i32],
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
Ok(())
|
||||
}
|
||||
/// Test the already-read state's collision shape in an empty entity context.
|
||||
fn state_collision_empty(
|
||||
&mut self,
|
||||
|
||||
@@ -0,0 +1,277 @@
|
||||
//! 26.3 projection-style features: `minecraft:projected_random_patchy_square`
|
||||
//! and `minecraft:stepped_column_cluster` (basalt columns).
|
||||
use super::{
|
||||
DecodeError, Object,
|
||||
block_feature::FeatureBlockBindings,
|
||||
block_predicate::BlockPredicate,
|
||||
feature::FeatureWorld,
|
||||
feature_graph::FeatureExecutionError,
|
||||
int_range,
|
||||
placement::{PlacementContext, PlacementQueryError},
|
||||
required,
|
||||
state_provider::BlockStateProvider,
|
||||
tree::{TreeDecoder, TreeResult, kind, read, sample_optional, sample_state, write},
|
||||
tree_blocks::{self as tb, TreeBlocks},
|
||||
value_provider::IntProvider,
|
||||
};
|
||||
use crate::registry::BlockStateId;
|
||||
use horizon_core::random::RandomSource;
|
||||
use std::{collections::BTreeSet, sync::Arc};
|
||||
|
||||
fn query<E>(error: PlacementQueryError) -> FeatureExecutionError<E> {
|
||||
FeatureExecutionError::Query(error)
|
||||
}
|
||||
fn predicate(
|
||||
object: &Object,
|
||||
name: &'static str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
) -> Result<BlockPredicate, DecodeError> {
|
||||
BlockPredicate::decode_with_blocks(
|
||||
required(object, name)?.get(),
|
||||
depth + 1,
|
||||
remaining,
|
||||
Some(bindings),
|
||||
)
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ProjectedPatchySquareFeature {
|
||||
block: BlockStateProvider,
|
||||
project_through: BlockPredicate,
|
||||
size: IntProvider,
|
||||
max_projection_height: i32,
|
||||
}
|
||||
impl ProjectedPatchySquareFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:projected_random_patchy_square" {
|
||||
return Err(DecodeError::Field("projected patchy square type"));
|
||||
}
|
||||
let mut decoder = TreeDecoder {
|
||||
bindings,
|
||||
depth,
|
||||
remaining,
|
||||
};
|
||||
let block = decoder.provider(required(&object, "block")?)?;
|
||||
let size = decoder.int_provider(required(&object, "size")?, 1, 16)?;
|
||||
Ok(Self {
|
||||
block,
|
||||
size,
|
||||
project_through: predicate(&object, "project_through", bindings, depth, remaining)?,
|
||||
max_projection_height: int_range(
|
||||
required(&object, "max_projection_height")?,
|
||||
"max_projection_height",
|
||||
0,
|
||||
i32::MAX,
|
||||
)?,
|
||||
})
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let size = self.size.sample(random)?;
|
||||
let bound = size.wrapping_mul(size).wrapping_add(1);
|
||||
for dx in -size..=size {
|
||||
for dz in -size..=size {
|
||||
let probability = dx.abs().wrapping_mul(dz.abs());
|
||||
if random.next_int_bound(bound)? < bound.wrapping_sub(probability) {
|
||||
let mut base = tb::offset(origin, dx, 0, dz);
|
||||
let mut drop = self.max_projection_height;
|
||||
while self
|
||||
.project_through
|
||||
.test(world, tb::offset(base, 0, -1, 0))
|
||||
.map_err(query)?
|
||||
{
|
||||
base = tb::offset(base, 0, -1, 0);
|
||||
drop -= 1;
|
||||
if drop <= 0 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if let Some(state) = sample_optional(&self.block, world, random, base)? {
|
||||
write(world, base, state, 2)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SteppedColumnClusterFeature {
|
||||
block: BlockStateProvider,
|
||||
continue_through: BlockPredicate,
|
||||
can_replace: BlockPredicate,
|
||||
cannot_place_on: Arc<BTreeSet<BlockStateId>>,
|
||||
cluster_reach: IntProvider,
|
||||
column_count: IntProvider,
|
||||
column_reach: IntProvider,
|
||||
height: IntProvider,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
impl SteppedColumnClusterFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:stepped_column_cluster" {
|
||||
return Err(DecodeError::Field("stepped column cluster type"));
|
||||
}
|
||||
let blocks = bindings.tree_blocks()?;
|
||||
let mut decoder = TreeDecoder {
|
||||
bindings,
|
||||
depth,
|
||||
remaining,
|
||||
};
|
||||
let block = decoder.provider(required(&object, "block")?)?;
|
||||
let cannot_place_on = decoder.block_set(required(&object, "cannot_place_on")?)?;
|
||||
let cluster_reach = decoder.int_provider(required(&object, "cluster_reach")?, 0, 13)?;
|
||||
let column_count = decoder.int_provider(required(&object, "column_count")?, 1, 150)?;
|
||||
let column_reach = decoder.int_provider(required(&object, "column_reach")?, 0, 3)?;
|
||||
let height = decoder.int_provider(required(&object, "height")?, 1, 10)?;
|
||||
Ok(Self {
|
||||
block,
|
||||
continue_through: predicate(&object, "continue_through", bindings, depth, remaining)?,
|
||||
can_replace: predicate(&object, "can_replace", bindings, depth, remaining)?,
|
||||
cannot_place_on,
|
||||
cluster_reach,
|
||||
column_count,
|
||||
column_reach,
|
||||
height,
|
||||
blocks,
|
||||
})
|
||||
}
|
||||
fn can_place_at<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
p: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if !self.can_replace.test(world, p).map_err(query)? {
|
||||
return Ok(false);
|
||||
}
|
||||
let below = read(world, tb::offset(p, 0, -1, 0))?;
|
||||
Ok(!self.blocks.is_air(below) && !self.cannot_place_on.contains(&below))
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if !self.can_place_at(world, origin)? {
|
||||
return Ok(false);
|
||||
}
|
||||
let column_height = self.height.sample(random)?;
|
||||
let reach = column_height.min(self.cluster_reach.sample(random)?);
|
||||
let count = self.column_count.sample(random)?;
|
||||
let width = reach.wrapping_mul(2).wrapping_add(1);
|
||||
let mut placed = false;
|
||||
for _ in 0..count {
|
||||
let x = origin[0]
|
||||
.wrapping_sub(reach)
|
||||
.wrapping_add(random.next_int_bound(width)?);
|
||||
let y = origin[1].wrapping_add(random.next_int_bound(1)?);
|
||||
let z = origin[2]
|
||||
.wrapping_sub(reach)
|
||||
.wrapping_add(random.next_int_bound(width)?);
|
||||
let pos = [x, y, z];
|
||||
let blocks_y = column_height - tb::dist_manhattan(pos, origin);
|
||||
if blocks_y >= 0 {
|
||||
let column_reach = self.column_reach.sample(random)?;
|
||||
placed |= self.place_column(world, random, pos, blocks_y, column_reach)?;
|
||||
}
|
||||
}
|
||||
Ok(placed)
|
||||
}
|
||||
fn place_column<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
column_height: i32,
|
||||
reach: i32,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let mut placed = false;
|
||||
// BlockPos.betweenClosed over a single layer: x fastest, then z.
|
||||
for dz in -reach..=reach {
|
||||
for dx in -reach..=reach {
|
||||
let pos = tb::offset(origin, dx, 0, dz);
|
||||
let step_limit = tb::dist_manhattan(pos, origin);
|
||||
let column = if self.can_replace.test(world, pos).map_err(query)? {
|
||||
self.find_surface(world, pos, step_limit)?
|
||||
} else {
|
||||
self.find_air(world, pos, step_limit)?
|
||||
};
|
||||
let Some(mut cursor) = column else {
|
||||
continue;
|
||||
};
|
||||
let mut blocks_y = column_height - step_limit / 2;
|
||||
while blocks_y >= 0 {
|
||||
if self.can_replace.test(world, cursor).map_err(query)? {
|
||||
let state = sample_state(&self.block, world, random, cursor)?;
|
||||
write(world, cursor, state, 3)?;
|
||||
cursor = tb::offset(cursor, 0, 1, 0);
|
||||
placed = true;
|
||||
} else {
|
||||
if !self.continue_through.test(world, cursor).map_err(query)? {
|
||||
break;
|
||||
}
|
||||
cursor = tb::offset(cursor, 0, 1, 0);
|
||||
}
|
||||
blocks_y -= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(placed)
|
||||
}
|
||||
fn find_surface<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
mut cursor: [i32; 3],
|
||||
mut limit: i32,
|
||||
) -> TreeResult<Option<[i32; 3]>, W::Error> {
|
||||
let min_y = world.min_y().map_err(query)?;
|
||||
while cursor[1] > min_y.wrapping_add(1) && limit > 0 {
|
||||
limit -= 1;
|
||||
if self.can_place_at(world, cursor)? {
|
||||
return Ok(Some(cursor));
|
||||
}
|
||||
cursor = tb::offset(cursor, 0, -1, 0);
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
fn find_air<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
mut cursor: [i32; 3],
|
||||
mut limit: i32,
|
||||
) -> TreeResult<Option<[i32; 3]>, W::Error> {
|
||||
let max_y = world.max_y().map_err(query)?;
|
||||
while cursor[1] <= max_y && limit > 0 {
|
||||
limit -= 1;
|
||||
let state = read(world, cursor)?;
|
||||
if self.cannot_place_on.contains(&state) {
|
||||
return Ok(None);
|
||||
}
|
||||
if self.blocks.is_air(state) {
|
||||
return Ok(Some(cursor));
|
||||
}
|
||||
cursor = tb::offset(cursor, 0, 1, 0);
|
||||
}
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,230 @@
|
||||
//! `minecraft:root_system`: a nested tree on a rooted-dirt column with
|
||||
//! hanging roots below.
|
||||
use super::{
|
||||
DecodeError, Object,
|
||||
block_feature::FeatureBlockBindings,
|
||||
block_predicate::BlockPredicate,
|
||||
feature::FeatureWorld,
|
||||
feature_graph::{FeatureExecutionError, PlacedFeatureDefinition},
|
||||
int_range,
|
||||
placement::{PlacementContext, PlacementQueryError},
|
||||
required,
|
||||
state_provider::BlockStateProvider,
|
||||
tree::{TreeDecoder, TreeResult, kind, read, sample_state, write},
|
||||
tree_blocks::{self as tb, TreeBlocks},
|
||||
vegetation::{PlacedDecoder, PlacedPlacer},
|
||||
};
|
||||
use crate::registry::BlockStateId;
|
||||
use horizon_core::{geometry::Direction, random::RandomSource};
|
||||
use std::{collections::BTreeSet, sync::Arc};
|
||||
|
||||
fn query<E>(error: PlacementQueryError) -> FeatureExecutionError<E> {
|
||||
FeatureExecutionError::Query(error)
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct RootSystemFeature {
|
||||
tree: Box<PlacedFeatureDefinition>,
|
||||
required_vertical_space: i32,
|
||||
level_test_distance: i32,
|
||||
max_level_deviation: i32,
|
||||
root_radius: i32,
|
||||
root_replaceable: Arc<BTreeSet<BlockStateId>>,
|
||||
root_provider: BlockStateProvider,
|
||||
root_attempts: i32,
|
||||
root_column_max_height: i32,
|
||||
hanging_radius: i32,
|
||||
hanging_span: i32,
|
||||
hanging_provider: BlockStateProvider,
|
||||
hanging_attempts: i32,
|
||||
allowed_water: i32,
|
||||
allowed_tree_position: BlockPredicate,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
impl RootSystemFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
nested: &PlacedDecoder<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:root_system" {
|
||||
return Err(DecodeError::Field("root system type"));
|
||||
}
|
||||
let blocks = bindings.tree_blocks()?;
|
||||
let tree = nested(required(&object, "feature")?.get(), depth + 1, remaining)?;
|
||||
let mut decoder = TreeDecoder {
|
||||
bindings,
|
||||
depth,
|
||||
remaining,
|
||||
};
|
||||
let int = |name: &'static str, low: i32, high: i32| {
|
||||
int_range(required(&object, name)?, name, low, high)
|
||||
};
|
||||
Ok(Self {
|
||||
tree: Box::new(tree),
|
||||
required_vertical_space: int("required_vertical_space_for_tree", 1, 64)?,
|
||||
level_test_distance: int("level_test_distance", 0, 16)?,
|
||||
max_level_deviation: int("max_level_deviation", 0, 64)?,
|
||||
root_radius: int("root_radius", 1, 64)?,
|
||||
root_replaceable: decoder.block_set(required(&object, "root_replaceable")?)?,
|
||||
root_provider: decoder.provider(required(&object, "root_state_provider")?)?,
|
||||
root_attempts: int("root_placement_attempts", 1, 256)?,
|
||||
root_column_max_height: int("root_column_max_height", 1, 4096)?,
|
||||
hanging_radius: int("hanging_root_radius", 1, 64)?,
|
||||
hanging_span: int("hanging_roots_vertical_span", 1, 16)?,
|
||||
hanging_provider: decoder
|
||||
.provider(required(&object, "hanging_root_state_provider")?)?,
|
||||
hanging_attempts: int("hanging_root_placement_attempts", 1, 256)?,
|
||||
allowed_water: int("allowed_vertical_water_for_tree", 1, 64)?,
|
||||
allowed_tree_position: BlockPredicate::decode_with_blocks(
|
||||
required(&object, "allowed_tree_position")?.get(),
|
||||
depth + 1,
|
||||
decoder.remaining,
|
||||
Some(bindings),
|
||||
)?,
|
||||
blocks,
|
||||
})
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
nested: &mut PlacedPlacer<'_, W, R>,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if !self.blocks.is_air(read(world, origin)?) {
|
||||
return Ok(false);
|
||||
}
|
||||
if self.dirt_and_tree(world, random, origin, nested)? {
|
||||
self.hanging_roots(world, random, origin)?;
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
fn space_for_tree<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
pos: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let mut column = pos;
|
||||
for i in 1..=self.required_vertical_space {
|
||||
column = tb::offset(column, 0, 1, 0);
|
||||
let state = read(world, column)?;
|
||||
let allowed = self.blocks.is_air(state)
|
||||
|| (i < self.allowed_water && self.blocks.has(state, tb::WATER_FLUID));
|
||||
if !allowed {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
if self.level_test_distance > 0 {
|
||||
// Direction.from2DDataValue: SOUTH, WEST, NORTH, EAST.
|
||||
for direction in [
|
||||
Direction::South,
|
||||
Direction::West,
|
||||
Direction::North,
|
||||
Direction::East,
|
||||
] {
|
||||
let corner = tb::relative(pos, direction, self.level_test_distance);
|
||||
let below = read(world, tb::offset(corner, 0, -self.max_level_deviation, 0))?;
|
||||
let above = read(world, tb::offset(corner, 0, self.max_level_deviation, 0))?;
|
||||
if self.blocks.is_air(below) || !self.blocks.is_air(above) {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
fn dirt_and_tree<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
nested: &mut PlacedPlacer<'_, W, R>,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let mut working = origin;
|
||||
for y in 0..self.root_column_max_height {
|
||||
working = tb::offset(working, 0, 1, 0);
|
||||
let surface = world
|
||||
.height(
|
||||
crate::heightmap::HeightmapType::WorldSurface,
|
||||
working[0],
|
||||
working[2],
|
||||
)
|
||||
.map_err(query)?;
|
||||
if surface < working[1] {
|
||||
return Ok(false);
|
||||
}
|
||||
if self
|
||||
.allowed_tree_position
|
||||
.test(world, working)
|
||||
.map_err(query)?
|
||||
&& self.space_for_tree(world, working)?
|
||||
{
|
||||
let below_state = read(world, tb::offset(working, 0, -1, 0))?;
|
||||
if self.blocks.has(below_state, tb::LAVA_FLUID)
|
||||
|| !self.blocks.has(below_state, tb::SOLID)
|
||||
{
|
||||
return Ok(false);
|
||||
}
|
||||
if nested(&self.tree, world, random, working)? {
|
||||
let target = origin[1].wrapping_add(y);
|
||||
let mut level = origin[1];
|
||||
while level < target {
|
||||
self.rooted_dirt(world, random, [origin[0], level, origin[2]])?;
|
||||
level += 1;
|
||||
}
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
fn rooted_dirt<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
column: [i32; 3],
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let r = self.root_radius;
|
||||
for _ in 0..self.root_attempts {
|
||||
let dx = random.next_int_bound(r)? - random.next_int_bound(r)?;
|
||||
let dz = random.next_int_bound(r)? - random.next_int_bound(r)?;
|
||||
let p = tb::offset(column, dx, 0, dz);
|
||||
if self.root_replaceable.contains(&read(world, p)?) {
|
||||
let state = sample_state(&self.root_provider, world, random, p)?;
|
||||
write(world, p, state, 2)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn hanging_roots<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let (r, span) = (self.hanging_radius, self.hanging_span);
|
||||
for _ in 0..self.hanging_attempts {
|
||||
let dx = random.next_int_bound(r)? - random.next_int_bound(r)?;
|
||||
let dy = random.next_int_bound(span)? - random.next_int_bound(span)?;
|
||||
let dz = random.next_int_bound(r)? - random.next_int_bound(r)?;
|
||||
let p = tb::offset(origin, dx, dy, dz);
|
||||
if !self.blocks.is_air(read(world, p)?) {
|
||||
continue;
|
||||
}
|
||||
let state = sample_state(&self.hanging_provider, world, random, p)?;
|
||||
if world.block_survives(state, p).map_err(query)? {
|
||||
let above = read(world, tb::offset(p, 0, 1, 0))?;
|
||||
if world
|
||||
.state_face_sturdy(above, p, Direction::Down)
|
||||
.map_err(query)?
|
||||
{
|
||||
write(world, p, state, 2)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,727 @@
|
||||
//! `minecraft:sculk_patch`: the world-generation SculkSpreader with sculk,
|
||||
//! sculk vein and default charge-cursor behaviours.
|
||||
use super::{
|
||||
DecodeError, Object,
|
||||
block_feature::FeatureBlockBindings,
|
||||
feature::FeatureWorld,
|
||||
feature_graph::FeatureExecutionError,
|
||||
int_range,
|
||||
placement::{PlacementContext, PlacementQueryError},
|
||||
required,
|
||||
tree::{TreeResult, kind, read, write},
|
||||
tree_blocks::{self as tb, TreeBlocks},
|
||||
};
|
||||
use crate::registry::BlockStateId;
|
||||
use horizon_core::{geometry::Direction, random::RandomSource};
|
||||
use std::{collections::BTreeSet, sync::Arc};
|
||||
|
||||
fn query<E>(error: PlacementQueryError) -> FeatureExecutionError<E> {
|
||||
FeatureExecutionError::Query(error)
|
||||
}
|
||||
|
||||
// Worldgen spreader constants (SculkSpreader.createWorldGenSpreader).
|
||||
const GROWTH_SPAWN_COST: i32 = 50;
|
||||
const NO_GROWTH_RADIUS: i32 = 1;
|
||||
const CHARGE_DECAY_RATE: i32 = 5;
|
||||
const ADDITIONAL_DECAY_RATE: i32 = 10;
|
||||
const MAX_CURSORS: usize = 32;
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
enum Behaviour {
|
||||
Default,
|
||||
Sculk,
|
||||
Vein,
|
||||
}
|
||||
#[derive(Clone, Copy)]
|
||||
enum Spread {
|
||||
SamePosition,
|
||||
SamePlane,
|
||||
WrapAround,
|
||||
}
|
||||
const ALL_SPREADS: [Spread; 3] = [Spread::SamePosition, Spread::SamePlane, Spread::WrapAround];
|
||||
|
||||
struct Cursor {
|
||||
pos: [i32; 3],
|
||||
charge: i32,
|
||||
update_delay: i32,
|
||||
decay_delay: i32,
|
||||
facings: Option<Vec<Direction>>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SculkPatchFeature {
|
||||
charge_count: i32,
|
||||
amount_per_charge: i32,
|
||||
spread_attempts: i32,
|
||||
growth_rounds: i32,
|
||||
spread_rounds: i32,
|
||||
sculk: BlockStateId,
|
||||
vein: BlockStateId,
|
||||
shrieker: BlockStateId,
|
||||
sensor: BlockStateId,
|
||||
water: BlockStateId,
|
||||
air: BlockStateId,
|
||||
replaceable_world_gen: Arc<BTreeSet<BlockStateId>>,
|
||||
replaceable: Arc<BTreeSet<BlockStateId>>,
|
||||
inhibitors: Arc<BTreeSet<BlockStateId>>,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
impl SculkPatchFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:sculk_patch" {
|
||||
return Err(DecodeError::Field("sculk patch type"));
|
||||
}
|
||||
let int = |name: &'static str, low: i32, high: i32| {
|
||||
int_range(required(&object, name)?, name, low, high)
|
||||
};
|
||||
let registry = bindings.registry();
|
||||
let default = |name: &str| {
|
||||
registry
|
||||
.default_state(name)
|
||||
.ok_or_else(|| DecodeError::Registry(format!("missing sculk block {name}")))
|
||||
};
|
||||
let tag = |name: &str| -> Arc<BTreeSet<BlockStateId>> {
|
||||
bindings.tags.get(name).cloned().unwrap_or_default()
|
||||
};
|
||||
let blocks = bindings.tree_blocks()?;
|
||||
let shrieker = blocks
|
||||
.with(default("minecraft:sculk_shrieker")?, "can_summon", "true")
|
||||
.ok_or(DecodeError::Field("sculk shrieker summon state"))?;
|
||||
Ok(Self {
|
||||
charge_count: int("charge_count", 1, 32)?,
|
||||
amount_per_charge: int("amount_per_charge", 1, 500)?,
|
||||
spread_attempts: int("spread_attempts", 1, 64)?,
|
||||
growth_rounds: int("growth_rounds", 0, 8)?,
|
||||
spread_rounds: int("spread_rounds", 0, 8)?,
|
||||
sculk: default("minecraft:sculk")?,
|
||||
vein: default("minecraft:sculk_vein")?,
|
||||
shrieker,
|
||||
sensor: default("minecraft:sculk_sensor")?,
|
||||
water: default("minecraft:water")?,
|
||||
air: default("minecraft:air")?,
|
||||
replaceable_world_gen: tag("minecraft:sculk_replaceable_world_gen"),
|
||||
replaceable: tag("minecraft:sculk_replaceable"),
|
||||
inhibitors: tag("minecraft:sculk_growth_inhibitors"),
|
||||
blocks,
|
||||
})
|
||||
}
|
||||
fn behaviour(&self, state: BlockStateId) -> Behaviour {
|
||||
if self.blocks.same_block(state, self.sculk) {
|
||||
Behaviour::Sculk
|
||||
} else if self.blocks.same_block(state, self.vein) {
|
||||
Behaviour::Vein
|
||||
} else {
|
||||
Behaviour::Default
|
||||
}
|
||||
}
|
||||
fn has_face(&self, state: BlockStateId, face: Direction) -> bool {
|
||||
self.blocks
|
||||
.properties
|
||||
.value(state, tb::direction_name(face))
|
||||
== Some("true")
|
||||
}
|
||||
fn is_vein(&self, state: BlockStateId) -> bool {
|
||||
self.blocks.same_block(state, self.vein)
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if !self.can_spread_from(world, origin)? {
|
||||
return Ok(false);
|
||||
}
|
||||
let mut cursors: Vec<Cursor> = Vec::new();
|
||||
for round in 0..self.spread_rounds + self.growth_rounds {
|
||||
for _ in 0..self.charge_count {
|
||||
let mut charge = self.amount_per_charge;
|
||||
while charge > 0 {
|
||||
let current = charge.min(1000);
|
||||
if cursors.len() < MAX_CURSORS {
|
||||
cursors.push(Cursor {
|
||||
pos: origin,
|
||||
charge: current,
|
||||
update_delay: 0,
|
||||
decay_delay: 1,
|
||||
facings: None,
|
||||
});
|
||||
}
|
||||
charge -= current;
|
||||
}
|
||||
}
|
||||
let spread_veins = round < self.spread_rounds;
|
||||
for _ in 0..self.spread_attempts {
|
||||
cursors = self.update_cursors(world, random, origin, cursors, spread_veins)?;
|
||||
}
|
||||
cursors.clear();
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
fn can_spread_from<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let start = read(world, origin)?;
|
||||
if self.behaviour(start) != Behaviour::Default {
|
||||
return Ok(true);
|
||||
}
|
||||
let water_source =
|
||||
self.blocks.has(start, tb::WATER_BLOCK) && self.blocks.has(start, tb::FLUID_SOURCE);
|
||||
if !self.blocks.is_air(start) && !water_source {
|
||||
return Ok(false);
|
||||
}
|
||||
for direction in Direction::ALL {
|
||||
let p = tb::relative(origin, direction, 1);
|
||||
let state = read(world, p)?;
|
||||
if world.collision_full_block(state, p).map_err(query)? {
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
fn update_cursors<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
cursors: Vec<Cursor>,
|
||||
spread_veins: bool,
|
||||
) -> TreeResult<Vec<Cursor>, W::Error> {
|
||||
let mut processed: Vec<Cursor> = Vec::new();
|
||||
// Mergeable cursor charge per position (index into `processed`).
|
||||
let mut mergeable: Vec<([i32; 3], usize, i32)> = Vec::new();
|
||||
for mut cursor in cursors {
|
||||
let distance = (0..3)
|
||||
.map(|i| cursor.pos[i].wrapping_sub(origin[i]).wrapping_abs())
|
||||
.max()
|
||||
.unwrap_or(0);
|
||||
if distance > 1024 {
|
||||
continue;
|
||||
}
|
||||
self.update(world, random, origin, &mut cursor, spread_veins)?;
|
||||
if cursor.charge <= 0 {
|
||||
continue;
|
||||
}
|
||||
match mergeable.iter_mut().find(|(p, _, _)| *p == cursor.pos) {
|
||||
None => {
|
||||
mergeable.push((cursor.pos, processed.len(), cursor.charge));
|
||||
processed.push(cursor);
|
||||
}
|
||||
Some(entry) => {
|
||||
// World generation never merges cursors.
|
||||
if cursor.charge < entry.2 {
|
||||
*entry = (cursor.pos, processed.len(), cursor.charge);
|
||||
}
|
||||
processed.push(cursor);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(processed)
|
||||
}
|
||||
fn update<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
cursor: &mut Cursor,
|
||||
spread_veins: bool,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
if cursor.charge <= 0 {
|
||||
return Ok(());
|
||||
}
|
||||
if cursor.update_delay > 0 {
|
||||
cursor.update_delay -= 1;
|
||||
return Ok(());
|
||||
}
|
||||
let mut state = read(world, cursor.pos)?;
|
||||
let mut behaviour = self.behaviour(state);
|
||||
if spread_veins
|
||||
&& self.attempt_spread_vein(
|
||||
world,
|
||||
behaviour,
|
||||
cursor.pos,
|
||||
state,
|
||||
cursor.facings.as_deref(),
|
||||
)?
|
||||
&& behaviour != Behaviour::Sculk
|
||||
{
|
||||
state = read(world, cursor.pos)?;
|
||||
behaviour = self.behaviour(state);
|
||||
}
|
||||
cursor.charge =
|
||||
self.attempt_use_charge(world, random, origin, behaviour, cursor, spread_veins)?;
|
||||
if cursor.charge <= 0 {
|
||||
self.on_discharged(world, behaviour, state, cursor.pos)?;
|
||||
return Ok(());
|
||||
}
|
||||
match self.valid_movement(world, random, cursor.pos, origin)? {
|
||||
Some(target) => {
|
||||
self.on_discharged(world, behaviour, state, cursor.pos)?;
|
||||
cursor.pos = target;
|
||||
state = read(world, target)?;
|
||||
}
|
||||
None => {
|
||||
self.on_discharged(world, behaviour, state, cursor.pos)?;
|
||||
cursor.charge = 0;
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
if self.behaviour(state) != Behaviour::Default {
|
||||
cursor.facings = Some(
|
||||
Direction::ALL
|
||||
.into_iter()
|
||||
.filter(|d| self.has_face(state, *d))
|
||||
.collect(),
|
||||
);
|
||||
}
|
||||
cursor.decay_delay = match behaviour {
|
||||
Behaviour::Default => (cursor.decay_delay - 1).max(0),
|
||||
_ => 1,
|
||||
};
|
||||
cursor.update_delay = 1;
|
||||
Ok(())
|
||||
}
|
||||
fn attempt_spread_vein<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
behaviour: Behaviour,
|
||||
pos: [i32; 3],
|
||||
state: BlockStateId,
|
||||
facings: Option<&[Direction]>,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if behaviour == Behaviour::Default {
|
||||
match facings {
|
||||
None => {
|
||||
let current = read(world, pos)?;
|
||||
return Ok(self.spread_all(world, current, pos, &[Spread::SamePosition])? > 0);
|
||||
}
|
||||
Some(faces) if !faces.is_empty() => {
|
||||
let water_source = self.blocks.has(state, tb::WATER_SOURCE);
|
||||
if !self.blocks.is_air(state) && !water_source {
|
||||
return Ok(false);
|
||||
}
|
||||
return self.regrow(world, pos, state, faces);
|
||||
}
|
||||
Some(_) => {}
|
||||
}
|
||||
}
|
||||
Ok(self.spread_all(world, state, pos, &ALL_SPREADS)? > 0)
|
||||
}
|
||||
fn regrow<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
pos: [i32; 3],
|
||||
existing: BlockStateId,
|
||||
faces: &[Direction],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let mut state = self.vein;
|
||||
let mut any = false;
|
||||
for &face in faces {
|
||||
if world.attachment_at(pos, face).map_err(query)? {
|
||||
state = self.with_face(state, face, true)?;
|
||||
any = true;
|
||||
}
|
||||
}
|
||||
if !any {
|
||||
return Ok(false);
|
||||
}
|
||||
if self.blocks.has(existing, tb::ANY_FLUID) {
|
||||
state = self.blocks.waterlogged(state, true);
|
||||
}
|
||||
write(world, pos, state, 3)?;
|
||||
Ok(true)
|
||||
}
|
||||
fn with_face<E>(
|
||||
&self,
|
||||
state: BlockStateId,
|
||||
face: Direction,
|
||||
value: bool,
|
||||
) -> TreeResult<BlockStateId, E> {
|
||||
self.blocks
|
||||
.with(
|
||||
state,
|
||||
tb::direction_name(face),
|
||||
if value { "true" } else { "false" },
|
||||
)
|
||||
.ok_or(FeatureExecutionError::InvalidState)
|
||||
}
|
||||
/// MultifaceSpreader.spreadAll with the sculk vein spreader configuration
|
||||
/// (post-processing enabled for world generation).
|
||||
fn spread_all<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
state: BlockStateId,
|
||||
pos: [i32; 3],
|
||||
types: &[Spread],
|
||||
) -> TreeResult<i64, W::Error> {
|
||||
let other_source = !self.is_vein(state);
|
||||
let mut count = 0;
|
||||
for face in Direction::ALL {
|
||||
if !(other_source || self.has_face(state, face)) {
|
||||
continue;
|
||||
}
|
||||
for direction in Direction::ALL {
|
||||
if tb::Axis::of(direction) == tb::Axis::of(face) {
|
||||
continue;
|
||||
}
|
||||
if !(other_source
|
||||
|| (self.has_face(state, face) && !self.has_face(state, direction)))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let mut target = None;
|
||||
for kind in types {
|
||||
let candidate = match kind {
|
||||
Spread::SamePosition => (pos, direction),
|
||||
Spread::SamePlane => (tb::relative(pos, direction, 1), face),
|
||||
Spread::WrapAround => (
|
||||
tb::relative(tb::relative(pos, direction, 1), face, 1),
|
||||
direction.opposite(),
|
||||
),
|
||||
};
|
||||
if self.can_spread_into(world, pos, candidate.0, candidate.1)? {
|
||||
target = Some(candidate);
|
||||
break;
|
||||
}
|
||||
}
|
||||
let Some((target, face_to)) = target else {
|
||||
continue;
|
||||
};
|
||||
let old = read(world, target)?;
|
||||
let Some(new) = self.state_for_placement(world, old, target, face_to)? else {
|
||||
continue;
|
||||
};
|
||||
world.mark_postprocessing(target).map_err(query)?;
|
||||
if write(world, target, new, 2)? {
|
||||
count += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(count)
|
||||
}
|
||||
fn valid_for_placement<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
old: BlockStateId,
|
||||
pos: [i32; 3],
|
||||
face: Direction,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if self.is_vein(old) && self.has_face(old, face) {
|
||||
return Ok(false);
|
||||
}
|
||||
world.attachment_at(pos, face).map_err(query)
|
||||
}
|
||||
fn state_for_placement<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
old: BlockStateId,
|
||||
pos: [i32; 3],
|
||||
face: Direction,
|
||||
) -> TreeResult<Option<BlockStateId>, W::Error> {
|
||||
if !self.valid_for_placement(world, old, pos, face)? {
|
||||
return Ok(None);
|
||||
}
|
||||
let base = if self.is_vein(old) {
|
||||
old
|
||||
} else if self.blocks.has(old, tb::WATER_SOURCE) {
|
||||
self.blocks.waterlogged(self.vein, true)
|
||||
} else {
|
||||
self.vein
|
||||
};
|
||||
self.with_face(base, face, true).map(Some)
|
||||
}
|
||||
fn can_spread_into<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
source: [i32; 3],
|
||||
target: [i32; 3],
|
||||
face: Direction,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let existing = read(world, target)?;
|
||||
let against = read(world, tb::relative(target, face, 1))?;
|
||||
if self.blocks.has(against, tb::SCULK_BLOCKER) {
|
||||
return Ok(false);
|
||||
}
|
||||
if tb::dist_manhattan(source, target) == 2 {
|
||||
let neighbor = tb::relative(source, face.opposite(), 1);
|
||||
let state = read(world, neighbor)?;
|
||||
if world
|
||||
.state_face_sturdy(state, neighbor, face)
|
||||
.map_err(query)?
|
||||
{
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
if self.blocks.has(existing, tb::ANY_FLUID) && !self.blocks.has(existing, tb::WATER_SOURCE)
|
||||
{
|
||||
return Ok(false);
|
||||
}
|
||||
if self.blocks.has(existing, tb::FIRE) {
|
||||
return Ok(false);
|
||||
}
|
||||
let replaceable = self.blocks.has(existing, tb::REPLACEABLE)
|
||||
|| self.blocks.is_air(existing)
|
||||
|| self.is_vein(existing)
|
||||
|| (self.blocks.has(existing, tb::WATER_BLOCK)
|
||||
&& self.blocks.has(existing, tb::WATER_SOURCE));
|
||||
Ok(replaceable && self.valid_for_placement(world, existing, target, face)?)
|
||||
}
|
||||
fn attempt_use_charge<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
behaviour: Behaviour,
|
||||
cursor: &Cursor,
|
||||
spread_veins: bool,
|
||||
) -> TreeResult<i32, W::Error> {
|
||||
let charge = cursor.charge;
|
||||
match behaviour {
|
||||
Behaviour::Default => Ok(if cursor.decay_delay > 0 { charge } else { 0 }),
|
||||
Behaviour::Vein => {
|
||||
if spread_veins && self.place_sculk(world, random, cursor.pos)? {
|
||||
Ok(charge - 1)
|
||||
} else if random.next_int_bound(CHARGE_DECAY_RATE)? == 0 {
|
||||
Ok((charge as f32 * 0.5f32).floor() as i32)
|
||||
} else {
|
||||
Ok(charge)
|
||||
}
|
||||
}
|
||||
Behaviour::Sculk => {
|
||||
if charge == 0 || random.next_int_bound(CHARGE_DECAY_RATE)? != 0 {
|
||||
return Ok(charge);
|
||||
}
|
||||
let pos = cursor.pos;
|
||||
let dist_sqr: f64 = (0..3)
|
||||
.map(|i| {
|
||||
let d = f64::from(pos[i]) - f64::from(origin[i]);
|
||||
d * d
|
||||
})
|
||||
.sum();
|
||||
let close = dist_sqr < f64::from(NO_GROWTH_RADIUS * NO_GROWTH_RADIUS);
|
||||
if !close && self.can_place_growth(world, pos)? {
|
||||
if random.next_int_bound(GROWTH_SPAWN_COST)? < charge {
|
||||
let above = tb::offset(pos, 0, 1, 0);
|
||||
let mut growth = if random.next_int_bound(11)? == 0 {
|
||||
self.shrieker
|
||||
} else {
|
||||
self.sensor
|
||||
};
|
||||
if self.blocks.has(growth, tb::WATERLOGGABLE)
|
||||
&& self.blocks.has(read(world, above)?, tb::ANY_FLUID)
|
||||
{
|
||||
growth = self.blocks.waterlogged(growth, true);
|
||||
}
|
||||
write(world, above, growth, 3)?;
|
||||
}
|
||||
return Ok(0.max(charge - GROWTH_SPAWN_COST));
|
||||
}
|
||||
if random.next_int_bound(ADDITIONAL_DECAY_RATE)? != 0 {
|
||||
return Ok(charge);
|
||||
}
|
||||
let penalty = if close {
|
||||
1
|
||||
} else {
|
||||
let outer = (dist_sqr.sqrt() as f32 - NO_GROWTH_RADIUS as f32).powi(2);
|
||||
let reach = (24 - NO_GROWTH_RADIUS) * (24 - NO_GROWTH_RADIUS);
|
||||
let factor = 1.0f32.min(outer / reach as f32);
|
||||
1.max((charge as f32 * factor * 0.5f32) as i32)
|
||||
};
|
||||
Ok(charge - penalty)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn can_place_growth<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
pos: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let above = read(world, tb::offset(pos, 0, 1, 0))?;
|
||||
let open = self.blocks.is_air(above)
|
||||
|| (self.blocks.has(above, tb::WATER_BLOCK)
|
||||
&& self.blocks.has(above, tb::WATER_SOURCE));
|
||||
if !open {
|
||||
return Ok(false);
|
||||
}
|
||||
let mut matched = 0;
|
||||
// BoxBlockMatcher iterates BlockPos.betweenClosed (x, then y, then z).
|
||||
for dz in -4..=4 {
|
||||
for dy in 0..=2 {
|
||||
for dx in -4..=4 {
|
||||
if self
|
||||
.inhibitors
|
||||
.contains(&read(world, tb::offset(pos, dx, dy, dz))?)
|
||||
{
|
||||
matched += 1;
|
||||
if matched >= 3 {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
fn place_sculk<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
pos: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let state = read(world, pos)?;
|
||||
let mut directions = Direction::ALL;
|
||||
tb::shuffle(&mut directions, random)?;
|
||||
for support in directions {
|
||||
if !self.has_face(state, support) {
|
||||
continue;
|
||||
}
|
||||
let support_pos = tb::relative(pos, support, 1);
|
||||
let support_state = read(world, support_pos)?;
|
||||
if !self.replaceable_world_gen.contains(&support_state) {
|
||||
continue;
|
||||
}
|
||||
write(world, support_pos, self.sculk, 3)?;
|
||||
self.spread_all(world, self.sculk, support_pos, &ALL_SPREADS)?;
|
||||
let skip = support.opposite();
|
||||
for direction in Direction::ALL {
|
||||
if direction == skip {
|
||||
continue;
|
||||
}
|
||||
let vein_pos = tb::relative(support_pos, direction, 1);
|
||||
let possible = read(world, vein_pos)?;
|
||||
if self.is_vein(possible) {
|
||||
self.on_discharged(world, Behaviour::Vein, possible, vein_pos)?;
|
||||
}
|
||||
}
|
||||
return Ok(true);
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
fn on_discharged<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
behaviour: Behaviour,
|
||||
state: BlockStateId,
|
||||
pos: [i32; 3],
|
||||
) -> TreeResult<(), W::Error> {
|
||||
if behaviour != Behaviour::Vein || !self.is_vein(state) {
|
||||
return Ok(());
|
||||
}
|
||||
let mut state = state;
|
||||
for direction in Direction::ALL {
|
||||
if self.has_face(state, direction)
|
||||
&& self
|
||||
.blocks
|
||||
.same_block(read(world, tb::relative(pos, direction, 1))?, self.sculk)
|
||||
{
|
||||
state = self.with_face(state, direction, false)?;
|
||||
}
|
||||
}
|
||||
if !Direction::ALL.into_iter().any(|d| self.has_face(state, d)) {
|
||||
let here = read(world, pos)?;
|
||||
state = if self.blocks.has(here, tb::ANY_FLUID) {
|
||||
self.water
|
||||
} else {
|
||||
self.air
|
||||
};
|
||||
}
|
||||
write(world, pos, state, 3)?;
|
||||
Ok(())
|
||||
}
|
||||
fn valid_movement<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
pos: [i32; 3],
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<Option<[i32; 3]>, W::Error> {
|
||||
// NON_CORNER_NEIGHBOURS in betweenClosed order (x, then y, then z).
|
||||
let mut offsets = Vec::with_capacity(18);
|
||||
for z in -1..=1 {
|
||||
for y in -1..=1 {
|
||||
for x in -1..=1 {
|
||||
if (x == 0 || y == 0 || z == 0) && (x, y, z) != (0, 0, 0) {
|
||||
offsets.push([x, y, z]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
tb::shuffle(&mut offsets, random)?;
|
||||
let mut best = pos;
|
||||
for o in offsets {
|
||||
let neighbour = tb::offset(pos, o[0], o[1], o[2]);
|
||||
let dx = origin[0].wrapping_sub(neighbour[0]);
|
||||
let dz = origin[2].wrapping_sub(neighbour[2]);
|
||||
if dx.wrapping_mul(dx).wrapping_add(dz.wrapping_mul(dz)) > 144 {
|
||||
continue;
|
||||
}
|
||||
let transferee = read(world, neighbour)?;
|
||||
if self.behaviour(transferee) == Behaviour::Default
|
||||
|| !self.unobstructed_move(world, pos, neighbour)?
|
||||
{
|
||||
continue;
|
||||
}
|
||||
best = neighbour;
|
||||
if self.is_vein(transferee) {
|
||||
let mut substrate = false;
|
||||
for direction in Direction::ALL {
|
||||
if self.has_face(transferee, direction)
|
||||
&& self
|
||||
.replaceable
|
||||
.contains(&read(world, tb::relative(neighbour, direction, 1))?)
|
||||
{
|
||||
substrate = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if substrate {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok((best != pos).then_some(best))
|
||||
}
|
||||
fn unobstructed_move<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
from: [i32; 3],
|
||||
to: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if tb::dist_manhattan(from, to) == 1 {
|
||||
return Ok(true);
|
||||
}
|
||||
let delta: [i32; 3] = std::array::from_fn(|i| to[i].wrapping_sub(from[i]));
|
||||
let pick = |v: i32, negative: Direction, positive: Direction| {
|
||||
if v < 0 { negative } else { positive }
|
||||
};
|
||||
let dir_x = pick(delta[0], Direction::West, Direction::East);
|
||||
let dir_y = pick(delta[1], Direction::Down, Direction::Up);
|
||||
let dir_z = pick(delta[2], Direction::North, Direction::South);
|
||||
let (a, b) = if delta[0] == 0 {
|
||||
(dir_y, dir_z)
|
||||
} else if delta[1] == 0 {
|
||||
(dir_x, dir_z)
|
||||
} else {
|
||||
(dir_x, dir_y)
|
||||
};
|
||||
Ok(self.unobstructed(world, from, a)? || self.unobstructed(world, from, b)?)
|
||||
}
|
||||
fn unobstructed<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
from: [i32; 3],
|
||||
direction: Direction,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let test = tb::relative(from, direction, 1);
|
||||
let state = read(world, test)?;
|
||||
Ok(!world
|
||||
.state_face_sturdy(state, test, direction.opposite())
|
||||
.map_err(query)?)
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,7 @@
|
||||
mod catalog;
|
||||
mod noise;
|
||||
pub use catalog::StateProviderCatalog;
|
||||
mod properties;
|
||||
pub(crate) mod properties;
|
||||
use super::{
|
||||
DecodeError, Object,
|
||||
block_predicate::{BlockPredicate, PredicateBlockResolver},
|
||||
@@ -137,7 +137,7 @@ impl<'r> StateProviderBindings<'r> {
|
||||
.clone()
|
||||
.map_err(DecodeError::Registry)
|
||||
}
|
||||
fn properties(&self) -> Result<Arc<StateProperties>, DecodeError> {
|
||||
pub(crate) fn properties(&self) -> Result<Arc<StateProperties>, DecodeError> {
|
||||
self.properties
|
||||
.get_or_init(|| StateProperties::build(self.registry, &self.integers).map(Arc::new))
|
||||
.clone()
|
||||
|
||||
@@ -21,7 +21,7 @@ struct Block {
|
||||
properties: Vec<Property>,
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub(super) struct StateProperties {
|
||||
pub(crate) struct StateProperties {
|
||||
blocks: Vec<Block>,
|
||||
addresses: Vec<Address>,
|
||||
}
|
||||
@@ -175,4 +175,32 @@ impl StateProperties {
|
||||
.get(address.local - previous * property.stride + index * property.stride)
|
||||
.copied()
|
||||
}
|
||||
|
||||
fn property(&self, state: BlockStateId, name: &str) -> Option<(Address, &Property)> {
|
||||
let address = *self.addresses.get(state.0 as usize)?;
|
||||
let property = self.blocks[address.block]
|
||||
.properties
|
||||
.iter()
|
||||
.find(|p| p.name == name)?;
|
||||
Some((address, property))
|
||||
}
|
||||
/// The state's value for a named property, or None when it has no such property.
|
||||
pub fn value(&self, state: BlockStateId, name: &str) -> Option<&str> {
|
||||
let (address, property) = self.property(state, name)?;
|
||||
Some(&property.values[(address.local / property.stride) % property.values.len()])
|
||||
}
|
||||
/// All values of the state's named property in registry encounter order.
|
||||
pub fn values(&self, state: BlockStateId, name: &str) -> Option<&[String]> {
|
||||
self.property(state, name).map(|(_, p)| p.values.as_slice())
|
||||
}
|
||||
/// Replace one property value, or None for a missing property or value.
|
||||
pub fn with_value(&self, state: BlockStateId, name: &str, value: &str) -> Option<BlockStateId> {
|
||||
let (address, property) = self.property(state, name)?;
|
||||
let index = *property.lookup.get(value)?;
|
||||
let previous = (address.local / property.stride) % property.values.len();
|
||||
self.blocks[address.block]
|
||||
.states
|
||||
.get(address.local - previous * property.stride + index * property.stride)
|
||||
.copied()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,832 @@
|
||||
//! Vanilla 26.3 `minecraft:tree` and `minecraft:fallen_tree` features: trunk,
|
||||
//! foliage and root placers, decorators, minimum-size clipping and the native
|
||||
//! leaf-distance pass. Native HashSet iteration order is reproduced wherever it
|
||||
//! feeds random draws. Neighbor shape updates at the tree's outer faces are
|
||||
//! delegated to `PlacementContext::update_shape_at_face`.
|
||||
mod decorator;
|
||||
mod fallen;
|
||||
mod foliage;
|
||||
mod trunk;
|
||||
use super::{
|
||||
DecodeError, Object,
|
||||
block_feature::FeatureBlockBindings,
|
||||
density::identifier,
|
||||
feature::{FeatureError, FeatureWorld},
|
||||
feature_graph::{FeatureDefinition, FeatureExecutionError},
|
||||
int_range, number_text, optional,
|
||||
placement::PlacementContext,
|
||||
required,
|
||||
state_provider::BlockStateProvider,
|
||||
tree_blocks::{self as tb, PosSet, TreeBlocks},
|
||||
value_provider::IntProvider,
|
||||
};
|
||||
use crate::registry::BlockStateId;
|
||||
pub(crate) use decorator::GROUND_FEATURE_KEY;
|
||||
use decorator::TreeDecorator;
|
||||
pub use fallen::FallenTreeFeature;
|
||||
use foliage::{FoliageAttachment, FoliagePlacer};
|
||||
use horizon_core::{geometry::Direction, random::RandomSource};
|
||||
use serde_json::value::RawValue;
|
||||
use std::{collections::BTreeSet, sync::Arc};
|
||||
use trunk::TrunkPlacer;
|
||||
|
||||
pub(crate) type TreeResult<T, E> = Result<T, FeatureExecutionError<E>>;
|
||||
/// Places a nested configured feature (the pale-moss ground patch).
|
||||
pub(crate) type NestedPlacer<'a, W, R> = dyn FnMut(
|
||||
&FeatureDefinition,
|
||||
&mut W,
|
||||
&mut R,
|
||||
[i32; 3],
|
||||
) -> TreeResult<bool, <W as FeatureWorld>::Error>
|
||||
+ 'a;
|
||||
|
||||
pub(crate) fn world_error<E>(error: E) -> FeatureExecutionError<E> {
|
||||
FeatureExecutionError::Basic(FeatureError::World(error))
|
||||
}
|
||||
pub(crate) fn read<W: FeatureWorld>(
|
||||
world: &mut W,
|
||||
position: [i32; 3],
|
||||
) -> TreeResult<BlockStateId, W::Error> {
|
||||
world.block(position).map_err(world_error)
|
||||
}
|
||||
pub(crate) fn write<W: FeatureWorld>(
|
||||
world: &mut W,
|
||||
position: [i32; 3],
|
||||
state: BlockStateId,
|
||||
flags: i32,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
world.set_block(position, state, flags).map_err(world_error)
|
||||
}
|
||||
pub(crate) fn sample_state<W: FeatureWorld + PlacementContext>(
|
||||
provider: &BlockStateProvider,
|
||||
world: &mut W,
|
||||
random: &mut impl RandomSource,
|
||||
position: [i32; 3],
|
||||
) -> TreeResult<BlockStateId, W::Error> {
|
||||
provider
|
||||
.get_state(world, random, position)
|
||||
.map_err(FeatureExecutionError::Provider)
|
||||
}
|
||||
pub(crate) fn sample_optional<W: FeatureWorld + PlacementContext>(
|
||||
provider: &BlockStateProvider,
|
||||
world: &mut W,
|
||||
random: &mut impl RandomSource,
|
||||
position: [i32; 3],
|
||||
) -> TreeResult<Option<BlockStateId>, W::Error> {
|
||||
provider
|
||||
.get_optional_state(world, random, position)
|
||||
.map_err(FeatureExecutionError::Provider)
|
||||
}
|
||||
|
||||
/// Decoding context shared by every tree component.
|
||||
pub(crate) struct TreeDecoder<'a, 'r> {
|
||||
pub bindings: &'a FeatureBlockBindings<'r>,
|
||||
pub depth: usize,
|
||||
pub remaining: &'a mut usize,
|
||||
}
|
||||
impl TreeDecoder<'_, '_> {
|
||||
pub fn provider(&mut self, raw: &RawValue) -> Result<BlockStateProvider, DecodeError> {
|
||||
let (providers, catalog, _) = self
|
||||
.bindings
|
||||
.simple_blocks
|
||||
.as_ref()
|
||||
.ok_or(DecodeError::Field("tree provider bindings"))?;
|
||||
catalog.provider_with_budget(raw.get(), providers, self.depth + 1, self.remaining)
|
||||
}
|
||||
pub fn int_provider(
|
||||
&mut self,
|
||||
raw: &RawValue,
|
||||
low: i32,
|
||||
high: i32,
|
||||
) -> Result<IntProvider, DecodeError> {
|
||||
let value = IntProvider::decode(raw, self.depth + 1, self.remaining)?;
|
||||
let [min, max] = value.bounds();
|
||||
if min < low || max > high {
|
||||
return Err(DecodeError::Field("tree integer provider bounds"));
|
||||
}
|
||||
Ok(value)
|
||||
}
|
||||
pub fn block_set(&self, raw: &RawValue) -> Result<Arc<BTreeSet<BlockStateId>>, DecodeError> {
|
||||
super::block_predicate::PredicateBlockResolver::predicate_block_set(
|
||||
self.bindings,
|
||||
raw.get(),
|
||||
)
|
||||
}
|
||||
}
|
||||
pub(crate) fn unit_float(raw: &RawValue, name: &'static str) -> Result<f32, DecodeError> {
|
||||
let value: f32 = number_text(raw)?
|
||||
.parse()
|
||||
.map_err(|_| DecodeError::Field(name))?;
|
||||
if !(0.0..=1.0).contains(&value) {
|
||||
return Err(DecodeError::Field(name));
|
||||
}
|
||||
Ok(value)
|
||||
}
|
||||
pub(crate) fn kind(object: &Object) -> Result<String, DecodeError> {
|
||||
identifier(&serde_json::from_str::<String>(
|
||||
required(object, "type")?.get(),
|
||||
)?)
|
||||
}
|
||||
fn optional_int(
|
||||
object: &Object,
|
||||
name: &'static str,
|
||||
default: i32,
|
||||
low: i32,
|
||||
high: i32,
|
||||
) -> Result<i32, DecodeError> {
|
||||
optional(object, name)
|
||||
.map(|raw| int_range(raw, name, low, high))
|
||||
.transpose()
|
||||
.map(|v| v.unwrap_or(default))
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum FeatureSize {
|
||||
TwoLayers {
|
||||
limit: i32,
|
||||
lower: i32,
|
||||
upper: i32,
|
||||
},
|
||||
ThreeLayers {
|
||||
limit: i32,
|
||||
upper_limit: i32,
|
||||
lower: i32,
|
||||
middle: i32,
|
||||
upper: i32,
|
||||
},
|
||||
}
|
||||
impl FeatureSize {
|
||||
fn decode(raw: &RawValue) -> Result<(Self, Option<i32>), DecodeError> {
|
||||
let object: Object = serde_json::from_str(raw.get())?;
|
||||
let clipped = optional(&object, "min_clipped_height")
|
||||
.map(|raw| int_range(raw, "min_clipped_height", 0, 80))
|
||||
.transpose()?;
|
||||
let size = match kind(&object)?.as_str() {
|
||||
"minecraft:two_layers_feature_size" => Self::TwoLayers {
|
||||
limit: optional_int(&object, "limit", 1, 0, 81)?,
|
||||
lower: optional_int(&object, "lower_size", 0, 0, 16)?,
|
||||
upper: optional_int(&object, "upper_size", 1, 0, 16)?,
|
||||
},
|
||||
"minecraft:three_layers_feature_size" => Self::ThreeLayers {
|
||||
limit: optional_int(&object, "limit", 1, 0, 80)?,
|
||||
upper_limit: optional_int(&object, "upper_limit", 1, 0, 80)?,
|
||||
lower: optional_int(&object, "lower_size", 0, 0, 16)?,
|
||||
middle: optional_int(&object, "middle_size", 1, 0, 16)?,
|
||||
upper: optional_int(&object, "upper_size", 1, 0, 16)?,
|
||||
},
|
||||
_ => return Err(DecodeError::Field("feature size type")),
|
||||
};
|
||||
Ok((size, clipped))
|
||||
}
|
||||
fn size_at_height(&self, tree_height: i32, yo: i32) -> i32 {
|
||||
match *self {
|
||||
Self::TwoLayers {
|
||||
limit,
|
||||
lower,
|
||||
upper,
|
||||
} => {
|
||||
if yo < limit {
|
||||
lower
|
||||
} else {
|
||||
upper
|
||||
}
|
||||
}
|
||||
Self::ThreeLayers {
|
||||
limit,
|
||||
upper_limit,
|
||||
lower,
|
||||
middle,
|
||||
upper,
|
||||
} => {
|
||||
if yo < limit {
|
||||
lower
|
||||
} else if yo >= tree_height.wrapping_sub(upper_limit) {
|
||||
upper
|
||||
} else {
|
||||
middle
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct MangroveRoots {
|
||||
can_grow_through: Arc<BTreeSet<BlockStateId>>,
|
||||
muddy_roots_in: Arc<BTreeSet<BlockStateId>>,
|
||||
muddy_roots_provider: BlockStateProvider,
|
||||
max_root_width: i32,
|
||||
max_root_length: i32,
|
||||
random_skew_chance: f32,
|
||||
}
|
||||
#[derive(Clone, Debug)]
|
||||
struct RootPlacer {
|
||||
trunk_offset_y: IntProvider,
|
||||
root_provider: BlockStateProvider,
|
||||
above: Option<(BlockStateProvider, f32)>,
|
||||
mangrove: MangroveRoots,
|
||||
}
|
||||
impl RootPlacer {
|
||||
fn decode(raw: &RawValue, decoder: &mut TreeDecoder<'_, '_>) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(raw.get())?;
|
||||
if kind(&object)? != "minecraft:mangrove_root_placer" {
|
||||
return Err(DecodeError::Field("root placer type"));
|
||||
}
|
||||
let trunk_offset_y = IntProvider::decode(
|
||||
required(&object, "trunk_offset_y")?,
|
||||
decoder.depth + 1,
|
||||
decoder.remaining,
|
||||
)?;
|
||||
let root_provider = decoder.provider(required(&object, "root_provider")?)?;
|
||||
let above = optional(&object, "above_root_placement")
|
||||
.map(|raw| -> Result<_, DecodeError> {
|
||||
let above: Object = serde_json::from_str(raw.get())?;
|
||||
Ok((
|
||||
decoder.provider(required(&above, "above_root_provider")?)?,
|
||||
unit_float(
|
||||
required(&above, "above_root_placement_chance")?,
|
||||
"above_root_placement_chance",
|
||||
)?,
|
||||
))
|
||||
})
|
||||
.transpose()?;
|
||||
let placement: Object =
|
||||
serde_json::from_str(required(&object, "mangrove_root_placement")?.get())?;
|
||||
let mangrove = MangroveRoots {
|
||||
can_grow_through: decoder.block_set(required(&placement, "can_grow_through")?)?,
|
||||
muddy_roots_in: decoder.block_set(required(&placement, "muddy_roots_in")?)?,
|
||||
muddy_roots_provider: decoder
|
||||
.provider(required(&placement, "muddy_roots_provider")?)?,
|
||||
max_root_width: int_range(
|
||||
required(&placement, "max_root_width")?,
|
||||
"max_root_width",
|
||||
1,
|
||||
12,
|
||||
)?,
|
||||
max_root_length: int_range(
|
||||
required(&placement, "max_root_length")?,
|
||||
"max_root_length",
|
||||
1,
|
||||
64,
|
||||
)?,
|
||||
random_skew_chance: unit_float(
|
||||
required(&placement, "random_skew_chance")?,
|
||||
"random_skew_chance",
|
||||
)?,
|
||||
};
|
||||
Ok(Self {
|
||||
trunk_offset_y,
|
||||
root_provider,
|
||||
above,
|
||||
mangrove,
|
||||
})
|
||||
}
|
||||
fn can_place_root<W: FeatureWorld, R>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
position: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let state = read(run.world, position)?;
|
||||
Ok(tree.blocks.valid_tree_pos(state) || self.mangrove.can_grow_through.contains(&state))
|
||||
}
|
||||
fn waterlogged<W: FeatureWorld>(
|
||||
tree: &TreeFeature,
|
||||
world: &mut W,
|
||||
position: [i32; 3],
|
||||
state: BlockStateId,
|
||||
) -> TreeResult<BlockStateId, W::Error> {
|
||||
if tree.blocks.has(state, tb::WATERLOGGABLE) {
|
||||
let here = read(world, position)?;
|
||||
Ok(tree
|
||||
.blocks
|
||||
.waterlogged(state, tree.blocks.has(here, tb::WATER_FLUID)))
|
||||
} else {
|
||||
Ok(state)
|
||||
}
|
||||
}
|
||||
fn place_root<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
position: [i32; 3],
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let here = read(run.world, position)?;
|
||||
if self.mangrove.muddy_roots_in.contains(&here) {
|
||||
let state = sample_state(
|
||||
&self.mangrove.muddy_roots_provider,
|
||||
run.world,
|
||||
run.random,
|
||||
position,
|
||||
)?;
|
||||
let state = Self::waterlogged(tree, run.world, position, state)?;
|
||||
return run.set(Layer::Root, position, state);
|
||||
}
|
||||
if !self.can_place_root(run, tree, position)? {
|
||||
return Ok(());
|
||||
}
|
||||
let state = sample_state(&self.root_provider, run.world, run.random, position)?;
|
||||
let state = Self::waterlogged(tree, run.world, position, state)?;
|
||||
run.set(Layer::Root, position, state)?;
|
||||
if let Some((provider, chance)) = &self.above {
|
||||
let above = tb::offset(position, 0, 1, 0);
|
||||
if run.random.next_float() < *chance && tree.blocks.is_air(read(run.world, above)?) {
|
||||
let state = sample_state(provider, run.world, run.random, above)?;
|
||||
let state = Self::waterlogged(tree, run.world, above, state)?;
|
||||
run.set(Layer::Root, above, state)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn place_roots<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
origin: [i32; 3],
|
||||
trunk_origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let mut column = origin;
|
||||
while column[1] < trunk_origin[1] {
|
||||
if !self.can_place_root(run, tree, column)? {
|
||||
return Ok(false);
|
||||
}
|
||||
column[1] = column[1].wrapping_add(1);
|
||||
}
|
||||
let mut roots = vec![tb::offset(trunk_origin, 0, -1, 0)];
|
||||
for direction in tb::HORIZONTAL {
|
||||
let start = tb::relative(trunk_origin, direction, 1);
|
||||
let mut positions = Vec::new();
|
||||
if !self.simulate(run, tree, start, direction, trunk_origin, &mut positions, 0)? {
|
||||
return Ok(false);
|
||||
}
|
||||
roots.extend(positions);
|
||||
roots.push(start);
|
||||
}
|
||||
for root in roots {
|
||||
self.place_root(run, tree, root)?;
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn simulate<W: FeatureWorld, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
position: [i32; 3],
|
||||
direction: Direction,
|
||||
origin: [i32; 3],
|
||||
positions: &mut Vec<[i32; 3]>,
|
||||
layer: i32,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let max = self.mangrove.max_root_length;
|
||||
if layer == max || positions.len() as i64 > i64::from(max) {
|
||||
return Ok(false);
|
||||
}
|
||||
for next in self.potential(run.random, position, direction, origin)? {
|
||||
if self.can_place_root(run, tree, next)? {
|
||||
positions.push(next);
|
||||
if !self.simulate(run, tree, next, direction, origin, positions, layer + 1)? {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
#[allow(clippy::if_same_then_else)] // Native branch order controls random draws.
|
||||
fn potential<E>(
|
||||
&self,
|
||||
random: &mut impl RandomSource,
|
||||
position: [i32; 3],
|
||||
direction: Direction,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<Vec<[i32; 3]>, E> {
|
||||
let below = tb::offset(position, 0, -1, 0);
|
||||
let next_to = tb::relative(position, direction, 1);
|
||||
let width = tb::dist_manhattan(position, origin);
|
||||
let max = self.mangrove.max_root_width;
|
||||
let skew = self.mangrove.random_skew_chance;
|
||||
Ok(if width > max - 3 && width <= max {
|
||||
if random.next_float() < skew {
|
||||
vec![below, tb::offset(next_to, 0, -1, 0)]
|
||||
} else {
|
||||
vec![below]
|
||||
}
|
||||
} else if width > max {
|
||||
vec![below]
|
||||
} else if random.next_float() < skew {
|
||||
vec![below]
|
||||
} else if random.next_boolean() {
|
||||
vec![next_to]
|
||||
} else {
|
||||
vec![below]
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct TreeFeature {
|
||||
trunk_provider: BlockStateProvider,
|
||||
trunk_placer: TrunkPlacer,
|
||||
foliage_provider: BlockStateProvider,
|
||||
foliage_placer: FoliagePlacer,
|
||||
root_placer: Option<RootPlacer>,
|
||||
minimum_size: FeatureSize,
|
||||
min_clipped_height: Option<i32>,
|
||||
decorators: Vec<TreeDecorator>,
|
||||
ignore_vines: bool,
|
||||
below_trunk_provider: BlockStateProvider,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||
pub(crate) enum Layer {
|
||||
Root,
|
||||
Trunk,
|
||||
Foliage,
|
||||
Decoration,
|
||||
}
|
||||
#[derive(Default)]
|
||||
pub(crate) struct Sets {
|
||||
roots: PosSet,
|
||||
trunks: PosSet,
|
||||
foliage: PosSet,
|
||||
decorations: PosSet,
|
||||
}
|
||||
pub(crate) struct Run<'a, W, R> {
|
||||
pub world: &'a mut W,
|
||||
pub random: &'a mut R,
|
||||
sets: Sets,
|
||||
/// Fallen trees write decorations without recording them.
|
||||
track: bool,
|
||||
}
|
||||
impl<W: FeatureWorld, R> Run<'_, W, R> {
|
||||
pub(crate) fn set(
|
||||
&mut self,
|
||||
layer: Layer,
|
||||
position: [i32; 3],
|
||||
state: BlockStateId,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
if self.track {
|
||||
match layer {
|
||||
Layer::Root => self.sets.roots.insert(position),
|
||||
Layer::Trunk => self.sets.trunks.insert(position),
|
||||
Layer::Foliage => self.sets.foliage.insert(position),
|
||||
Layer::Decoration => self.sets.decorations.insert(position),
|
||||
};
|
||||
}
|
||||
write(self.world, position, state, 19)?;
|
||||
Ok(())
|
||||
}
|
||||
pub(crate) fn foliage_contains(&self, position: [i32; 3]) -> bool {
|
||||
self.sets.foliage.contains(position)
|
||||
}
|
||||
}
|
||||
|
||||
impl TreeFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
nested: &decorator::NestedDecoder<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:tree" {
|
||||
return Err(DecodeError::Field("tree feature type"));
|
||||
}
|
||||
let blocks = bindings.tree_blocks()?;
|
||||
let mut decoder = TreeDecoder {
|
||||
bindings,
|
||||
depth,
|
||||
remaining,
|
||||
};
|
||||
let trunk_provider = decoder.provider(required(&object, "trunk_provider")?)?;
|
||||
let trunk_placer = TrunkPlacer::decode(required(&object, "trunk_placer")?, &mut decoder)?;
|
||||
let foliage_provider = decoder.provider(required(&object, "foliage_provider")?)?;
|
||||
let foliage_placer =
|
||||
FoliagePlacer::decode(required(&object, "foliage_placer")?, &mut decoder)?;
|
||||
let root_placer = optional(&object, "root_placer")
|
||||
.map(|raw| RootPlacer::decode(raw, &mut decoder))
|
||||
.transpose()?;
|
||||
let (minimum_size, min_clipped_height) =
|
||||
FeatureSize::decode(required(&object, "minimum_size")?)?;
|
||||
let decorators = TreeDecorator::decode_list(
|
||||
required(&object, "decorators")?,
|
||||
&mut decoder,
|
||||
optional(&object, decorator::GROUND_FEATURE_KEY),
|
||||
nested,
|
||||
)?;
|
||||
let ignore_vines = optional(&object, "ignore_vines")
|
||||
.map(|raw| serde_json::from_str::<bool>(raw.get()))
|
||||
.transpose()?
|
||||
.unwrap_or(false);
|
||||
let below_trunk_provider = decoder.provider(required(&object, "below_trunk_provider")?)?;
|
||||
Ok(Self {
|
||||
trunk_provider,
|
||||
trunk_placer,
|
||||
foliage_provider,
|
||||
foliage_placer,
|
||||
root_placer,
|
||||
minimum_size,
|
||||
min_clipped_height,
|
||||
decorators,
|
||||
ignore_vines,
|
||||
below_trunk_provider,
|
||||
blocks,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
nested: &mut NestedPlacer<'_, W, R>,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let mut run = Run {
|
||||
world,
|
||||
random,
|
||||
sets: Sets::default(),
|
||||
track: true,
|
||||
};
|
||||
let result = self.do_place(&mut run, origin)?;
|
||||
if !result || (run.sets.trunks.is_empty() && run.sets.foliage.is_empty()) {
|
||||
return Ok(false);
|
||||
}
|
||||
if !self.decorators.is_empty() {
|
||||
let lists = decorator::Lists::new(
|
||||
run.sets.trunks.to_vec(),
|
||||
run.sets.foliage.to_vec(),
|
||||
run.sets.roots.to_vec(),
|
||||
);
|
||||
for decorator in &self.decorators {
|
||||
decorator.place(&mut run, &self.blocks, &lists, nested)?;
|
||||
}
|
||||
}
|
||||
let mut bounds: Option<([i32; 3], [i32; 3])> = None;
|
||||
for set in [
|
||||
&run.sets.roots,
|
||||
&run.sets.trunks,
|
||||
&run.sets.foliage,
|
||||
&run.sets.decorations,
|
||||
] {
|
||||
for p in set.to_vec() {
|
||||
bounds = Some(match bounds {
|
||||
None => (p, p),
|
||||
Some((lo, hi)) => (
|
||||
std::array::from_fn(|i| lo[i].min(p[i])),
|
||||
std::array::from_fn(|i| hi[i].max(p[i])),
|
||||
),
|
||||
});
|
||||
}
|
||||
}
|
||||
let Some((low, high)) = bounds else {
|
||||
return Ok(false);
|
||||
};
|
||||
let shape = update_leaves(&mut run, &self.blocks, low, high)?;
|
||||
update_shape_at_edge(run.world, &shape, low, 3)?;
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
fn do_place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let tree_height = self.trunk_placer.tree_height(run.random)?;
|
||||
let foliage_height = self
|
||||
.foliage_placer
|
||||
.foliage_height(run.random, tree_height)?;
|
||||
let trunk_height = tree_height.wrapping_sub(foliage_height);
|
||||
let leaf_radius = self
|
||||
.foliage_placer
|
||||
.foliage_radius(run.random, trunk_height)?;
|
||||
let trunk_origin = match &self.root_placer {
|
||||
Some(root) => tb::offset(origin, 0, root.trunk_offset_y.sample(run.random)?, 0),
|
||||
None => origin,
|
||||
};
|
||||
let min_y = origin[1].min(trunk_origin[1]);
|
||||
let max_y = origin[1]
|
||||
.max(trunk_origin[1])
|
||||
.wrapping_add(tree_height)
|
||||
.wrapping_add(1);
|
||||
let world_min = run.world.min_y().map_err(FeatureExecutionError::Query)?;
|
||||
let world_max = run.world.max_y().map_err(FeatureExecutionError::Query)?;
|
||||
if min_y < world_min.wrapping_add(1) || max_y > world_max.wrapping_add(1) {
|
||||
return Ok(false);
|
||||
}
|
||||
let clipped = self.max_free_tree_height(run, tree_height, trunk_origin)?;
|
||||
if clipped < tree_height && self.min_clipped_height.is_none_or(|min| clipped < min) {
|
||||
return Ok(false);
|
||||
}
|
||||
if let Some(root) = &self.root_placer {
|
||||
if !root.place_roots(run, self, origin, trunk_origin)? {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
let attachments = self
|
||||
.trunk_placer
|
||||
.place_trunk(run, self, clipped, trunk_origin)?;
|
||||
for attachment in attachments {
|
||||
self.foliage_placer.create_foliage(
|
||||
run,
|
||||
self,
|
||||
clipped,
|
||||
attachment,
|
||||
foliage_height,
|
||||
leaf_radius,
|
||||
)?;
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
fn max_free_tree_height<W: FeatureWorld, R>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
max_tree_height: i32,
|
||||
tree_pos: [i32; 3],
|
||||
) -> TreeResult<i32, W::Error> {
|
||||
let mut y = 0;
|
||||
while y <= max_tree_height.wrapping_add(1) {
|
||||
let r = self.minimum_size.size_at_height(max_tree_height, y);
|
||||
for x in -r..=r {
|
||||
for z in -r..=r {
|
||||
let p = tb::offset(tree_pos, x, y, z);
|
||||
let state = read(run.world, p)?;
|
||||
if !self.trunk_placer.is_free(&self.blocks, state)
|
||||
|| (!self.ignore_vines && self.blocks.has(state, tb::VINE))
|
||||
{
|
||||
return Ok(y - 2);
|
||||
}
|
||||
}
|
||||
}
|
||||
y += 1;
|
||||
}
|
||||
Ok(max_tree_height)
|
||||
}
|
||||
|
||||
/// FoliagePlacer.tryPlaceLeaf.
|
||||
pub(crate) fn try_place_leaf<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
position: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let here = read(run.world, position)?;
|
||||
if self.blocks.has(here, tb::PERSISTENT) || !self.blocks.valid_tree_pos(here) {
|
||||
return Ok(false);
|
||||
}
|
||||
let mut state = sample_state(&self.foliage_provider, run.world, run.random, position)?;
|
||||
if self.blocks.has(state, tb::WATERLOGGABLE) {
|
||||
let here = read(run.world, position)?;
|
||||
state = self
|
||||
.blocks
|
||||
.waterlogged(state, self.blocks.has(here, tb::WATER_SOURCE));
|
||||
}
|
||||
run.set(Layer::Foliage, position, state)?;
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
/// Voxel occupancy over the tree's bounding box.
|
||||
pub(crate) struct Shape {
|
||||
size: [i32; 3],
|
||||
bits: Vec<bool>,
|
||||
}
|
||||
impl Shape {
|
||||
fn new(size: [i32; 3]) -> Self {
|
||||
let len = size.iter().map(|v| *v as usize).product();
|
||||
Self {
|
||||
size,
|
||||
bits: vec![false; len],
|
||||
}
|
||||
}
|
||||
fn index(&self, [x, y, z]: [i32; 3]) -> usize {
|
||||
((x * self.size[1] + y) * self.size[2] + z) as usize
|
||||
}
|
||||
fn fill(&mut self, p: [i32; 3]) {
|
||||
let i = self.index(p);
|
||||
self.bits[i] = true;
|
||||
}
|
||||
fn full(&self, p: [i32; 3]) -> bool {
|
||||
p.iter()
|
||||
.zip(self.size)
|
||||
.all(|(v, size)| (0..size).contains(v))
|
||||
&& self.bits[self.index(p)]
|
||||
}
|
||||
}
|
||||
|
||||
const MAX_TREE_SPAN: i64 = 512;
|
||||
fn inside(low: [i32; 3], high: [i32; 3], p: [i32; 3]) -> bool {
|
||||
(0..3).all(|i| p[i] >= low[i] && p[i] <= high[i])
|
||||
}
|
||||
|
||||
/// TreeFeature.updateLeaves: native bucketed breadth-first distance pass.
|
||||
fn update_leaves<W: FeatureWorld, R>(
|
||||
run: &mut Run<'_, W, R>,
|
||||
blocks: &TreeBlocks,
|
||||
low: [i32; 3],
|
||||
high: [i32; 3],
|
||||
) -> TreeResult<Shape, W::Error> {
|
||||
let span: [i64; 3] = std::array::from_fn(|i| i64::from(high[i]) - i64::from(low[i]) + 1);
|
||||
if span.iter().any(|s| *s > MAX_TREE_SPAN) {
|
||||
return Err(FeatureExecutionError::WorkLimit);
|
||||
}
|
||||
let mut shape = Shape::new(span.map(|v| v as i32));
|
||||
let local = |p: [i32; 3]| -> [i32; 3] { std::array::from_fn(|i| p[i].wrapping_sub(low[i])) };
|
||||
let mut fixed = run.sets.decorations.to_vec();
|
||||
fixed.extend(run.sets.roots.to_vec());
|
||||
for p in fixed {
|
||||
if inside(low, high, p) {
|
||||
shape.fill(local(p));
|
||||
}
|
||||
}
|
||||
let mut to_check: [PosSet; 7] = Default::default();
|
||||
for p in run.sets.trunks.to_vec() {
|
||||
to_check[0].insert(p);
|
||||
}
|
||||
let mut smallest = 0usize;
|
||||
loop {
|
||||
while smallest >= 7 || !to_check[smallest].is_empty() {
|
||||
if smallest >= 7 {
|
||||
return Ok(shape);
|
||||
}
|
||||
let pos = to_check[smallest]
|
||||
.pop_first()
|
||||
.ok_or(FeatureExecutionError::InvalidState)?;
|
||||
if !inside(low, high, pos) {
|
||||
continue;
|
||||
}
|
||||
if smallest != 0 {
|
||||
let state = read(run.world, pos)?;
|
||||
let updated = blocks
|
||||
.with(state, "distance", &smallest.to_string())
|
||||
.ok_or(FeatureExecutionError::InvalidState)?;
|
||||
write(run.world, pos, updated, 19)?;
|
||||
}
|
||||
shape.fill(local(pos));
|
||||
for direction in Direction::ALL {
|
||||
let neighbor = tb::relative(pos, direction, 1);
|
||||
if !inside(low, high, neighbor) || shape.full(local(neighbor)) {
|
||||
continue;
|
||||
}
|
||||
let state = read(run.world, neighbor)?;
|
||||
if let Some(distance) = blocks.leaf_distance(state) {
|
||||
let next = distance.min(smallest as i32 + 1);
|
||||
if next < 7 {
|
||||
to_check[next as usize].insert(neighbor);
|
||||
smallest = smallest.min(next as usize);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
smallest += 1;
|
||||
}
|
||||
}
|
||||
|
||||
/// StructureTemplate.updateShapeAtEdge face traversal (DiscreteVoxelShape.forAllFaces).
|
||||
pub(crate) fn update_shape_at_edge<W: FeatureWorld + PlacementContext>(
|
||||
world: &mut W,
|
||||
shape: &Shape,
|
||||
start: [i32; 3],
|
||||
flags: i32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let [sx, sy, sz] = shape.size;
|
||||
// (c-axis, a size, b size, mapping (a, b, c) -> (x, y, z))
|
||||
type Map = fn(i32, i32, i32) -> [i32; 3];
|
||||
let passes: [(Direction, Direction, i32, i32, i32, Map); 3] = [
|
||||
(Direction::North, Direction::South, sx, sy, sz, |a, b, c| {
|
||||
[a, b, c]
|
||||
}),
|
||||
(Direction::Down, Direction::Up, sz, sx, sy, |a, b, c| {
|
||||
[b, c, a]
|
||||
}),
|
||||
(Direction::West, Direction::East, sy, sz, sx, |a, b, c| {
|
||||
[c, a, b]
|
||||
}),
|
||||
];
|
||||
for (negative, positive, a_size, b_size, c_size, map) in passes {
|
||||
for a in 0..a_size {
|
||||
for b in 0..b_size {
|
||||
let mut last = false;
|
||||
for c in 0..=c_size {
|
||||
let full = c != c_size && shape.full(map(a, b, c));
|
||||
let face = if !last && full {
|
||||
Some((negative, map(a, b, c)))
|
||||
} else if last && !full {
|
||||
Some((positive, map(a, b, c - 1)))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
if let Some((direction, local)) = face {
|
||||
let p = std::array::from_fn(|i| start[i].wrapping_add(local[i]));
|
||||
world
|
||||
.update_shape_at_face(p, direction, flags)
|
||||
.map_err(FeatureExecutionError::Query)?;
|
||||
}
|
||||
last = full;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,677 @@
|
||||
//! Tree decorators (TreeDecorator subclasses), in native random-draw order.
|
||||
use super::{
|
||||
Layer, NestedPlacer, Run, TreeDecoder, TreeResult, kind, read, sample_optional, sample_state,
|
||||
unit_float,
|
||||
};
|
||||
use crate::heightmap::HeightmapType;
|
||||
use crate::registry::BlockStateId;
|
||||
use crate::worldgen::{
|
||||
DecodeError, Object,
|
||||
feature::FeatureWorld,
|
||||
feature_graph::{FeatureDefinition, FeatureExecutionError},
|
||||
int_range, optional,
|
||||
placement::PlacementContext,
|
||||
required,
|
||||
state_provider::BlockStateProvider,
|
||||
tree_blocks::{self as tb, TreeBlocks},
|
||||
};
|
||||
use horizon_core::{geometry::Direction, random::RandomSource};
|
||||
use serde_json::value::RawValue;
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
/// Catalog-injected configured feature for the pale-moss ground patch, which
|
||||
/// vanilla looks up by registry key during decoration.
|
||||
pub(crate) const GROUND_FEATURE_KEY: &str = "horizon:pale_moss_patch";
|
||||
|
||||
/// Decorator context lists: set iteration order, stably sorted by Y.
|
||||
pub(crate) struct Lists {
|
||||
pub logs: Vec<[i32; 3]>,
|
||||
pub leaves: Vec<[i32; 3]>,
|
||||
pub roots: Vec<[i32; 3]>,
|
||||
}
|
||||
impl Lists {
|
||||
pub(crate) fn new(
|
||||
mut logs: Vec<[i32; 3]>,
|
||||
mut leaves: Vec<[i32; 3]>,
|
||||
mut roots: Vec<[i32; 3]>,
|
||||
) -> Self {
|
||||
logs.sort_by_key(|p| p[1]);
|
||||
leaves.sort_by_key(|p| p[1]);
|
||||
roots.sort_by_key(|p| p[1]);
|
||||
Self {
|
||||
logs,
|
||||
leaves,
|
||||
roots,
|
||||
}
|
||||
}
|
||||
/// TreeFeature.getLowestTrunkOrRootOfTree.
|
||||
fn lowest(&self) -> Vec<[i32; 3]> {
|
||||
if self.roots.is_empty() {
|
||||
self.logs.clone()
|
||||
} else if !self.logs.is_empty() && self.roots[0][1] == self.logs[0][1] {
|
||||
let mut all = self.logs.clone();
|
||||
all.extend(&self.roots);
|
||||
all
|
||||
} else {
|
||||
self.roots.clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) enum TreeDecorator {
|
||||
TrunkVine,
|
||||
LeaveVine(f32),
|
||||
Cocoa(f32),
|
||||
Beehive(f32),
|
||||
AlterGround(BlockStateProvider),
|
||||
AttachedToLeaves {
|
||||
probability: f32,
|
||||
exclusion_xz: i32,
|
||||
exclusion_y: i32,
|
||||
provider: BlockStateProvider,
|
||||
required_empty: i32,
|
||||
directions: Vec<Direction>,
|
||||
},
|
||||
AttachedToLogs {
|
||||
probability: f32,
|
||||
provider: BlockStateProvider,
|
||||
directions: Vec<Direction>,
|
||||
},
|
||||
CreakingHeart(f32),
|
||||
PaleMoss {
|
||||
leaves: f32,
|
||||
trunk: f32,
|
||||
ground: f32,
|
||||
patch: Option<Box<FeatureDefinition>>,
|
||||
},
|
||||
PlaceOnGround {
|
||||
tries: i32,
|
||||
radius: i32,
|
||||
height: i32,
|
||||
provider: BlockStateProvider,
|
||||
},
|
||||
ShelfMushroom(f32),
|
||||
}
|
||||
|
||||
fn directions(raw: &RawValue) -> Result<Vec<Direction>, DecodeError> {
|
||||
let names: Vec<String> = serde_json::from_str(raw.get())?;
|
||||
if names.is_empty() || names.len() > 64 {
|
||||
return Err(DecodeError::Field("decorator directions"));
|
||||
}
|
||||
names.iter().map(|n| tb::decode_direction(n)).collect()
|
||||
}
|
||||
|
||||
pub(crate) type NestedDecoder<'a> =
|
||||
dyn Fn(&str, usize, &mut usize) -> Result<FeatureDefinition, DecodeError> + 'a;
|
||||
|
||||
impl TreeDecorator {
|
||||
pub(crate) fn decode_list(
|
||||
raw: &RawValue,
|
||||
decoder: &mut TreeDecoder<'_, '_>,
|
||||
ground: Option<&RawValue>,
|
||||
nested: &NestedDecoder<'_>,
|
||||
) -> Result<Vec<Self>, DecodeError> {
|
||||
let values: Vec<Box<RawValue>> = serde_json::from_str(raw.get())?;
|
||||
if values.len() > 256 {
|
||||
return Err(DecodeError::Field("tree decorator count"));
|
||||
}
|
||||
values
|
||||
.iter()
|
||||
.map(|raw| Self::decode(raw, decoder, ground, nested))
|
||||
.collect()
|
||||
}
|
||||
fn decode(
|
||||
raw: &RawValue,
|
||||
decoder: &mut TreeDecoder<'_, '_>,
|
||||
ground: Option<&RawValue>,
|
||||
nested: &NestedDecoder<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(raw.get())?;
|
||||
let probability = || unit_float(required(&object, "probability")?, "probability");
|
||||
Ok(match kind(&object)?.as_str() {
|
||||
"minecraft:trunk_vine" => Self::TrunkVine,
|
||||
"minecraft:leave_vine" => Self::LeaveVine(probability()?),
|
||||
"minecraft:cocoa" => Self::Cocoa(probability()?),
|
||||
"minecraft:beehive" => Self::Beehive(probability()?),
|
||||
"minecraft:creaking_heart" => Self::CreakingHeart(probability()?),
|
||||
"minecraft:shelf_mushroom" => Self::ShelfMushroom(probability()?),
|
||||
"minecraft:alter_ground" => {
|
||||
Self::AlterGround(decoder.provider(required(&object, "provider")?)?)
|
||||
}
|
||||
"minecraft:attached_to_leaves" => Self::AttachedToLeaves {
|
||||
probability: probability()?,
|
||||
exclusion_xz: int_range(
|
||||
required(&object, "exclusion_radius_xz")?,
|
||||
"exclusion_radius_xz",
|
||||
0,
|
||||
16,
|
||||
)?,
|
||||
exclusion_y: int_range(
|
||||
required(&object, "exclusion_radius_y")?,
|
||||
"exclusion_radius_y",
|
||||
0,
|
||||
16,
|
||||
)?,
|
||||
provider: decoder.provider(required(&object, "block_provider")?)?,
|
||||
required_empty: int_range(
|
||||
required(&object, "required_empty_blocks")?,
|
||||
"required_empty_blocks",
|
||||
1,
|
||||
16,
|
||||
)?,
|
||||
directions: directions(required(&object, "directions")?)?,
|
||||
},
|
||||
"minecraft:attached_to_logs" => Self::AttachedToLogs {
|
||||
probability: probability()?,
|
||||
provider: decoder.provider(required(&object, "block_provider")?)?,
|
||||
directions: directions(required(&object, "directions")?)?,
|
||||
},
|
||||
"minecraft:pale_moss" => Self::PaleMoss {
|
||||
leaves: unit_float(
|
||||
required(&object, "leaves_probability")?,
|
||||
"leaves_probability",
|
||||
)?,
|
||||
trunk: unit_float(required(&object, "trunk_probability")?, "trunk_probability")?,
|
||||
ground: unit_float(
|
||||
required(&object, "ground_probability")?,
|
||||
"ground_probability",
|
||||
)?,
|
||||
patch: ground
|
||||
.map(|raw| nested(raw.get(), decoder.depth + 1, decoder.remaining))
|
||||
.transpose()?
|
||||
.map(Box::new),
|
||||
},
|
||||
"minecraft:place_on_ground" => Self::PlaceOnGround {
|
||||
tries: optional(&object, "tries")
|
||||
.map(|raw| int_range(raw, "tries", 1, i32::MAX))
|
||||
.transpose()?
|
||||
.unwrap_or(128),
|
||||
radius: optional(&object, "radius")
|
||||
.map(|raw| int_range(raw, "radius", 0, i32::MAX))
|
||||
.transpose()?
|
||||
.unwrap_or(2),
|
||||
height: optional(&object, "height")
|
||||
.map(|raw| int_range(raw, "height", 0, i32::MAX))
|
||||
.transpose()?
|
||||
.unwrap_or(1),
|
||||
provider: decoder.provider(required(&object, "block_state_provider")?)?,
|
||||
},
|
||||
_ => return Err(DecodeError::Field("tree decorator type")),
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
blocks: &TreeBlocks,
|
||||
lists: &Lists,
|
||||
nested: &mut NestedPlacer<'_, W, R>,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let mut d = Decorate { run, blocks };
|
||||
match self {
|
||||
Self::TrunkVine => {
|
||||
for &pos in &lists.logs {
|
||||
for (direction, face) in [
|
||||
(Direction::West, "east"),
|
||||
(Direction::East, "west"),
|
||||
(Direction::North, "south"),
|
||||
(Direction::South, "north"),
|
||||
] {
|
||||
if d.run.random.next_int_bound(3)? > 0 {
|
||||
let p = tb::relative(pos, direction, 1);
|
||||
if d.is_air(p)? {
|
||||
d.place_vine(p, face)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Self::LeaveVine(probability) => {
|
||||
for &pos in &lists.leaves {
|
||||
for (direction, face) in [
|
||||
(Direction::West, "east"),
|
||||
(Direction::East, "west"),
|
||||
(Direction::North, "south"),
|
||||
(Direction::South, "north"),
|
||||
] {
|
||||
if d.run.random.next_float() < *probability {
|
||||
let p = tb::relative(pos, direction, 1);
|
||||
if d.is_air(p)? {
|
||||
d.place_vine(p, face)?;
|
||||
let mut below = tb::offset(p, 0, -1, 0);
|
||||
let mut remaining = 4;
|
||||
while d.is_air(below)? && remaining > 0 {
|
||||
d.place_vine(below, face)?;
|
||||
below = tb::offset(below, 0, -1, 0);
|
||||
remaining -= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Self::Cocoa(probability) => {
|
||||
if d.run.random.next_float() >= *probability {
|
||||
return Ok(());
|
||||
}
|
||||
let Some(first) = lists.logs.first() else {
|
||||
return Ok(());
|
||||
};
|
||||
let tree_y = first[1];
|
||||
for &pos in lists.logs.iter().filter(|p| p[1].wrapping_sub(tree_y) <= 2) {
|
||||
for direction in tb::HORIZONTAL {
|
||||
if d.run.random.next_float() <= 0.25 {
|
||||
let n = direction.opposite().normal();
|
||||
let p = tb::offset(pos, n[0], 0, n[2]);
|
||||
if d.is_air(p)? {
|
||||
let age = d.run.random.next_int_bound(3)?;
|
||||
let state = d.default("minecraft:cocoa")?;
|
||||
let state = d.with(state, "age", &age.to_string())?;
|
||||
let state =
|
||||
d.with(state, "facing", tb::direction_name(direction))?;
|
||||
d.set(p, state)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Self::Beehive(probability) => d.beehive(lists, *probability)?,
|
||||
Self::AlterGround(provider) => {
|
||||
let positions = lists.lowest();
|
||||
let Some(first) = positions.first() else {
|
||||
return Ok(());
|
||||
};
|
||||
let min_y = first[1];
|
||||
for &pos in positions.iter().filter(|p| p[1] == min_y) {
|
||||
d.circle(provider, tb::offset(pos, -1, 0, -1))?;
|
||||
d.circle(provider, tb::offset(pos, 2, 0, -1))?;
|
||||
d.circle(provider, tb::offset(pos, -1, 0, 2))?;
|
||||
d.circle(provider, tb::offset(pos, 2, 0, 2))?;
|
||||
for _ in 0..5 {
|
||||
let placement = d.run.random.next_int_bound(64)?;
|
||||
let (xx, zz) = (placement % 8, placement / 8);
|
||||
if xx == 0 || xx == 7 || zz == 0 || zz == 7 {
|
||||
d.circle(provider, tb::offset(pos, -3 + xx, 0, -3 + zz))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Self::AttachedToLeaves {
|
||||
probability,
|
||||
exclusion_xz,
|
||||
exclusion_y,
|
||||
provider,
|
||||
required_empty,
|
||||
directions,
|
||||
} => {
|
||||
let mut blacklist = BTreeSet::new();
|
||||
let mut leaves = lists.leaves.clone();
|
||||
tb::shuffle(&mut leaves, d.run.random)?;
|
||||
for leaf in leaves {
|
||||
let direction =
|
||||
directions[d.run.random.next_int_bound(directions.len() as i32)? as usize];
|
||||
let p = tb::relative(leaf, direction, 1);
|
||||
if blacklist.contains(&p) || d.run.random.next_float() >= *probability {
|
||||
continue;
|
||||
}
|
||||
let mut empty = true;
|
||||
for i in 1..=*required_empty {
|
||||
if !d.is_air(tb::relative(leaf, direction, i))? {
|
||||
empty = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if !empty {
|
||||
continue;
|
||||
}
|
||||
for dx in -exclusion_xz..=*exclusion_xz {
|
||||
for dy in -exclusion_y..=*exclusion_y {
|
||||
for dz in -exclusion_xz..=*exclusion_xz {
|
||||
blacklist.insert(tb::offset(p, dx, dy, dz));
|
||||
}
|
||||
}
|
||||
}
|
||||
let state = sample_state(provider, d.run.world, d.run.random, p)?;
|
||||
d.set(p, state)?;
|
||||
}
|
||||
}
|
||||
Self::AttachedToLogs {
|
||||
probability,
|
||||
provider,
|
||||
directions,
|
||||
} => {
|
||||
let mut logs = lists.logs.clone();
|
||||
tb::shuffle(&mut logs, d.run.random)?;
|
||||
for log in logs {
|
||||
let direction =
|
||||
directions[d.run.random.next_int_bound(directions.len() as i32)? as usize];
|
||||
let p = tb::relative(log, direction, 1);
|
||||
if d.run.random.next_float() <= *probability && d.is_air(p)? {
|
||||
let state = sample_state(provider, d.run.world, d.run.random, p)?;
|
||||
d.set(p, state)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Self::CreakingHeart(probability) => {
|
||||
if lists.logs.is_empty() || d.run.random.next_float() >= *probability {
|
||||
return Ok(());
|
||||
}
|
||||
let mut candidates = lists.logs.clone();
|
||||
tb::shuffle(&mut candidates, d.run.random)?;
|
||||
for pos in candidates {
|
||||
let mut enclosed = true;
|
||||
for direction in Direction::ALL {
|
||||
let state = read(d.run.world, tb::relative(pos, direction, 1))?;
|
||||
if !blocks.has(state, tb::LOGS) {
|
||||
enclosed = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if enclosed {
|
||||
let state = d.default("minecraft:creaking_heart")?;
|
||||
let state = d.with(state, "creaking_heart_state", "dormant")?;
|
||||
let state = d.with(state, "natural", "true")?;
|
||||
d.set(pos, state)?;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
Self::PaleMoss {
|
||||
leaves,
|
||||
trunk,
|
||||
ground,
|
||||
patch,
|
||||
} => {
|
||||
let mut logs = lists.logs.clone();
|
||||
tb::shuffle(&mut logs, d.run.random)?;
|
||||
let Some(origin) = logs
|
||||
.iter()
|
||||
.copied()
|
||||
.reduce(|best, p| if p[1] < best[1] { p } else { best })
|
||||
else {
|
||||
return Ok(());
|
||||
};
|
||||
if d.run.random.next_float() < *ground {
|
||||
if let Some(patch) = patch {
|
||||
nested(
|
||||
patch,
|
||||
d.run.world,
|
||||
d.run.random,
|
||||
tb::offset(origin, 0, 1, 0),
|
||||
)?;
|
||||
}
|
||||
}
|
||||
for (positions, chance) in [(&lists.logs, *trunk), (&lists.leaves, *leaves)] {
|
||||
for &pos in positions {
|
||||
if d.run.random.next_float() < chance {
|
||||
let down = tb::offset(pos, 0, -1, 0);
|
||||
if d.is_air(down)? {
|
||||
d.moss_hanger(down)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Self::PlaceOnGround {
|
||||
tries,
|
||||
radius,
|
||||
height,
|
||||
provider,
|
||||
} => {
|
||||
let positions = lists.lowest();
|
||||
let Some(&origin) = positions.first() else {
|
||||
return Ok(());
|
||||
};
|
||||
let min_y = origin[1];
|
||||
let (mut min_x, mut max_x, mut min_z, mut max_z) =
|
||||
(origin[0], origin[0], origin[2], origin[2]);
|
||||
for p in positions.iter().filter(|p| p[1] == min_y) {
|
||||
min_x = min_x.min(p[0]);
|
||||
max_x = max_x.max(p[0]);
|
||||
min_z = min_z.min(p[2]);
|
||||
max_z = max_z.max(p[2]);
|
||||
}
|
||||
let low = [
|
||||
min_x.wrapping_sub(*radius),
|
||||
min_y.wrapping_sub(*height),
|
||||
min_z.wrapping_sub(*radius),
|
||||
];
|
||||
let high = [
|
||||
max_x.wrapping_add(*radius),
|
||||
min_y.wrapping_add(*height),
|
||||
max_z.wrapping_add(*radius),
|
||||
];
|
||||
for _ in 0..*tries {
|
||||
let p = [
|
||||
d.run.random.next_int_between_inclusive(low[0], high[0])?,
|
||||
d.run.random.next_int_between_inclusive(low[1], high[1])?,
|
||||
d.run.random.next_int_between_inclusive(low[2], high[2])?,
|
||||
];
|
||||
let above = tb::offset(p, 0, 1, 0);
|
||||
let above_state = read(d.run.world, above)?;
|
||||
if !blocks.has(above_state, tb::AIR | tb::VINE) {
|
||||
continue;
|
||||
}
|
||||
if !blocks.has(read(d.run.world, p)?, tb::SOLID_RENDER) {
|
||||
continue;
|
||||
}
|
||||
let surface = d
|
||||
.run
|
||||
.world
|
||||
.height(HeightmapType::MotionBlockingNoLeaves, p[0], p[2])
|
||||
.map_err(FeatureExecutionError::Query)?;
|
||||
if surface <= above[1] {
|
||||
let state = sample_state(provider, d.run.world, d.run.random, above)?;
|
||||
d.set(above, state)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Self::ShelfMushroom(probability) => d.shelf_mushroom(lists, *probability)?,
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
struct Decorate<'a, 'b, 'w, W, R> {
|
||||
run: &'a mut Run<'w, W, R>,
|
||||
blocks: &'b TreeBlocks,
|
||||
}
|
||||
impl<W: FeatureWorld + PlacementContext, R: RandomSource> Decorate<'_, '_, '_, W, R> {
|
||||
fn is_air(&mut self, p: [i32; 3]) -> TreeResult<bool, W::Error> {
|
||||
Ok(self.blocks.is_air(read(self.run.world, p)?))
|
||||
}
|
||||
fn has(&mut self, p: [i32; 3], flag: u32) -> TreeResult<bool, W::Error> {
|
||||
Ok(self.blocks.has(read(self.run.world, p)?, flag))
|
||||
}
|
||||
fn set(&mut self, p: [i32; 3], state: BlockStateId) -> TreeResult<(), W::Error> {
|
||||
self.run.set(Layer::Decoration, p, state)
|
||||
}
|
||||
fn default(&self, name: &str) -> TreeResult<BlockStateId, W::Error> {
|
||||
self.blocks
|
||||
.default_state(name)
|
||||
.ok_or(FeatureExecutionError::InvalidState)
|
||||
}
|
||||
fn with(
|
||||
&self,
|
||||
state: BlockStateId,
|
||||
name: &str,
|
||||
value: &str,
|
||||
) -> TreeResult<BlockStateId, W::Error> {
|
||||
self.blocks
|
||||
.with(state, name, value)
|
||||
.ok_or(FeatureExecutionError::InvalidState)
|
||||
}
|
||||
fn place_vine(&mut self, p: [i32; 3], face: &str) -> TreeResult<(), W::Error> {
|
||||
let vine = self.default("minecraft:vine")?;
|
||||
let state = self.with(vine, face, "true")?;
|
||||
self.set(p, state)
|
||||
}
|
||||
fn circle(
|
||||
&mut self,
|
||||
provider: &BlockStateProvider,
|
||||
center: [i32; 3],
|
||||
) -> TreeResult<(), W::Error> {
|
||||
for xx in -2i32..=2 {
|
||||
for zz in -2i32..=2 {
|
||||
if xx.abs() != 2 || zz.abs() != 2 {
|
||||
let column = tb::offset(center, xx, 0, zz);
|
||||
for dy in (-3..=2).rev() {
|
||||
let cursor = tb::offset(column, 0, dy, 0);
|
||||
if let Some(state) =
|
||||
sample_optional(provider, self.run.world, self.run.random, cursor)?
|
||||
{
|
||||
self.set(cursor, state)?;
|
||||
break;
|
||||
}
|
||||
if !self.is_air(cursor)? && dy < 0 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn moss_hanger(&mut self, mut p: [i32; 3]) -> TreeResult<(), W::Error> {
|
||||
let moss = self.default("minecraft:pale_hanging_moss")?;
|
||||
let middle = self.with(moss, "tip", "false")?;
|
||||
let tip = self.with(moss, "tip", "true")?;
|
||||
while self.is_air(tb::offset(p, 0, -1, 0))? && self.run.random.next_float() >= 0.5 {
|
||||
self.set(p, middle)?;
|
||||
p = tb::offset(p, 0, -1, 0);
|
||||
}
|
||||
self.set(p, tip)
|
||||
}
|
||||
fn beehive(&mut self, lists: &Lists, probability: f32) -> TreeResult<(), W::Error> {
|
||||
let (Some(first_log), Some(last_log)) = (lists.logs.first(), lists.logs.last()) else {
|
||||
return Ok(());
|
||||
};
|
||||
if self.run.random.next_float() >= probability {
|
||||
return Ok(());
|
||||
}
|
||||
let hive_y = match lists.leaves.first() {
|
||||
Some(leaf) => (leaf[1] - 1).max(first_log[1] + 1),
|
||||
None => (first_log[1] + 1 + self.run.random.next_int_bound(3)?).min(last_log[1]),
|
||||
};
|
||||
let mut placements: Vec<[i32; 3]> = lists
|
||||
.logs
|
||||
.iter()
|
||||
.filter(|p| p[1] == hive_y)
|
||||
.flat_map(|p| {
|
||||
[Direction::East, Direction::South, Direction::West].map(|d| tb::relative(*p, d, 1))
|
||||
})
|
||||
.collect();
|
||||
if placements.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
tb::shuffle(&mut placements, self.run.random)?;
|
||||
for p in placements {
|
||||
if self.is_air(p)? && self.is_air(tb::relative(p, Direction::South, 1))? {
|
||||
let nest = self.default("minecraft:bee_nest")?;
|
||||
let nest = self.with(nest, "facing", "south")?;
|
||||
self.set(p, nest)?;
|
||||
// Occupants exist only when the write produced the nest block entity.
|
||||
if read(self.run.world, p)? == nest {
|
||||
let count = 2 + self.run.random.next_int_bound(2)?;
|
||||
let mut ticks = Vec::with_capacity(count as usize);
|
||||
for _ in 0..count {
|
||||
ticks.push(self.run.random.next_int_bound(599)?);
|
||||
}
|
||||
self.run
|
||||
.world
|
||||
.store_beehive_occupants(p, &ticks)
|
||||
.map_err(FeatureExecutionError::Query)?;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn shelf_mushroom(&mut self, lists: &Lists, probability: f32) -> TreeResult<(), W::Error> {
|
||||
if self.run.random.next_float() >= probability {
|
||||
return Ok(());
|
||||
}
|
||||
let (Some(first), Some(last)) = (lists.logs.first(), lists.logs.last()) else {
|
||||
return Ok(());
|
||||
};
|
||||
if first[1] == last[1] {
|
||||
let facings = if first[0] != last[0] {
|
||||
[Direction::North, Direction::South]
|
||||
} else {
|
||||
[Direction::East, Direction::West]
|
||||
};
|
||||
for &log in &lists.logs {
|
||||
for facing in facings {
|
||||
if self.run.random.next_float() <= 0.25 {
|
||||
let p = mushroom_pos(log, facing);
|
||||
if self.mushroom_replaceable(p)?
|
||||
&& !self.adjacent_mushroom(p)?
|
||||
&& !self.adjacent_mushroom(log)?
|
||||
{
|
||||
self.place_mushroom(p, facing)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let a = tb::HORIZONTAL[self.run.random.next_int_bound(4)? as usize];
|
||||
let facings = [a, tb::clockwise(a)];
|
||||
let base = first[1];
|
||||
for &log in &lists.logs {
|
||||
let dy = log[1].wrapping_sub(base);
|
||||
if !(1..=4).contains(&dy) {
|
||||
continue;
|
||||
}
|
||||
for facing in facings {
|
||||
if self.run.random.next_float() <= 0.25 {
|
||||
let p = mushroom_pos(log, facing);
|
||||
if self.mushroom_replaceable(p)?
|
||||
&& !self.has(tb::offset(p, 0, -1, 0), tb::SHELF_MUSHROOM)?
|
||||
{
|
||||
self.place_mushroom(p, facing)?;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn mushroom_replaceable(&mut self, p: [i32; 3]) -> TreeResult<bool, W::Error> {
|
||||
if !self.has(p, tb::REPLACEABLE)? {
|
||||
return Ok(false);
|
||||
}
|
||||
for q in [
|
||||
p,
|
||||
tb::offset(p, 1, 0, 0),
|
||||
tb::offset(p, -1, 0, 0),
|
||||
tb::offset(p, 0, 0, -1),
|
||||
tb::offset(p, 0, 0, 1),
|
||||
] {
|
||||
if self.has(q, tb::WATER_BLOCK)? {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
fn adjacent_mushroom(&mut self, p: [i32; 3]) -> TreeResult<bool, W::Error> {
|
||||
for direction in tb::HORIZONTAL {
|
||||
if self.has(tb::relative(p, direction, 1), tb::SHELF_MUSHROOM)? {
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
fn place_mushroom(&mut self, p: [i32; 3], facing: Direction) -> TreeResult<(), W::Error> {
|
||||
let age = self.run.random.next_int_bound(2)?;
|
||||
let state = self.default("minecraft:shelf_mushroom")?;
|
||||
let state = self.with(state, "age", &age.to_string())?;
|
||||
let state = self.with(state, "facing", tb::direction_name(facing))?;
|
||||
self.set(p, state)
|
||||
}
|
||||
}
|
||||
fn mushroom_pos(log: [i32; 3], facing: Direction) -> [i32; 3] {
|
||||
let n = facing.normal();
|
||||
tb::offset(log, n[0], 0, n[2])
|
||||
}
|
||||
@@ -0,0 +1,182 @@
|
||||
//! `minecraft:fallen_tree`: a stump and an optional fallen log with decorators.
|
||||
use super::{
|
||||
NestedPlacer, Run, Sets, TreeDecoder, TreeResult, decorator::Lists, decorator::NestedDecoder,
|
||||
decorator::TreeDecorator, kind, read, sample_state, write,
|
||||
};
|
||||
use crate::worldgen::{
|
||||
DecodeError, Object,
|
||||
block_feature::FeatureBlockBindings,
|
||||
feature::FeatureWorld,
|
||||
feature_graph::FeatureExecutionError,
|
||||
placement::PlacementContext,
|
||||
required,
|
||||
state_provider::BlockStateProvider,
|
||||
tree_blocks::{self as tb, Axis, PosSet, TreeBlocks},
|
||||
value_provider::IntProvider,
|
||||
};
|
||||
use horizon_core::{geometry::Direction, random::RandomSource};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct FallenTreeFeature {
|
||||
trunk_provider: BlockStateProvider,
|
||||
log_length: IntProvider,
|
||||
stump_decorators: Vec<TreeDecorator>,
|
||||
log_decorators: Vec<TreeDecorator>,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
impl FallenTreeFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
nested: &NestedDecoder<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:fallen_tree" {
|
||||
return Err(DecodeError::Field("fallen tree feature type"));
|
||||
}
|
||||
let blocks = bindings.tree_blocks()?;
|
||||
let mut decoder = TreeDecoder {
|
||||
bindings,
|
||||
depth,
|
||||
remaining,
|
||||
};
|
||||
Ok(Self {
|
||||
trunk_provider: decoder.provider(required(&object, "trunk_provider")?)?,
|
||||
log_length: decoder.int_provider(required(&object, "log_length")?, 0, 16)?,
|
||||
stump_decorators: TreeDecorator::decode_list(
|
||||
required(&object, "stump_decorators")?,
|
||||
&mut decoder,
|
||||
None,
|
||||
nested,
|
||||
)?,
|
||||
log_decorators: TreeDecorator::decode_list(
|
||||
required(&object, "log_decorators")?,
|
||||
&mut decoder,
|
||||
None,
|
||||
nested,
|
||||
)?,
|
||||
blocks,
|
||||
})
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
nested: &mut NestedPlacer<'_, W, R>,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let mut run = Run {
|
||||
world,
|
||||
random,
|
||||
sets: Sets::default(),
|
||||
track: false,
|
||||
};
|
||||
let stump = self.place_log(&mut run, origin, None)?;
|
||||
self.decorate(&mut run, &[stump], &self.stump_decorators, nested)?;
|
||||
let direction = tb::HORIZONTAL[run.random.next_int_bound(4)? as usize];
|
||||
let length = self.log_length.sample(run.random)? - 2;
|
||||
let mut start = tb::relative(origin, direction, 2 + run.random.next_int_bound(2)?);
|
||||
start = tb::offset(start, 0, 1, 0);
|
||||
for _ in 0..6 {
|
||||
if self.may_place_on(&mut run, start)? {
|
||||
break;
|
||||
}
|
||||
start = tb::offset(start, 0, -1, 0);
|
||||
}
|
||||
if self.can_place_log(&mut run, length, start, direction)? {
|
||||
let mut logs = PosSet::default();
|
||||
let mut p = start;
|
||||
for _ in 0..length {
|
||||
logs.insert(self.place_log(&mut run, p, Some(Axis::of(direction)))?);
|
||||
p = tb::relative(p, direction, 1);
|
||||
}
|
||||
self.decorate(&mut run, &logs.to_vec(), &self.log_decorators, nested)?;
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
fn decorate<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
logs: &[[i32; 3]],
|
||||
decorators: &[TreeDecorator],
|
||||
nested: &mut NestedPlacer<'_, W, R>,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
if decorators.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let lists = Lists::new(logs.to_vec(), vec![], vec![]);
|
||||
for decorator in decorators {
|
||||
decorator.place(run, &self.blocks, &lists, nested)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn place_log<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
p: [i32; 3],
|
||||
axis: Option<Axis>,
|
||||
) -> TreeResult<[i32; 3], W::Error> {
|
||||
let mut state = sample_state(&self.trunk_provider, run.world, run.random, p)?;
|
||||
if let Some(axis) = axis {
|
||||
state = self.blocks.try_axis(state, axis);
|
||||
}
|
||||
write(run.world, p, state, 3)?;
|
||||
// Feature.markAboveForPostProcessing.
|
||||
let mut above = p;
|
||||
for _ in 0..2 {
|
||||
above = tb::offset(above, 0, 1, 0);
|
||||
if self.blocks.is_air(read(run.world, above)?) {
|
||||
break;
|
||||
}
|
||||
run.world
|
||||
.mark_postprocessing(above)
|
||||
.map_err(FeatureExecutionError::Query)?;
|
||||
}
|
||||
Ok(p)
|
||||
}
|
||||
fn over_solid_ground<W: FeatureWorld + PlacementContext, R>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
p: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let below = read(run.world, tb::offset(p, 0, -1, 0))?;
|
||||
run.world
|
||||
.state_face_sturdy(below, p, Direction::Up)
|
||||
.map_err(FeatureExecutionError::Query)
|
||||
}
|
||||
fn may_place_on<W: FeatureWorld + PlacementContext, R>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
p: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
Ok(self.blocks.valid_tree_pos(read(run.world, p)?) && self.over_solid_ground(run, p)?)
|
||||
}
|
||||
fn can_place_log<W: FeatureWorld + PlacementContext, R>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
length: i32,
|
||||
start: [i32; 3],
|
||||
direction: Direction,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let mut gap = 0;
|
||||
let mut p = start;
|
||||
for _ in 0..length {
|
||||
if !self.blocks.valid_tree_pos(read(run.world, p)?) {
|
||||
return Ok(false);
|
||||
}
|
||||
if !self.over_solid_ground(run, p)? {
|
||||
gap += 1;
|
||||
if gap > 2 {
|
||||
return Ok(false);
|
||||
}
|
||||
} else {
|
||||
gap = 0;
|
||||
}
|
||||
p = tb::relative(p, direction, 1);
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,631 @@
|
||||
//! Foliage placers (FoliagePlacer subclasses), in native random-draw order.
|
||||
use super::{
|
||||
Layer, Run, TreeDecoder, TreeFeature, TreeResult, kind, read, sample_state, unit_float,
|
||||
};
|
||||
use crate::worldgen::{
|
||||
DecodeError, Object,
|
||||
feature::FeatureWorld,
|
||||
int_range,
|
||||
placement::PlacementContext,
|
||||
required,
|
||||
tree_blocks::{self as tb, Axis},
|
||||
value_provider::IntProvider,
|
||||
};
|
||||
use horizon_core::{geometry::Direction, random::RandomSource};
|
||||
use serde_json::value::RawValue;
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub(crate) struct FoliageAttachment {
|
||||
pub pos: [i32; 3],
|
||||
pub radius_offset: i32,
|
||||
pub height_offset: i32,
|
||||
size: [i32; 2],
|
||||
}
|
||||
impl FoliageAttachment {
|
||||
pub(crate) fn new(pos: [i32; 3], radius_offset: i32, double_trunk: bool) -> Self {
|
||||
let size = if double_trunk { 2 } else { 1 };
|
||||
Self {
|
||||
pos,
|
||||
radius_offset,
|
||||
height_offset: 0,
|
||||
size: [size; 2],
|
||||
}
|
||||
}
|
||||
fn double_trunk(&self) -> bool {
|
||||
self.size == [2, 2]
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum Kind {
|
||||
Blob(i32),
|
||||
Fancy(i32),
|
||||
Bush(i32),
|
||||
Acacia,
|
||||
Spruce(IntProvider),
|
||||
Pine(IntProvider),
|
||||
MegaPine(IntProvider),
|
||||
MegaJungle(i32),
|
||||
DarkOak,
|
||||
RandomSpread {
|
||||
foliage_height: IntProvider,
|
||||
attempts: i32,
|
||||
},
|
||||
Cherry {
|
||||
height: IntProvider,
|
||||
wide_bottom_hole: f32,
|
||||
corner_hole: f32,
|
||||
hanging: f32,
|
||||
hanging_extension: f32,
|
||||
},
|
||||
Poplar {
|
||||
height: IntProvider,
|
||||
side_hole: f32,
|
||||
},
|
||||
}
|
||||
#[derive(Clone, Debug)]
|
||||
pub(super) struct FoliagePlacer {
|
||||
radius: IntProvider,
|
||||
offset: IntProvider,
|
||||
kind: Kind,
|
||||
}
|
||||
|
||||
fn abs(v: i32) -> i32 {
|
||||
v.wrapping_abs()
|
||||
}
|
||||
|
||||
impl FoliagePlacer {
|
||||
pub(super) fn decode(
|
||||
raw: &RawValue,
|
||||
decoder: &mut TreeDecoder<'_, '_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(raw.get())?;
|
||||
let radius = decoder.int_provider(required(&object, "radius")?, 0, 16)?;
|
||||
let offset = decoder.int_provider(required(&object, "offset")?, 0, 16)?;
|
||||
let fixed_height = || int_range(required(&object, "height")?, "foliage height", 0, 16);
|
||||
let chance = |name: &'static str| unit_float(required(&object, name)?, name);
|
||||
let kind = match kind(&object)?.as_str() {
|
||||
"minecraft:blob_foliage_placer" => Kind::Blob(fixed_height()?),
|
||||
"minecraft:fancy_foliage_placer" => Kind::Fancy(fixed_height()?),
|
||||
"minecraft:bush_foliage_placer" => Kind::Bush(fixed_height()?),
|
||||
"minecraft:jungle_foliage_placer" => Kind::MegaJungle(fixed_height()?),
|
||||
"minecraft:acacia_foliage_placer" => Kind::Acacia,
|
||||
"minecraft:dark_oak_foliage_placer" => Kind::DarkOak,
|
||||
"minecraft:spruce_foliage_placer" => {
|
||||
Kind::Spruce(decoder.int_provider(required(&object, "trunk_height")?, 0, 24)?)
|
||||
}
|
||||
"minecraft:pine_foliage_placer" => {
|
||||
Kind::Pine(decoder.int_provider(required(&object, "height")?, 0, 24)?)
|
||||
}
|
||||
"minecraft:mega_pine_foliage_placer" => {
|
||||
Kind::MegaPine(decoder.int_provider(required(&object, "crown_height")?, 0, 24)?)
|
||||
}
|
||||
"minecraft:random_spread_foliage_placer" => Kind::RandomSpread {
|
||||
foliage_height: decoder.int_provider(
|
||||
required(&object, "foliage_height")?,
|
||||
1,
|
||||
512,
|
||||
)?,
|
||||
attempts: int_range(
|
||||
required(&object, "leaf_placement_attempts")?,
|
||||
"leaf_placement_attempts",
|
||||
0,
|
||||
256,
|
||||
)?,
|
||||
},
|
||||
"minecraft:cherry_foliage_placer" => Kind::Cherry {
|
||||
height: decoder.int_provider(required(&object, "height")?, 4, 16)?,
|
||||
wide_bottom_hole: chance("wide_bottom_layer_hole_chance")?,
|
||||
corner_hole: chance("corner_hole_chance")?,
|
||||
hanging: chance("hanging_leaves_chance")?,
|
||||
hanging_extension: chance("hanging_leaves_extension_chance")?,
|
||||
},
|
||||
"minecraft:poplar_foliage_placer" => Kind::Poplar {
|
||||
height: decoder.int_provider(required(&object, "height")?, 5, 16)?,
|
||||
side_hole: chance("side_hole_chance")?,
|
||||
},
|
||||
_ => return Err(DecodeError::Field("foliage placer type")),
|
||||
};
|
||||
Ok(Self {
|
||||
radius,
|
||||
offset,
|
||||
kind,
|
||||
})
|
||||
}
|
||||
pub(super) fn foliage_height<E>(
|
||||
&self,
|
||||
random: &mut impl RandomSource,
|
||||
tree_height: i32,
|
||||
) -> TreeResult<i32, E> {
|
||||
Ok(match &self.kind {
|
||||
Kind::Blob(h) | Kind::Fancy(h) | Kind::Bush(h) | Kind::MegaJungle(h) => *h,
|
||||
Kind::Acacia => 0,
|
||||
Kind::DarkOak => 4,
|
||||
Kind::Spruce(trunk) => 4.max(tree_height - trunk.sample(random)?),
|
||||
Kind::Pine(h) | Kind::MegaPine(h) => h.sample(random)?,
|
||||
Kind::RandomSpread { foliage_height, .. } => foliage_height.sample(random)?,
|
||||
Kind::Cherry { height, .. } | Kind::Poplar { height, .. } => height.sample(random)?,
|
||||
})
|
||||
}
|
||||
pub(super) fn foliage_radius<E>(
|
||||
&self,
|
||||
random: &mut impl RandomSource,
|
||||
trunk_height: i32,
|
||||
) -> TreeResult<i32, E> {
|
||||
let radius = self.radius.sample(random)?;
|
||||
if matches!(self.kind, Kind::Pine(_)) {
|
||||
return Ok(radius + random.next_int_bound(trunk_height.wrapping_add(1).max(1))?);
|
||||
}
|
||||
Ok(radius)
|
||||
}
|
||||
|
||||
/// shouldSkipLocation with already-unsigned offsets.
|
||||
fn skip(
|
||||
&self,
|
||||
random: &mut impl RandomSource,
|
||||
dx: i32,
|
||||
y: i32,
|
||||
dz: i32,
|
||||
r: i32,
|
||||
double: bool,
|
||||
) -> Result<bool, horizon_core::random::InvalidBound> {
|
||||
Ok(match &self.kind {
|
||||
Kind::Blob(_) => dx == r && dz == r && (random.next_int_bound(2)? == 0 || y == 0),
|
||||
Kind::Bush(_) => dx == r && dz == r && random.next_int_bound(2)? == 0,
|
||||
Kind::Fancy(_) => {
|
||||
let a = dx as f32 + 0.5;
|
||||
let b = dz as f32 + 0.5;
|
||||
a * a + b * b > r.wrapping_mul(r) as f32
|
||||
}
|
||||
Kind::Acacia => {
|
||||
if y == 0 {
|
||||
(dx > 1 || dz > 1) && dx != 0 && dz != 0
|
||||
} else {
|
||||
dx == r && dz == r && r > 0
|
||||
}
|
||||
}
|
||||
Kind::Spruce(_) | Kind::Pine(_) => dx == r && dz == r && r > 0,
|
||||
Kind::MegaPine(_) | Kind::MegaJungle(_) => {
|
||||
dx.wrapping_add(dz) >= 7
|
||||
|| dx.wrapping_mul(dx).wrapping_add(dz.wrapping_mul(dz)) > r.wrapping_mul(r)
|
||||
}
|
||||
Kind::DarkOak => {
|
||||
if y == -1 && !double {
|
||||
dx == r && dz == r
|
||||
} else if y == 1 {
|
||||
dx.wrapping_add(dz) > r.wrapping_mul(2).wrapping_sub(2)
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
Kind::RandomSpread { .. } => false,
|
||||
Kind::Cherry {
|
||||
wide_bottom_hole,
|
||||
corner_hole,
|
||||
..
|
||||
} => {
|
||||
if y == -1 && (dx == r || dz == r) && random.next_float() < *wide_bottom_hole {
|
||||
return Ok(true);
|
||||
}
|
||||
let corner = dx == r && dz == r;
|
||||
if r > 2 {
|
||||
corner
|
||||
|| (dx.wrapping_add(dz) > r.wrapping_mul(2).wrapping_sub(2)
|
||||
&& random.next_float() < *corner_hole)
|
||||
} else {
|
||||
corner && random.next_float() < *corner_hole
|
||||
}
|
||||
}
|
||||
Kind::Poplar { .. } => unreachable!("poplar uses its own row placement"),
|
||||
})
|
||||
}
|
||||
fn skip_signed(
|
||||
&self,
|
||||
random: &mut impl RandomSource,
|
||||
dx: i32,
|
||||
y: i32,
|
||||
dz: i32,
|
||||
r: i32,
|
||||
double: bool,
|
||||
) -> Result<bool, horizon_core::random::InvalidBound> {
|
||||
if matches!(self.kind, Kind::DarkOak) {
|
||||
let defer = y != 0
|
||||
|| !double
|
||||
|| (dx != r.wrapping_neg() && dx < r)
|
||||
|| (dz != r.wrapping_neg() && dz < r);
|
||||
if !defer {
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
let (mx, mz) = if double {
|
||||
(
|
||||
abs(dx).min(abs(dx.wrapping_sub(1))),
|
||||
abs(dz).min(abs(dz.wrapping_sub(1))),
|
||||
)
|
||||
} else {
|
||||
(abs(dx), abs(dz))
|
||||
};
|
||||
self.skip(random, mx, y, mz, r, double)
|
||||
}
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn leaves_row<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
origin: [i32; 3],
|
||||
r: i32,
|
||||
y: i32,
|
||||
double: bool,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let offset = i32::from(double);
|
||||
let mut dx = r.wrapping_neg();
|
||||
while dx <= r.wrapping_add(offset) {
|
||||
let mut dz = r.wrapping_neg();
|
||||
while dz <= r.wrapping_add(offset) {
|
||||
if !self.skip_signed(run.random, dx, y, dz, r, double)? {
|
||||
tree.try_place_leaf(run, tb::offset(origin, dx, y, dz))?;
|
||||
}
|
||||
dz += 1;
|
||||
}
|
||||
dx += 1;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn leaves_row_with_hanging<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
origin: [i32; 3],
|
||||
r: i32,
|
||||
y: i32,
|
||||
double: bool,
|
||||
chance: f32,
|
||||
extension: f32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
self.leaves_row(run, tree, origin, r, y, double)?;
|
||||
let offset = i32::from(double);
|
||||
let log = tb::offset(origin, 0, -1, 0);
|
||||
for along in tb::HORIZONTAL {
|
||||
let to_edge = tb::clockwise(along);
|
||||
let positive = matches!(to_edge, Direction::East | Direction::South);
|
||||
let to_edge_offset = if positive { r + offset } else { r };
|
||||
let mut pos = tb::relative(
|
||||
tb::relative(tb::offset(origin, 0, y - 1, 0), to_edge, to_edge_offset),
|
||||
along,
|
||||
r.wrapping_neg(),
|
||||
);
|
||||
let mut along_offset = r.wrapping_neg();
|
||||
while along_offset < r + offset {
|
||||
let above = run.foliage_contains(tb::offset(pos, 0, 1, 0));
|
||||
if above && Self::try_extension(run, tree, chance, log, pos)? {
|
||||
Self::try_extension(run, tree, extension, log, tb::offset(pos, 0, -1, 0))?;
|
||||
}
|
||||
along_offset += 1;
|
||||
pos = tb::relative(pos, along, 1);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn try_extension<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
chance: f32,
|
||||
log: [i32; 3],
|
||||
pos: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if tb::dist_manhattan(pos, log) >= 7 {
|
||||
return Ok(false);
|
||||
}
|
||||
if run.random.next_float() > chance {
|
||||
return Ok(false);
|
||||
}
|
||||
tree.try_place_leaf(run, pos)
|
||||
}
|
||||
|
||||
pub(super) fn create_foliage<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
_tree_height: i32,
|
||||
attachment: FoliageAttachment,
|
||||
foliage_height: i32,
|
||||
leaf_radius: i32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let offset = self.offset.sample(run.random)?;
|
||||
let double = attachment.double_trunk();
|
||||
let pos = attachment.pos;
|
||||
let with_offset = foliage_height + attachment.height_offset;
|
||||
match &self.kind {
|
||||
Kind::Blob(_) => {
|
||||
let mut yo = offset;
|
||||
while yo >= offset - with_offset {
|
||||
let r = 0.max(leaf_radius + attachment.radius_offset - 1 - yo / 2);
|
||||
self.leaves_row(run, tree, pos, r, yo, double)?;
|
||||
yo -= 1;
|
||||
}
|
||||
}
|
||||
Kind::Fancy(_) => {
|
||||
let mut yo = offset;
|
||||
while yo >= offset - foliage_height {
|
||||
let r = leaf_radius + i32::from(yo != offset && yo != offset - foliage_height);
|
||||
self.leaves_row(run, tree, pos, r, yo, double)?;
|
||||
yo -= 1;
|
||||
}
|
||||
}
|
||||
Kind::Bush(_) => {
|
||||
let mut yo = offset;
|
||||
while yo >= offset - with_offset {
|
||||
let r = leaf_radius + attachment.radius_offset - 1 - yo;
|
||||
self.leaves_row(run, tree, pos, r, yo, double)?;
|
||||
yo -= 1;
|
||||
}
|
||||
}
|
||||
Kind::Acacia => {
|
||||
let p = tb::offset(pos, 0, offset, 0);
|
||||
self.leaves_row(
|
||||
run,
|
||||
tree,
|
||||
p,
|
||||
leaf_radius + attachment.radius_offset,
|
||||
-1 - with_offset,
|
||||
double,
|
||||
)?;
|
||||
self.leaves_row(run, tree, p, leaf_radius - 1, -with_offset, double)?;
|
||||
self.leaves_row(
|
||||
run,
|
||||
tree,
|
||||
p,
|
||||
leaf_radius + attachment.radius_offset - 1,
|
||||
0,
|
||||
double,
|
||||
)?;
|
||||
}
|
||||
Kind::Spruce(_) => {
|
||||
let mut r = run.random.next_int_bound(2)?;
|
||||
let mut max_r = 1;
|
||||
let mut min_r = 0;
|
||||
let mut yo = offset;
|
||||
while yo >= -with_offset {
|
||||
self.leaves_row(run, tree, pos, r, yo, double)?;
|
||||
if r >= max_r {
|
||||
r = min_r;
|
||||
min_r = 1;
|
||||
max_r = (max_r + 1).min(leaf_radius + attachment.radius_offset);
|
||||
} else {
|
||||
r += 1;
|
||||
}
|
||||
yo -= 1;
|
||||
}
|
||||
}
|
||||
Kind::Pine(_) => {
|
||||
let mut r = 0;
|
||||
let mut yo = offset;
|
||||
while yo >= offset - with_offset {
|
||||
self.leaves_row(run, tree, pos, r, yo, double)?;
|
||||
if r >= 1 && yo == offset - with_offset + 1 {
|
||||
r -= 1;
|
||||
} else if r < leaf_radius + attachment.radius_offset {
|
||||
r += 1;
|
||||
}
|
||||
yo -= 1;
|
||||
}
|
||||
}
|
||||
Kind::MegaPine(_) => {
|
||||
let mut previous = 0;
|
||||
let mut yy = pos[1] - with_offset + offset;
|
||||
while yy <= pos[1] + offset {
|
||||
let yo = pos[1] - yy;
|
||||
let smooth = leaf_radius
|
||||
.wrapping_add(attachment.radius_offset)
|
||||
.wrapping_add((yo as f32 / with_offset as f32 * 3.5f32).floor() as i32);
|
||||
let jagged = if yo > 0 && smooth == previous && (yy & 1) == 0 {
|
||||
smooth.wrapping_add(1)
|
||||
} else {
|
||||
smooth
|
||||
};
|
||||
self.leaves_row(run, tree, [pos[0], yy, pos[2]], jagged, 0, double)?;
|
||||
previous = smooth;
|
||||
yy += 1;
|
||||
}
|
||||
}
|
||||
Kind::MegaJungle(_) => {
|
||||
let leaf_height = (if double {
|
||||
foliage_height
|
||||
} else {
|
||||
1 + run.random.next_int_bound(2)?
|
||||
}) + attachment.height_offset;
|
||||
let mut yo = offset;
|
||||
while yo >= offset - leaf_height {
|
||||
let r = leaf_radius + attachment.radius_offset + 1 - yo;
|
||||
self.leaves_row(run, tree, pos, r, yo, double)?;
|
||||
yo -= 1;
|
||||
}
|
||||
}
|
||||
Kind::DarkOak => {
|
||||
let p = tb::offset(pos, 0, offset, 0);
|
||||
if double {
|
||||
self.leaves_row(run, tree, p, leaf_radius + 2, -1, double)?;
|
||||
self.leaves_row(run, tree, p, leaf_radius + 3, 0, double)?;
|
||||
self.leaves_row(run, tree, p, leaf_radius + 2, 1, double)?;
|
||||
if run.random.next_boolean() {
|
||||
self.leaves_row(run, tree, p, leaf_radius, 2, double)?;
|
||||
}
|
||||
} else {
|
||||
self.leaves_row(run, tree, p, leaf_radius + 2, -1, double)?;
|
||||
self.leaves_row(run, tree, p, leaf_radius + 1, 0, double)?;
|
||||
}
|
||||
}
|
||||
Kind::RandomSpread { attempts, .. } => {
|
||||
for _ in 0..*attempts {
|
||||
let dx = run.random.next_int_bound(leaf_radius)?
|
||||
- run.random.next_int_bound(leaf_radius)?;
|
||||
let dy = run.random.next_int_bound(foliage_height)?
|
||||
- run.random.next_int_bound(foliage_height)?;
|
||||
let dz = run.random.next_int_bound(leaf_radius)?
|
||||
- run.random.next_int_bound(leaf_radius)?;
|
||||
tree.try_place_leaf(run, tb::offset(pos, dx, dy, dz))?;
|
||||
}
|
||||
}
|
||||
Kind::Cherry {
|
||||
hanging,
|
||||
hanging_extension,
|
||||
..
|
||||
} => {
|
||||
let p = tb::offset(pos, 0, offset, 0);
|
||||
let r = leaf_radius + attachment.radius_offset - 1;
|
||||
self.leaves_row(run, tree, p, r - 2, with_offset - 3, double)?;
|
||||
self.leaves_row(run, tree, p, r - 1, with_offset - 4, double)?;
|
||||
let mut y = with_offset - 5;
|
||||
while y >= 0 {
|
||||
self.leaves_row(run, tree, p, r, y, double)?;
|
||||
y -= 1;
|
||||
}
|
||||
self.leaves_row_with_hanging(
|
||||
run,
|
||||
tree,
|
||||
p,
|
||||
r,
|
||||
-1,
|
||||
double,
|
||||
*hanging,
|
||||
*hanging_extension,
|
||||
)?;
|
||||
self.leaves_row_with_hanging(
|
||||
run,
|
||||
tree,
|
||||
p,
|
||||
r - 1,
|
||||
-2,
|
||||
double,
|
||||
*hanging,
|
||||
*hanging_extension,
|
||||
)?;
|
||||
}
|
||||
Kind::Poplar { side_hole, .. } => {
|
||||
let poplar = Poplar {
|
||||
side_hole: *side_hole,
|
||||
flip: run.random.next_boolean(),
|
||||
height: with_offset,
|
||||
double,
|
||||
};
|
||||
let p = tb::offset(pos, 0, offset, 0);
|
||||
let r = leaf_radius + attachment.radius_offset - 1;
|
||||
poplar.row(run, tree, p, r - 2, with_offset - 1)?;
|
||||
poplar.row(run, tree, p, r - 1, with_offset - 2)?;
|
||||
poplar.row(run, tree, p, r - 1, with_offset - 3)?;
|
||||
let mut y = with_offset - 4;
|
||||
while y >= 1 {
|
||||
poplar.row(run, tree, p, r, y)?;
|
||||
y -= 1;
|
||||
}
|
||||
poplar.replace_with_log(run, tree, p, r, with_offset - 4)?;
|
||||
poplar.row(run, tree, p, r - 1, 0)?;
|
||||
poplar.row(run, tree, p, (r - 2).clamp(1, 2), -1)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
struct Poplar {
|
||||
side_hole: f32,
|
||||
flip: bool,
|
||||
height: i32,
|
||||
double: bool,
|
||||
}
|
||||
impl Poplar {
|
||||
fn partial_row(&self, y: i32) -> bool {
|
||||
self.height - 1 == y || self.height - 2 == y
|
||||
}
|
||||
fn corner_cut(&self, dx: i32, dz: i32, r: i32, partial: bool) -> i32 {
|
||||
let small = if self.flip {
|
||||
(dx > 0 && dz > 0) || (dz < 0 && dx < 0)
|
||||
} else {
|
||||
(dx > 0 && dz < 0) || (dz > 0 && dx < 0)
|
||||
};
|
||||
if small {
|
||||
r - 1
|
||||
} else if partial {
|
||||
r + 1
|
||||
} else {
|
||||
r
|
||||
}
|
||||
}
|
||||
fn within(r: i32, adx: i32, adz: i32, cut: i32, extra: i32) -> bool {
|
||||
adx.wrapping_add(adz) <= r.wrapping_mul(2).wrapping_sub(cut.wrapping_add(extra))
|
||||
}
|
||||
fn skip(
|
||||
&self,
|
||||
random: &mut impl RandomSource,
|
||||
dx: i32,
|
||||
y: i32,
|
||||
dz: i32,
|
||||
r: i32,
|
||||
) -> Result<bool, horizon_core::random::InvalidBound> {
|
||||
let partial = self.partial_row(y);
|
||||
let cut = self.corner_cut(dx, dz, r, partial);
|
||||
let (adx, adz) = (abs(dx), abs(dz));
|
||||
if partial && (adx == r || adz == r) {
|
||||
return Ok(true);
|
||||
}
|
||||
let extra = i32::from(random.next_float() <= self.side_hole);
|
||||
Ok(!Self::within(r, adx, adz, cut, extra))
|
||||
}
|
||||
fn row<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
origin: [i32; 3],
|
||||
r: i32,
|
||||
y: i32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let offset = i32::from(self.double);
|
||||
let mut dx = r.wrapping_neg();
|
||||
while dx <= r + offset {
|
||||
let mut dz = r.wrapping_neg();
|
||||
while dz <= r + offset {
|
||||
if !self.skip(run.random, dx, y, dz, r)? {
|
||||
tree.try_place_leaf(run, tb::offset(origin, dx, y, dz))?;
|
||||
}
|
||||
dz += 1;
|
||||
}
|
||||
dx += 1;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn replace_with_log<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
origin: [i32; 3],
|
||||
r: i32,
|
||||
y: i32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let offset = i32::from(self.double);
|
||||
let mut dx = r.wrapping_neg();
|
||||
while dx <= r + offset {
|
||||
let mut dz = r.wrapping_neg();
|
||||
while dz <= r + offset {
|
||||
let (adx, adz) = (abs(dx), abs(dz));
|
||||
let cut = self.corner_cut(dx, dz, r, self.partial_row(y));
|
||||
if Self::within(r, adx, adz, cut, 2)
|
||||
&& ((adz == 0 && r - adx >= 4) || (adx == 0 && r - adz >= 4))
|
||||
{
|
||||
let pos = tb::offset(origin, dx, y, dz);
|
||||
let axis = if adz == 0 { Axis::X } else { Axis::Z };
|
||||
// The comparison state is sampled from the foliage provider.
|
||||
let here = read(run.world, pos)?;
|
||||
let foliage = sample_state(&tree.foliage_provider, run.world, run.random, pos)?;
|
||||
if here == foliage {
|
||||
let log = sample_state(&tree.trunk_provider, run.world, run.random, pos)?;
|
||||
run.set(Layer::Foliage, pos, tree.blocks.try_axis(log, axis))?;
|
||||
}
|
||||
}
|
||||
dz += 1;
|
||||
}
|
||||
dx += 1;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,810 @@
|
||||
//! Trunk placers (TrunkPlacer subclasses), in native random-draw order.
|
||||
use super::{
|
||||
FoliageAttachment, Layer, Run, TreeDecoder, TreeFeature, TreeResult, kind, read,
|
||||
sample_optional, sample_state, unit_float,
|
||||
};
|
||||
use crate::registry::BlockStateId;
|
||||
use crate::worldgen::{
|
||||
DecodeError, Object,
|
||||
feature::FeatureWorld,
|
||||
int_range, optional,
|
||||
placement::PlacementContext,
|
||||
required,
|
||||
tree_blocks::{self as tb, Axis, TreeBlocks},
|
||||
value_provider::IntProvider,
|
||||
};
|
||||
use horizon_core::{geometry::Direction, random::RandomSource};
|
||||
use serde_json::value::RawValue;
|
||||
use std::{collections::BTreeSet, sync::Arc};
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum Kind {
|
||||
Straight,
|
||||
Forking,
|
||||
Giant,
|
||||
MegaJungle,
|
||||
DarkOak,
|
||||
Fancy,
|
||||
Bending {
|
||||
min_height_for_leaves: i32,
|
||||
bend_length: IntProvider,
|
||||
},
|
||||
UpwardsBranching {
|
||||
extra_branch_steps: IntProvider,
|
||||
branch_probability: f32,
|
||||
extra_branch_length: IntProvider,
|
||||
can_grow_through: Arc<BTreeSet<BlockStateId>>,
|
||||
},
|
||||
Cherry {
|
||||
branch_count: IntProvider,
|
||||
branch_horizontal_length: IntProvider,
|
||||
branch_start: [i32; 2],
|
||||
branch_end_offset: IntProvider,
|
||||
},
|
||||
Poplar {
|
||||
trunk_height_above_branches: IntProvider,
|
||||
branch_amount: IntProvider,
|
||||
},
|
||||
}
|
||||
#[derive(Clone, Debug)]
|
||||
pub(super) struct TrunkPlacer {
|
||||
base_height: i32,
|
||||
height_rand_a: i32,
|
||||
height_rand_b: i32,
|
||||
kind: Kind,
|
||||
}
|
||||
|
||||
fn random_horizontal(
|
||||
random: &mut impl RandomSource,
|
||||
) -> Result<Direction, horizon_core::random::InvalidBound> {
|
||||
Ok(tb::HORIZONTAL[random.next_int_bound(4)? as usize])
|
||||
}
|
||||
|
||||
impl TrunkPlacer {
|
||||
pub(super) fn decode(
|
||||
raw: &RawValue,
|
||||
decoder: &mut TreeDecoder<'_, '_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(raw.get())?;
|
||||
let base_height = int_range(required(&object, "base_height")?, "base_height", 0, 32)?;
|
||||
let height_rand_a = int_range(required(&object, "height_rand_a")?, "height_rand_a", 0, 24)?;
|
||||
let height_rand_b = int_range(required(&object, "height_rand_b")?, "height_rand_b", 0, 24)?;
|
||||
let kind = match kind(&object)?.as_str() {
|
||||
"minecraft:straight_trunk_placer" => Kind::Straight,
|
||||
"minecraft:forking_trunk_placer" => Kind::Forking,
|
||||
"minecraft:giant_trunk_placer" => Kind::Giant,
|
||||
"minecraft:mega_jungle_trunk_placer" => Kind::MegaJungle,
|
||||
"minecraft:dark_oak_trunk_placer" => Kind::DarkOak,
|
||||
"minecraft:fancy_trunk_placer" => Kind::Fancy,
|
||||
"minecraft:bending_trunk_placer" => Kind::Bending {
|
||||
min_height_for_leaves: optional(&object, "min_height_for_leaves")
|
||||
.map(|raw| int_range(raw, "min_height_for_leaves", 1, i32::MAX))
|
||||
.transpose()?
|
||||
.unwrap_or(1),
|
||||
bend_length: decoder.int_provider(required(&object, "bend_length")?, 1, 64)?,
|
||||
},
|
||||
"minecraft:upwards_branching_trunk_placer" => Kind::UpwardsBranching {
|
||||
extra_branch_steps: decoder.int_provider(
|
||||
required(&object, "extra_branch_steps")?,
|
||||
1,
|
||||
i32::MAX,
|
||||
)?,
|
||||
branch_probability: unit_float(
|
||||
required(&object, "place_branch_per_log_probability")?,
|
||||
"place_branch_per_log_probability",
|
||||
)?,
|
||||
extra_branch_length: decoder.int_provider(
|
||||
required(&object, "extra_branch_length")?,
|
||||
0,
|
||||
i32::MAX,
|
||||
)?,
|
||||
can_grow_through: decoder.block_set(required(&object, "can_grow_through")?)?,
|
||||
},
|
||||
"minecraft:cherry_trunk_placer" => {
|
||||
let start: Object =
|
||||
serde_json::from_str(required(&object, "branch_start_offset_from_top")?.get())?;
|
||||
if let Some(kind) = optional(&start, "type") {
|
||||
if serde_json::from_str::<String>(kind.get())? != "minecraft:uniform" {
|
||||
return Err(DecodeError::Field("cherry branch start type"));
|
||||
}
|
||||
}
|
||||
let min = int_range(required(&start, "min_inclusive")?, "branch start", -16, 0)?;
|
||||
let max = int_range(required(&start, "max_inclusive")?, "branch start", -16, 0)?;
|
||||
if max - min < 1 {
|
||||
return Err(DecodeError::Field("cherry branch start variation"));
|
||||
}
|
||||
Kind::Cherry {
|
||||
branch_count: decoder.int_provider(required(&object, "branch_count")?, 1, 3)?,
|
||||
branch_horizontal_length: decoder.int_provider(
|
||||
required(&object, "branch_horizontal_length")?,
|
||||
2,
|
||||
16,
|
||||
)?,
|
||||
branch_start: [min, max],
|
||||
branch_end_offset: decoder.int_provider(
|
||||
required(&object, "branch_end_offset_from_top")?,
|
||||
-16,
|
||||
16,
|
||||
)?,
|
||||
}
|
||||
}
|
||||
"minecraft:poplar_trunk_placer" => Kind::Poplar {
|
||||
trunk_height_above_branches: decoder.int_provider(
|
||||
required(&object, "trunk_height_above_branches")?,
|
||||
0,
|
||||
8,
|
||||
)?,
|
||||
branch_amount: decoder.int_provider(required(&object, "branch_amount")?, 1, 4)?,
|
||||
},
|
||||
_ => return Err(DecodeError::Field("trunk placer type")),
|
||||
};
|
||||
Ok(Self {
|
||||
base_height,
|
||||
height_rand_a,
|
||||
height_rand_b,
|
||||
kind,
|
||||
})
|
||||
}
|
||||
pub(super) fn tree_height<E>(&self, random: &mut impl RandomSource) -> TreeResult<i32, E> {
|
||||
let a = random.next_int_bound(self.height_rand_a + 1)?;
|
||||
let b = random.next_int_bound(self.height_rand_b + 1)?;
|
||||
Ok(self.base_height + a + b)
|
||||
}
|
||||
/// Virtual TrunkPlacer.validTreePos.
|
||||
fn valid_tree_pos(&self, blocks: &TreeBlocks, state: BlockStateId) -> bool {
|
||||
blocks.valid_tree_pos(state)
|
||||
|| matches!(&self.kind, Kind::UpwardsBranching { can_grow_through, .. } if can_grow_through.contains(&state))
|
||||
}
|
||||
pub(super) fn is_free(&self, blocks: &TreeBlocks, state: BlockStateId) -> bool {
|
||||
self.valid_tree_pos(blocks, state) || blocks.has(state, tb::LOGS)
|
||||
}
|
||||
fn place_log<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
position: [i32; 3],
|
||||
axis: Option<Axis>,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let here = read(run.world, position)?;
|
||||
if !self.valid_tree_pos(&tree.blocks, here) {
|
||||
return Ok(false);
|
||||
}
|
||||
let mut state = sample_state(&tree.trunk_provider, run.world, run.random, position)?;
|
||||
if let Some(axis) = axis {
|
||||
state = tree.blocks.try_axis(state, axis);
|
||||
}
|
||||
run.set(Layer::Trunk, position, state)?;
|
||||
Ok(true)
|
||||
}
|
||||
fn place_log_if_free<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
position: [i32; 3],
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let here = read(run.world, position)?;
|
||||
if self.is_free(&tree.blocks, here) {
|
||||
self.place_log(run, tree, position, None)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn place_below_trunk<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
position: [i32; 3],
|
||||
) -> TreeResult<(), W::Error> {
|
||||
if let Some(state) =
|
||||
sample_optional(&tree.below_trunk_provider, run.world, run.random, position)?
|
||||
{
|
||||
run.set(Layer::Trunk, position, state)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub(super) fn place_trunk<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
tree_height: i32,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<Vec<FoliageAttachment>, W::Error> {
|
||||
let below = tb::offset(origin, 0, -1, 0);
|
||||
match &self.kind {
|
||||
Kind::Straight => {
|
||||
Self::place_below_trunk(run, tree, below)?;
|
||||
for y in 0..tree_height {
|
||||
self.place_log(run, tree, tb::offset(origin, 0, y, 0), None)?;
|
||||
}
|
||||
Ok(vec![FoliageAttachment::new(
|
||||
tb::offset(origin, 0, tree_height, 0),
|
||||
0,
|
||||
false,
|
||||
)])
|
||||
}
|
||||
Kind::Forking => self.forking(run, tree, tree_height, origin),
|
||||
Kind::Giant => self.giant(run, tree, tree_height, origin),
|
||||
Kind::MegaJungle => {
|
||||
let mut attachments = self.giant(run, tree, tree_height, origin)?;
|
||||
let mut branch_height = tree_height - 2 - run.random.next_int_bound(4)?;
|
||||
while branch_height > tree_height / 2 {
|
||||
let angle = run.random.next_float() * (std::f64::consts::PI * 2.0) as f32;
|
||||
let (mut bx, mut bz) = (0, 0);
|
||||
for b in 0..5 {
|
||||
bx = (1.5f32
|
||||
+ horizon_core::geometry::trig::cos(f64::from(angle)) * b as f32)
|
||||
as i32;
|
||||
bz = (1.5f32
|
||||
+ horizon_core::geometry::trig::sin(f64::from(angle)) * b as f32)
|
||||
as i32;
|
||||
let p = tb::offset(origin, bx, branch_height - 3 + b / 2, bz);
|
||||
self.place_log(run, tree, p, None)?;
|
||||
}
|
||||
attachments.push(FoliageAttachment::new(
|
||||
tb::offset(origin, bx, branch_height, bz),
|
||||
-2,
|
||||
false,
|
||||
));
|
||||
branch_height -= 2 + run.random.next_int_bound(4)?;
|
||||
}
|
||||
Ok(attachments)
|
||||
}
|
||||
Kind::DarkOak => self.dark_oak(run, tree, tree_height, origin),
|
||||
Kind::Fancy => self.fancy(run, tree, tree_height, origin),
|
||||
Kind::Bending {
|
||||
min_height_for_leaves,
|
||||
bend_length,
|
||||
} => {
|
||||
let direction = random_horizontal(run.random)?;
|
||||
let log_height = tree_height - 1;
|
||||
let mut pos = origin;
|
||||
Self::place_below_trunk(run, tree, below)?;
|
||||
let mut points = Vec::new();
|
||||
for i in 0..=log_height {
|
||||
if i + 1 >= log_height + run.random.next_int_bound(2)? {
|
||||
pos = tb::relative(pos, direction, 1);
|
||||
}
|
||||
if tree.blocks.valid_tree_pos(read(run.world, pos)?) {
|
||||
self.place_log(run, tree, pos, None)?;
|
||||
}
|
||||
if i >= *min_height_for_leaves {
|
||||
points.push(FoliageAttachment::new(pos, 0, false));
|
||||
}
|
||||
pos = tb::offset(pos, 0, 1, 0);
|
||||
}
|
||||
let length = bend_length.sample(run.random)?;
|
||||
for _ in 0..=length {
|
||||
if tree.blocks.valid_tree_pos(read(run.world, pos)?) {
|
||||
self.place_log(run, tree, pos, None)?;
|
||||
}
|
||||
points.push(FoliageAttachment::new(pos, 0, false));
|
||||
pos = tb::relative(pos, direction, 1);
|
||||
}
|
||||
Ok(points)
|
||||
}
|
||||
Kind::UpwardsBranching {
|
||||
extra_branch_steps,
|
||||
branch_probability,
|
||||
extra_branch_length,
|
||||
..
|
||||
} => {
|
||||
let mut attachments = Vec::new();
|
||||
for height in 0..tree_height {
|
||||
let current = origin[1].wrapping_add(height);
|
||||
let log = [origin[0], current, origin[2]];
|
||||
if self.place_log(run, tree, log, None)?
|
||||
&& height < tree_height - 1
|
||||
&& run.random.next_float() < *branch_probability
|
||||
{
|
||||
let direction = random_horizontal(run.random)?;
|
||||
let length = extra_branch_length.sample(run.random)?;
|
||||
let branch_pos =
|
||||
0.max(length - extra_branch_length.sample(run.random)? - 1);
|
||||
let steps = extra_branch_steps.sample(run.random)?;
|
||||
self.upwards_branch(
|
||||
run,
|
||||
tree,
|
||||
tree_height,
|
||||
&mut attachments,
|
||||
log,
|
||||
current,
|
||||
direction,
|
||||
branch_pos,
|
||||
steps,
|
||||
)?;
|
||||
}
|
||||
if height == tree_height - 1 {
|
||||
attachments.push(FoliageAttachment::new(
|
||||
[origin[0], current.wrapping_add(1), origin[2]],
|
||||
0,
|
||||
false,
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(attachments)
|
||||
}
|
||||
Kind::Cherry { .. } => self.cherry(run, tree, tree_height, origin),
|
||||
Kind::Poplar {
|
||||
trunk_height_above_branches,
|
||||
branch_amount,
|
||||
} => {
|
||||
Self::place_below_trunk(run, tree, below)?;
|
||||
let up_to_branches =
|
||||
tree_height - trunk_height_above_branches.sample(run.random)?;
|
||||
for y in 0..tree_height {
|
||||
let log = tb::offset(origin, 0, y, 0);
|
||||
self.place_log(run, tree, log, None)?;
|
||||
let mut all = Direction::ALL;
|
||||
tb::shuffle(&mut all, run.random)?;
|
||||
let directions: Vec<Direction> = all
|
||||
.into_iter()
|
||||
.filter(|d| !matches!(d, Direction::Up | Direction::Down))
|
||||
.collect();
|
||||
if up_to_branches - 1 == y {
|
||||
let branches = branch_amount.sample(run.random)?;
|
||||
for direction in directions.iter().take(branches.max(0) as usize) {
|
||||
self.place_log(
|
||||
run,
|
||||
tree,
|
||||
tb::relative(log, *direction, 1),
|
||||
Some(Axis::of(*direction)),
|
||||
)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(vec![FoliageAttachment::new(
|
||||
tb::offset(origin, 0, up_to_branches, 0),
|
||||
0,
|
||||
false,
|
||||
)])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn forking<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
tree_height: i32,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<Vec<FoliageAttachment>, W::Error> {
|
||||
Self::place_below_trunk(run, tree, tb::offset(origin, 0, -1, 0))?;
|
||||
let mut attachments = Vec::new();
|
||||
let lean = random_horizontal(run.random)?;
|
||||
let lean_height = tree_height - run.random.next_int_bound(4)? - 1;
|
||||
let mut lean_steps = 3 - run.random.next_int_bound(3)?;
|
||||
let (mut tx, mut tz) = (origin[0], origin[2]);
|
||||
let mut ey = None;
|
||||
for yo in 0..tree_height {
|
||||
let yy = origin[1].wrapping_add(yo);
|
||||
if yo >= lean_height && lean_steps > 0 {
|
||||
let n = lean.normal();
|
||||
tx = tx.wrapping_add(n[0]);
|
||||
tz = tz.wrapping_add(n[2]);
|
||||
lean_steps -= 1;
|
||||
}
|
||||
if self.place_log(run, tree, [tx, yy, tz], None)? {
|
||||
ey = Some(yy.wrapping_add(1));
|
||||
}
|
||||
}
|
||||
if let Some(ey) = ey {
|
||||
attachments.push(FoliageAttachment::new([tx, ey, tz], 1, false));
|
||||
}
|
||||
tx = origin[0];
|
||||
tz = origin[2];
|
||||
let branch = random_horizontal(run.random)?;
|
||||
if branch != lean {
|
||||
let branch_pos = lean_height - run.random.next_int_bound(2)? - 1;
|
||||
let mut steps = 1 + run.random.next_int_bound(3)?;
|
||||
let mut ey = None;
|
||||
let mut yo = branch_pos;
|
||||
while yo < tree_height && steps > 0 {
|
||||
if yo >= 1 {
|
||||
let yy = origin[1].wrapping_add(yo);
|
||||
let n = branch.normal();
|
||||
tx = tx.wrapping_add(n[0]);
|
||||
tz = tz.wrapping_add(n[2]);
|
||||
if self.place_log(run, tree, [tx, yy, tz], None)? {
|
||||
ey = Some(yy.wrapping_add(1));
|
||||
}
|
||||
}
|
||||
yo += 1;
|
||||
steps -= 1;
|
||||
}
|
||||
if let Some(ey) = ey {
|
||||
attachments.push(FoliageAttachment::new([tx, ey, tz], 0, false));
|
||||
}
|
||||
}
|
||||
Ok(attachments)
|
||||
}
|
||||
|
||||
fn giant<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
tree_height: i32,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<Vec<FoliageAttachment>, W::Error> {
|
||||
let below = tb::offset(origin, 0, -1, 0);
|
||||
Self::place_below_trunk(run, tree, below)?;
|
||||
Self::place_below_trunk(run, tree, tb::offset(below, 1, 0, 0))?;
|
||||
Self::place_below_trunk(run, tree, tb::offset(below, 0, 0, 1))?;
|
||||
Self::place_below_trunk(run, tree, tb::offset(below, 1, 0, 1))?;
|
||||
for hh in 0..tree_height {
|
||||
self.place_log_if_free(run, tree, tb::offset(origin, 0, hh, 0))?;
|
||||
if hh < tree_height - 1 {
|
||||
self.place_log_if_free(run, tree, tb::offset(origin, 1, hh, 0))?;
|
||||
self.place_log_if_free(run, tree, tb::offset(origin, 1, hh, 1))?;
|
||||
self.place_log_if_free(run, tree, tb::offset(origin, 0, hh, 1))?;
|
||||
}
|
||||
}
|
||||
Ok(vec![FoliageAttachment::new(
|
||||
tb::offset(origin, 0, tree_height, 0),
|
||||
0,
|
||||
true,
|
||||
)])
|
||||
}
|
||||
|
||||
fn dark_oak<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
tree_height: i32,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<Vec<FoliageAttachment>, W::Error> {
|
||||
let mut attachments = Vec::new();
|
||||
let below = tb::offset(origin, 0, -1, 0);
|
||||
Self::place_below_trunk(run, tree, below)?;
|
||||
Self::place_below_trunk(run, tree, tb::offset(below, 1, 0, 0))?;
|
||||
Self::place_below_trunk(run, tree, tb::offset(below, 0, 0, 1))?;
|
||||
Self::place_below_trunk(run, tree, tb::offset(below, 1, 0, 1))?;
|
||||
let lean = random_horizontal(run.random)?;
|
||||
let lean_height = tree_height - run.random.next_int_bound(4)?;
|
||||
let mut lean_steps = 2 - run.random.next_int_bound(3)?;
|
||||
let [x, y, z] = origin;
|
||||
let (mut tx, mut tz) = (x, z);
|
||||
let ey = y.wrapping_add(tree_height).wrapping_sub(1);
|
||||
for dy in 0..tree_height {
|
||||
if dy >= lean_height && lean_steps > 0 {
|
||||
let n = lean.normal();
|
||||
tx = tx.wrapping_add(n[0]);
|
||||
tz = tz.wrapping_add(n[2]);
|
||||
lean_steps -= 1;
|
||||
}
|
||||
let p = [tx, y.wrapping_add(dy), tz];
|
||||
let here = read(run.world, p)?;
|
||||
if tree.blocks.has(here, tb::AIR | tb::LEAVES) {
|
||||
self.place_log(run, tree, p, None)?;
|
||||
self.place_log(run, tree, tb::offset(p, 1, 0, 0), None)?;
|
||||
self.place_log(run, tree, tb::offset(p, 0, 0, 1), None)?;
|
||||
self.place_log(run, tree, tb::offset(p, 1, 0, 1), None)?;
|
||||
}
|
||||
}
|
||||
attachments.push(FoliageAttachment::new([tx, ey, tz], 0, true));
|
||||
for ox in -1..=2 {
|
||||
for oz in -1..=2 {
|
||||
if (!(0..=1).contains(&ox) || !(0..=1).contains(&oz))
|
||||
&& run.random.next_int_bound(3)? <= 0
|
||||
{
|
||||
let length = run.random.next_int_bound(3)? + 2;
|
||||
for branch_y in 0..length {
|
||||
self.place_log(
|
||||
run,
|
||||
tree,
|
||||
[
|
||||
x.wrapping_add(ox),
|
||||
ey.wrapping_sub(branch_y).wrapping_sub(1),
|
||||
z.wrapping_add(oz),
|
||||
],
|
||||
None,
|
||||
)?;
|
||||
}
|
||||
attachments.push(FoliageAttachment::new(
|
||||
[x.wrapping_add(ox), ey, z.wrapping_add(oz)],
|
||||
0,
|
||||
false,
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(attachments)
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn upwards_branch<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
tree_height: i32,
|
||||
attachments: &mut Vec<FoliageAttachment>,
|
||||
log: [i32; 3],
|
||||
current_height: i32,
|
||||
direction: Direction,
|
||||
branch_pos: i32,
|
||||
mut steps: i32,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let mut height_along = current_height.wrapping_add(branch_pos);
|
||||
let (mut lx, mut lz) = (log[0], log[2]);
|
||||
let mut index = branch_pos;
|
||||
let n = direction.normal();
|
||||
while index < tree_height && steps > 0 {
|
||||
if index >= 1 {
|
||||
let placement = current_height.wrapping_add(index);
|
||||
lx = lx.wrapping_add(n[0]);
|
||||
lz = lz.wrapping_add(n[2]);
|
||||
height_along = placement;
|
||||
let log = [lx, placement, lz];
|
||||
if self.place_log(run, tree, log, None)? {
|
||||
height_along = height_along.wrapping_add(1);
|
||||
}
|
||||
attachments.push(FoliageAttachment::new(log, 0, false));
|
||||
}
|
||||
index += 1;
|
||||
steps -= 1;
|
||||
}
|
||||
if height_along.wrapping_sub(current_height) > 1 {
|
||||
let foliage = [lx, height_along, lz];
|
||||
attachments.push(FoliageAttachment::new(foliage, 0, false));
|
||||
attachments.push(FoliageAttachment::new(
|
||||
tb::offset(foliage, 0, -2, 0),
|
||||
0,
|
||||
false,
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn cherry<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
tree_height: i32,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<Vec<FoliageAttachment>, W::Error> {
|
||||
let Kind::Cherry {
|
||||
branch_count,
|
||||
branch_horizontal_length,
|
||||
branch_start: [start_min, start_max],
|
||||
branch_end_offset,
|
||||
} = &self.kind
|
||||
else {
|
||||
unreachable!("cherry trunk kind");
|
||||
};
|
||||
Self::place_below_trunk(run, tree, tb::offset(origin, 0, -1, 0))?;
|
||||
let first = 0.max(
|
||||
tree_height - 1
|
||||
+ run
|
||||
.random
|
||||
.next_int_between_inclusive(*start_min, *start_max)?,
|
||||
);
|
||||
let mut second = 0.max(
|
||||
tree_height - 1
|
||||
+ run
|
||||
.random
|
||||
.next_int_between_inclusive(*start_min, start_max - 1)?,
|
||||
);
|
||||
if second >= first {
|
||||
second += 1;
|
||||
}
|
||||
let count = branch_count.sample(run.random)?;
|
||||
let middle = count == 3;
|
||||
let both = count >= 2;
|
||||
let trunk_height = if middle {
|
||||
tree_height
|
||||
} else if both {
|
||||
first.max(second) + 1
|
||||
} else {
|
||||
first + 1
|
||||
};
|
||||
for y in 0..trunk_height {
|
||||
self.place_log(run, tree, tb::offset(origin, 0, y, 0), None)?;
|
||||
}
|
||||
let mut attachments = Vec::new();
|
||||
if middle {
|
||||
attachments.push(FoliageAttachment::new(
|
||||
tb::offset(origin, 0, trunk_height, 0),
|
||||
0,
|
||||
false,
|
||||
));
|
||||
}
|
||||
let direction = random_horizontal(run.random)?;
|
||||
let sideways = Axis::of(direction);
|
||||
let generate = |this: &Self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
branch_direction: Direction,
|
||||
offset: i32,
|
||||
middle_continues: bool|
|
||||
-> TreeResult<FoliageAttachment, W::Error> {
|
||||
let mut log = tb::offset(origin, 0, offset, 0);
|
||||
let end_offset = tree_height - 1 + branch_end_offset.sample(run.random)?;
|
||||
let extend = middle_continues || end_offset < offset;
|
||||
let distance = branch_horizontal_length.sample(run.random)? + i32::from(extend);
|
||||
let end = tb::offset(
|
||||
tb::relative(origin, branch_direction, distance),
|
||||
0,
|
||||
end_offset,
|
||||
0,
|
||||
);
|
||||
let steps = if extend { 2 } else { 1 };
|
||||
for _ in 0..steps {
|
||||
log = tb::relative(log, branch_direction, 1);
|
||||
this.place_log(run, tree, log, Some(sideways))?;
|
||||
}
|
||||
let vertical = if end[1] > log[1] {
|
||||
Direction::Up
|
||||
} else {
|
||||
Direction::Down
|
||||
};
|
||||
loop {
|
||||
let distance = tb::dist_manhattan(log, end);
|
||||
if distance == 0 {
|
||||
return Ok(FoliageAttachment::new(tb::offset(end, 0, 1, 0), 0, false));
|
||||
}
|
||||
let chance = end[1].wrapping_sub(log[1]).wrapping_abs() as f32 / distance as f32;
|
||||
let grow_vertically = run.random.next_float() < chance;
|
||||
log = tb::relative(
|
||||
log,
|
||||
if grow_vertically {
|
||||
vertical
|
||||
} else {
|
||||
branch_direction
|
||||
},
|
||||
1,
|
||||
);
|
||||
this.place_log(
|
||||
run,
|
||||
tree,
|
||||
log,
|
||||
if grow_vertically {
|
||||
None
|
||||
} else {
|
||||
Some(sideways)
|
||||
},
|
||||
)?;
|
||||
}
|
||||
};
|
||||
attachments.push(generate(
|
||||
self,
|
||||
run,
|
||||
direction,
|
||||
first,
|
||||
first < trunk_height - 1,
|
||||
)?);
|
||||
if both {
|
||||
attachments.push(generate(
|
||||
self,
|
||||
run,
|
||||
direction.opposite(),
|
||||
second,
|
||||
second < trunk_height - 1,
|
||||
)?);
|
||||
}
|
||||
Ok(attachments)
|
||||
}
|
||||
|
||||
fn fancy<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
tree_height: i32,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<Vec<FoliageAttachment>, W::Error> {
|
||||
let height = tree_height + 2;
|
||||
let trunk_height = (f64::from(height) * 0.618).floor() as i32;
|
||||
Self::place_below_trunk(run, tree, tb::offset(origin, 0, -1, 0))?;
|
||||
let clusters_per_y =
|
||||
1.min((1.382 + (1.0 * f64::from(height) / 13.0).powf(2.0)).floor() as i32);
|
||||
let trunk_top = origin[1].wrapping_add(trunk_height);
|
||||
let mut relative_y = height - 5;
|
||||
// (attachment position, branch base y)
|
||||
let mut coords = vec![(tb::offset(origin, 0, relative_y, 0), trunk_top)];
|
||||
while relative_y >= 0 {
|
||||
let shape = tree_shape(height, relative_y);
|
||||
// tree_shape never returns NaN.
|
||||
if shape >= 0.0 {
|
||||
for _ in 0..clusters_per_y {
|
||||
let radius =
|
||||
1.0 * f64::from(shape) * (f64::from(run.random.next_float()) + 0.328);
|
||||
let angle = f64::from(run.random.next_float() * 2.0f32) * std::f64::consts::PI;
|
||||
let x = radius * angle.sin() + 0.5;
|
||||
let z = radius * angle.cos() + 0.5;
|
||||
let check_start =
|
||||
tb::offset(origin, x.floor() as i32, relative_y - 1, z.floor() as i32);
|
||||
let check_end = tb::offset(check_start, 0, 5, 0);
|
||||
if self.make_limb(run, tree, check_start, check_end, false)? {
|
||||
let dx = origin[0].wrapping_sub(check_start[0]);
|
||||
let dz = origin[2].wrapping_sub(check_start[2]);
|
||||
let branch_height = f64::from(check_start[1])
|
||||
- f64::from(dx.wrapping_mul(dx).wrapping_add(dz.wrapping_mul(dz)))
|
||||
.sqrt()
|
||||
* 0.381;
|
||||
let branch_top = if branch_height > f64::from(trunk_top) {
|
||||
trunk_top
|
||||
} else {
|
||||
branch_height as i32
|
||||
};
|
||||
let base = [origin[0], branch_top, origin[2]];
|
||||
if self.make_limb(run, tree, base, check_start, false)? {
|
||||
coords.push((check_start, base[1]));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
relative_y -= 1;
|
||||
}
|
||||
self.make_limb(
|
||||
run,
|
||||
tree,
|
||||
origin,
|
||||
tb::offset(origin, 0, trunk_height, 0),
|
||||
true,
|
||||
)?;
|
||||
for (end, branch_base) in &coords {
|
||||
let base = [origin[0], *branch_base, origin[2]];
|
||||
if base != *end && trim_branches(height, branch_base.wrapping_sub(origin[1])) {
|
||||
self.make_limb(run, tree, base, *end, true)?;
|
||||
}
|
||||
}
|
||||
Ok(coords
|
||||
.into_iter()
|
||||
.filter(|(_, base)| trim_branches(height, base.wrapping_sub(origin[1])))
|
||||
.map(|(p, _)| FoliageAttachment::new(p, 0, false))
|
||||
.collect())
|
||||
}
|
||||
|
||||
fn make_limb<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
run: &mut Run<'_, W, R>,
|
||||
tree: &TreeFeature,
|
||||
start: [i32; 3],
|
||||
end: [i32; 3],
|
||||
place: bool,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if !place && start == end {
|
||||
return Ok(true);
|
||||
}
|
||||
let delta: [i32; 3] = std::array::from_fn(|i| end[i].wrapping_sub(start[i]));
|
||||
let steps = delta[0]
|
||||
.wrapping_abs()
|
||||
.max(delta[1].wrapping_abs().max(delta[2].wrapping_abs()));
|
||||
let step: [f32; 3] = delta.map(|d| d as f32 / steps as f32);
|
||||
for i in 0..=steps {
|
||||
let p: [i32; 3] = std::array::from_fn(|axis| {
|
||||
start[axis].wrapping_add((0.5f32 + i as f32 * step[axis]).floor() as i32)
|
||||
});
|
||||
if place {
|
||||
let axis = log_axis(start, p);
|
||||
self.place_log(run, tree, p, Some(axis))?;
|
||||
} else if !self.is_free(&tree.blocks, read(run.world, p)?) {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
fn log_axis(start: [i32; 3], p: [i32; 3]) -> Axis {
|
||||
let xdiff = p[0].wrapping_sub(start[0]).wrapping_abs();
|
||||
let zdiff = p[2].wrapping_sub(start[2]).wrapping_abs();
|
||||
let max = xdiff.max(zdiff);
|
||||
if max > 0 {
|
||||
if xdiff == max { Axis::X } else { Axis::Z }
|
||||
} else {
|
||||
Axis::Y
|
||||
}
|
||||
}
|
||||
fn trim_branches(height: i32, local_y: i32) -> bool {
|
||||
f64::from(local_y) >= f64::from(height) * 0.2
|
||||
}
|
||||
fn tree_shape(height: i32, y: i32) -> f32 {
|
||||
if (y as f32) < height as f32 * 0.3f32 {
|
||||
return -1.0;
|
||||
}
|
||||
let radius = height as f32 / 2.0;
|
||||
let adjacent = radius - y as f32;
|
||||
let mut distance = (radius * radius - adjacent * adjacent).sqrt();
|
||||
if adjacent == 0.0 {
|
||||
distance = radius;
|
||||
} else if adjacent.abs() >= radius {
|
||||
return 0.0;
|
||||
}
|
||||
distance * 0.5
|
||||
}
|
||||
@@ -0,0 +1,471 @@
|
||||
//! Registry-bound block classifications and property transitions shared by tree,
|
||||
//! fallen-tree and other vegetation features. Built once per binding snapshot.
|
||||
use super::{
|
||||
DecodeError, block_feature::FeatureBlockBindings, state_provider::properties::StateProperties,
|
||||
};
|
||||
use crate::{
|
||||
block_properties::BlockProperty,
|
||||
fluid::FluidKind,
|
||||
registry::{BlockRegistry, BlockStateId},
|
||||
};
|
||||
use horizon_core::geometry::Direction;
|
||||
use std::{collections::BTreeMap, sync::Arc};
|
||||
|
||||
pub(crate) const AIR: u32 = 1;
|
||||
pub(crate) const LEAVES: u32 = 1 << 1;
|
||||
pub(crate) const REPLACEABLE_BY_TREES: u32 = 1 << 2;
|
||||
pub(crate) const LOGS: u32 = 1 << 3;
|
||||
pub(crate) const PREVENTS_LEAF_DECAY: u32 = 1 << 4;
|
||||
pub(crate) const VINE: u32 = 1 << 5;
|
||||
pub(crate) const WATER_BLOCK: u32 = 1 << 6;
|
||||
pub(crate) const WATER_SOURCE: u32 = 1 << 7;
|
||||
pub(crate) const WATER_FLUID: u32 = 1 << 8;
|
||||
pub(crate) const REPLACEABLE: u32 = 1 << 9;
|
||||
pub(crate) const SOLID_RENDER: u32 = 1 << 10;
|
||||
pub(crate) const SHELF_MUSHROOM: u32 = 1 << 11;
|
||||
pub(crate) const PERSISTENT: u32 = 1 << 12;
|
||||
pub(crate) const WATERLOGGABLE: u32 = 1 << 13;
|
||||
pub(crate) const SOLID: u32 = 1 << 14;
|
||||
pub(crate) const LAVA_FLUID: u32 = 1 << 15;
|
||||
pub(crate) const ANY_FLUID: u32 = 1 << 16;
|
||||
pub(crate) const FULL_AXIS: u32 = 1 << 17;
|
||||
pub(crate) const MUSHROOM_REPLACEABLE: u32 = 1 << 18;
|
||||
pub(crate) const FIRE: u32 = 1 << 19;
|
||||
pub(crate) const SCULK_BLOCKER: u32 = 1 << 20;
|
||||
pub(crate) const SCULK_VEIN: u32 = 1 << 21;
|
||||
pub(crate) const LIQUID: u32 = 1 << 22;
|
||||
pub(crate) const FEATURES_CANNOT_REPLACE: u32 = 1 << 23;
|
||||
pub(crate) const CHEST: u32 = 1 << 24;
|
||||
pub(crate) const SPAWNER: u32 = 1 << 25;
|
||||
/// Any source fluid state (water or lava), including waterlogged blocks.
|
||||
pub(crate) const FLUID_SOURCE: u32 = 1 << 26;
|
||||
/// Fluid amount 8 (sources and falling fluids).
|
||||
pub(crate) const FLUID_FULL: u32 = 1 << 27;
|
||||
pub(crate) const BASE_STONE_OVERWORLD: u32 = 1 << 28;
|
||||
|
||||
/// Immutable per-state facts. Missing tags or blocks are empty classifications.
|
||||
pub struct TreeBlocks {
|
||||
flags: Vec<u32>,
|
||||
/// Native LeavesBlock DISTANCE (1..=7) values; 0 when absent.
|
||||
distance: Vec<u8>,
|
||||
/// Block identity (index of the block name) per state.
|
||||
block: Vec<u32>,
|
||||
pub(crate) properties: Arc<StateProperties>,
|
||||
defaults: BTreeMap<String, BlockStateId>,
|
||||
}
|
||||
impl std::fmt::Debug for TreeBlocks {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("TreeBlocks")
|
||||
.field("states", &self.flags.len())
|
||||
.finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
const DEFAULTS: [&str; 20] = [
|
||||
"minecraft:cobblestone",
|
||||
"minecraft:mossy_cobblestone",
|
||||
"minecraft:chest",
|
||||
"minecraft:spawner",
|
||||
"minecraft:ice",
|
||||
"minecraft:packed_ice",
|
||||
"minecraft:glow_lichen",
|
||||
"minecraft:sculk_vein",
|
||||
"minecraft:vine",
|
||||
"minecraft:cocoa",
|
||||
"minecraft:bee_nest",
|
||||
"minecraft:creaking_heart",
|
||||
"minecraft:pale_hanging_moss",
|
||||
"minecraft:shelf_mushroom",
|
||||
"minecraft:water",
|
||||
"minecraft:lava",
|
||||
"minecraft:air",
|
||||
"minecraft:cave_air",
|
||||
"minecraft:dirt",
|
||||
"minecraft:mud",
|
||||
];
|
||||
impl TreeBlocks {
|
||||
pub(crate) fn build(bindings: &FeatureBlockBindings<'_>) -> Result<Self, DecodeError> {
|
||||
let registry: &BlockRegistry = bindings.registry();
|
||||
let (providers, _, _) = bindings
|
||||
.simple_blocks
|
||||
.as_ref()
|
||||
.ok_or(DecodeError::Field("tree state provider bindings"))?;
|
||||
let properties = providers.properties()?;
|
||||
let replaceable = super::block_predicate::PredicateBlockResolver::predicate_property(
|
||||
bindings,
|
||||
BlockProperty::Replaceable,
|
||||
)?;
|
||||
let solid_render = super::block_predicate::PredicateBlockResolver::predicate_property(
|
||||
bindings,
|
||||
BlockProperty::SolidRender,
|
||||
)?;
|
||||
let solid = super::block_predicate::PredicateBlockResolver::predicate_property(
|
||||
bindings,
|
||||
BlockProperty::Solid,
|
||||
)?;
|
||||
let liquid = super::block_predicate::PredicateBlockResolver::predicate_property(
|
||||
bindings,
|
||||
BlockProperty::Liquid,
|
||||
)?;
|
||||
let mut flags = vec![0u32; registry.len()];
|
||||
let mut distance = vec![0u8; registry.len()];
|
||||
let mark_tag = |tag: &str, flag: u32, flags: &mut Vec<u32>| {
|
||||
if let Some(states) = bindings.tags.get(tag) {
|
||||
for state in states.iter() {
|
||||
flags[state.0 as usize] |= flag;
|
||||
}
|
||||
}
|
||||
};
|
||||
mark_tag("minecraft:leaves", LEAVES, &mut flags);
|
||||
mark_tag(
|
||||
"minecraft:replaceable_by_trees",
|
||||
REPLACEABLE_BY_TREES,
|
||||
&mut flags,
|
||||
);
|
||||
mark_tag("minecraft:logs", LOGS, &mut flags);
|
||||
mark_tag(
|
||||
"minecraft:prevents_nearby_leaf_decay",
|
||||
PREVENTS_LEAF_DECAY,
|
||||
&mut flags,
|
||||
);
|
||||
mark_tag(
|
||||
"minecraft:replaceable_by_mushrooms",
|
||||
MUSHROOM_REPLACEABLE,
|
||||
&mut flags,
|
||||
);
|
||||
mark_tag("minecraft:fire", FIRE, &mut flags);
|
||||
mark_tag(
|
||||
"minecraft:base_stone_overworld",
|
||||
BASE_STONE_OVERWORLD,
|
||||
&mut flags,
|
||||
);
|
||||
mark_tag(
|
||||
"minecraft:features_cannot_replace",
|
||||
FEATURES_CANNOT_REPLACE,
|
||||
&mut flags,
|
||||
);
|
||||
for (name, flag) in [
|
||||
("minecraft:vine", VINE),
|
||||
("minecraft:water", WATER_BLOCK),
|
||||
("minecraft:shelf_mushroom", SHELF_MUSHROOM),
|
||||
("minecraft:sculk", SCULK_BLOCKER),
|
||||
("minecraft:sculk_catalyst", SCULK_BLOCKER),
|
||||
("minecraft:moving_piston", SCULK_BLOCKER),
|
||||
("minecraft:sculk_vein", SCULK_VEIN),
|
||||
("minecraft:chest", CHEST),
|
||||
("minecraft:spawner", SPAWNER),
|
||||
] {
|
||||
if let Some(states) = bindings.blocks.get(name) {
|
||||
for state in states.iter() {
|
||||
flags[state.0 as usize] |= flag;
|
||||
}
|
||||
}
|
||||
}
|
||||
for air in bindings.air {
|
||||
flags[air.0 as usize] |= AIR;
|
||||
}
|
||||
for index in 0..registry.len() {
|
||||
let id = BlockStateId(index as u32);
|
||||
let flag = &mut flags[index];
|
||||
if replaceable.contains(id) {
|
||||
*flag |= REPLACEABLE;
|
||||
}
|
||||
if solid_render.contains(id) {
|
||||
*flag |= SOLID_RENDER;
|
||||
}
|
||||
if solid.contains(id) {
|
||||
*flag |= SOLID;
|
||||
}
|
||||
if liquid.contains(id) {
|
||||
*flag |= LIQUID;
|
||||
}
|
||||
if let Some(fluid) = bindings.fluids.state(id) {
|
||||
match fluid.kind() {
|
||||
FluidKind::Water => *flag |= WATER_SOURCE | WATER_FLUID | ANY_FLUID,
|
||||
FluidKind::FlowingWater => *flag |= WATER_FLUID | ANY_FLUID,
|
||||
FluidKind::Lava | FluidKind::FlowingLava => *flag |= LAVA_FLUID | ANY_FLUID,
|
||||
FluidKind::Empty => {}
|
||||
}
|
||||
if fluid.is_source() {
|
||||
*flag |= FLUID_SOURCE;
|
||||
}
|
||||
if fluid.amount() == 8 {
|
||||
*flag |= FLUID_FULL;
|
||||
}
|
||||
}
|
||||
if properties.value(id, "persistent") == Some("true") {
|
||||
*flag |= PERSISTENT;
|
||||
}
|
||||
if properties
|
||||
.values(id, "waterlogged")
|
||||
.is_some_and(|v| v.len() == 2)
|
||||
{
|
||||
*flag |= WATERLOGGABLE;
|
||||
}
|
||||
if properties.values(id, "axis").is_some_and(|values| {
|
||||
values.len() == 3
|
||||
&& ["x", "y", "z"]
|
||||
.iter()
|
||||
.all(|a| values.iter().any(|v| v == a))
|
||||
}) {
|
||||
*flag |= FULL_AXIS;
|
||||
}
|
||||
if let Some(values) = properties.values(id, "distance") {
|
||||
let native = values.len() == 7
|
||||
&& (1..=7).all(|n| values.iter().any(|v| *v == n.to_string()));
|
||||
if native {
|
||||
distance[index] = properties
|
||||
.value(id, "distance")
|
||||
.and_then(|v| v.parse().ok())
|
||||
.unwrap_or(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut names = BTreeMap::new();
|
||||
let block = (0..registry.len())
|
||||
.map(|i| {
|
||||
let name = ®istry.state(BlockStateId(i as u32)).unwrap().name;
|
||||
let next = names.len() as u32;
|
||||
*names.entry(name.clone()).or_insert(next)
|
||||
})
|
||||
.collect();
|
||||
let defaults = DEFAULTS
|
||||
.iter()
|
||||
.filter_map(|name| {
|
||||
registry
|
||||
.default_state(name)
|
||||
.map(|id| ((*name).to_owned(), id))
|
||||
})
|
||||
.collect();
|
||||
Ok(Self {
|
||||
flags,
|
||||
distance,
|
||||
block,
|
||||
properties,
|
||||
defaults,
|
||||
})
|
||||
}
|
||||
pub(crate) fn has(&self, state: BlockStateId, flag: u32) -> bool {
|
||||
self.flags
|
||||
.get(state.0 as usize)
|
||||
.is_some_and(|value| value & flag != 0)
|
||||
}
|
||||
/// BlockState.is(Block): same block, any properties.
|
||||
pub(crate) fn same_block(&self, a: BlockStateId, b: BlockStateId) -> bool {
|
||||
self.block.get(a.0 as usize) == self.block.get(b.0 as usize)
|
||||
}
|
||||
pub(crate) fn is_air(&self, state: BlockStateId) -> bool {
|
||||
self.has(state, AIR)
|
||||
}
|
||||
/// TreeFeature.validTreePos: air or replaceable by trees.
|
||||
pub(crate) fn valid_tree_pos(&self, state: BlockStateId) -> bool {
|
||||
self.has(state, AIR | REPLACEABLE_BY_TREES)
|
||||
}
|
||||
/// LeavesBlock.getOptionalDistanceAt.
|
||||
pub(crate) fn leaf_distance(&self, state: BlockStateId) -> Option<i32> {
|
||||
if self.has(state, PREVENTS_LEAF_DECAY) {
|
||||
return Some(0);
|
||||
}
|
||||
match self.distance.get(state.0 as usize) {
|
||||
Some(0) | None => None,
|
||||
Some(d) => Some(i32::from(*d)),
|
||||
}
|
||||
}
|
||||
pub(crate) fn default_state(&self, name: &str) -> Option<BlockStateId> {
|
||||
self.defaults.get(name).copied()
|
||||
}
|
||||
pub(crate) fn with(
|
||||
&self,
|
||||
state: BlockStateId,
|
||||
name: &str,
|
||||
value: &str,
|
||||
) -> Option<BlockStateId> {
|
||||
self.properties.with_value(state, name, value)
|
||||
}
|
||||
/// BlockState.trySetValue(RotatedPillarBlock.AXIS, axis).
|
||||
pub(crate) fn try_axis(&self, state: BlockStateId, axis: Axis) -> BlockStateId {
|
||||
if self.has(state, FULL_AXIS) {
|
||||
self.with(state, "axis", axis.name()).unwrap_or(state)
|
||||
} else {
|
||||
state
|
||||
}
|
||||
}
|
||||
/// Set WATERLOGGED when the state has that property; otherwise unchanged.
|
||||
pub(crate) fn waterlogged(&self, state: BlockStateId, value: bool) -> BlockStateId {
|
||||
if self.has(state, WATERLOGGABLE) {
|
||||
self.with(state, "waterlogged", if value { "true" } else { "false" })
|
||||
.unwrap_or(state)
|
||||
} else {
|
||||
state
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(crate) enum Axis {
|
||||
X,
|
||||
Y,
|
||||
Z,
|
||||
}
|
||||
impl Axis {
|
||||
pub(crate) fn name(self) -> &'static str {
|
||||
match self {
|
||||
Self::X => "x",
|
||||
Self::Y => "y",
|
||||
Self::Z => "z",
|
||||
}
|
||||
}
|
||||
pub(crate) fn of(direction: Direction) -> Self {
|
||||
match direction {
|
||||
Direction::West | Direction::East => Self::X,
|
||||
Direction::Down | Direction::Up => Self::Y,
|
||||
Direction::North | Direction::South => Self::Z,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Direction.Plane.HORIZONTAL order.
|
||||
pub(crate) const HORIZONTAL: [Direction; 4] = [
|
||||
Direction::North,
|
||||
Direction::East,
|
||||
Direction::South,
|
||||
Direction::West,
|
||||
];
|
||||
pub(crate) fn clockwise(direction: Direction) -> Direction {
|
||||
match direction {
|
||||
Direction::North => Direction::East,
|
||||
Direction::East => Direction::South,
|
||||
Direction::South => Direction::West,
|
||||
Direction::West => Direction::North,
|
||||
other => other,
|
||||
}
|
||||
}
|
||||
pub(crate) fn direction_name(direction: Direction) -> &'static str {
|
||||
match direction {
|
||||
Direction::Down => "down",
|
||||
Direction::Up => "up",
|
||||
Direction::North => "north",
|
||||
Direction::South => "south",
|
||||
Direction::West => "west",
|
||||
Direction::East => "east",
|
||||
}
|
||||
}
|
||||
pub(crate) fn decode_direction(name: &str) -> Result<Direction, DecodeError> {
|
||||
Direction::ALL
|
||||
.into_iter()
|
||||
.find(|d| direction_name(*d) == name)
|
||||
.ok_or(DecodeError::Field("direction"))
|
||||
}
|
||||
pub(crate) fn offset(p: [i32; 3], dx: i32, dy: i32, dz: i32) -> [i32; 3] {
|
||||
[
|
||||
p[0].wrapping_add(dx),
|
||||
p[1].wrapping_add(dy),
|
||||
p[2].wrapping_add(dz),
|
||||
]
|
||||
}
|
||||
pub(crate) fn relative(p: [i32; 3], direction: Direction, distance: i32) -> [i32; 3] {
|
||||
let n = direction.normal();
|
||||
offset(
|
||||
p,
|
||||
n[0].wrapping_mul(distance),
|
||||
n[1].wrapping_mul(distance),
|
||||
n[2].wrapping_mul(distance),
|
||||
)
|
||||
}
|
||||
/// Vec3i.distManhattan, including its float accumulation.
|
||||
pub(crate) fn dist_manhattan(a: [i32; 3], b: [i32; 3]) -> i32 {
|
||||
let d = |i: usize| b[i].wrapping_sub(a[i]).wrapping_abs() as f32;
|
||||
(d(0) + d(1) + d(2)) as i32
|
||||
}
|
||||
|
||||
/// Java HashSet<BlockPos> with native bucket iteration order.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(crate) struct JavaPos(pub [i32; 3]);
|
||||
impl crate::java_hash_map::JavaKey for JavaPos {
|
||||
fn java_hash(&self) -> i32 {
|
||||
let [x, y, z] = self.0;
|
||||
y.wrapping_add(z.wrapping_mul(31))
|
||||
.wrapping_mul(31)
|
||||
.wrapping_add(x)
|
||||
}
|
||||
fn tie_break(&self, other: &Self) -> std::cmp::Ordering {
|
||||
// BlockPos is not self-Comparable for HashMap; vanilla falls back to
|
||||
// identity hashes, which are not reproducible. Any total order works.
|
||||
let key = |p: &Self| (p.0[1], p.0[2], p.0[0]);
|
||||
match key(self).cmp(&key(other)) {
|
||||
std::cmp::Ordering::Equal => std::cmp::Ordering::Less,
|
||||
ordering => ordering,
|
||||
}
|
||||
}
|
||||
}
|
||||
#[derive(Default)]
|
||||
pub(crate) struct PosSet(crate::java_hash_map::JavaHashMap<JavaPos, ()>);
|
||||
impl PosSet {
|
||||
pub(crate) fn insert(&mut self, p: [i32; 3]) -> bool {
|
||||
self.0.put(JavaPos(p), ()).is_none()
|
||||
}
|
||||
pub(crate) fn contains(&self, p: [i32; 3]) -> bool {
|
||||
self.0.get(&JavaPos(p)).is_some()
|
||||
}
|
||||
pub(crate) fn is_empty(&self) -> bool {
|
||||
self.0.is_empty()
|
||||
}
|
||||
/// Iteration order of the native set.
|
||||
pub(crate) fn to_vec(&self) -> Vec<[i32; 3]> {
|
||||
self.0.entries().map(|(k, _)| k.0).collect()
|
||||
}
|
||||
/// iterator().next() followed by iterator.remove().
|
||||
pub(crate) fn pop_first(&mut self) -> Option<[i32; 3]> {
|
||||
let mut cursor = self.0.cursor();
|
||||
let first = self.0.next_entry(&mut cursor).ok().flatten()?.0.0;
|
||||
self.0.remove_current(&mut cursor).ok()?;
|
||||
Some(first)
|
||||
}
|
||||
}
|
||||
|
||||
/// Util.shuffle (Fisher-Yates from the end with nextInt(i)).
|
||||
pub(crate) fn shuffle<T>(
|
||||
values: &mut [T],
|
||||
random: &mut impl horizon_core::random::RandomSource,
|
||||
) -> Result<(), horizon_core::random::InvalidBound> {
|
||||
for i in (2..=values.len()).rev() {
|
||||
let swap = random.next_int_bound(i as i32)? as usize;
|
||||
values.swap(i - 1, swap);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use horizon_core::random::{LegacyRandom, RandomSource};
|
||||
#[test]
|
||||
fn pos_set_iterates_in_java_hash_bucket_order() {
|
||||
let mut set = PosSet::default();
|
||||
let inserted = [[0, 64, 1], [1, 64, 0], [0, 65, 0], [0, 64, 0]];
|
||||
for p in inserted {
|
||||
set.insert(p);
|
||||
}
|
||||
// BlockPos.hashCode spread by h ^ (h >>> 16) into 16 buckets; ties keep
|
||||
// insertion order within a bucket.
|
||||
let mut expected = inserted.to_vec();
|
||||
expected.sort_by_key(|p| {
|
||||
let h = crate::java_hash_map::JavaKey::java_hash(&JavaPos(*p)) as u32;
|
||||
(h ^ (h >> 16)) & 15
|
||||
});
|
||||
assert_eq!(set.to_vec(), expected);
|
||||
assert_eq!(set.pop_first(), Some(expected[0]));
|
||||
assert!(!set.contains(expected[0]));
|
||||
}
|
||||
#[test]
|
||||
fn fisher_yates_matches_native_draw_order() {
|
||||
let mut values = [0, 1, 2, 3];
|
||||
shuffle(&mut values, &mut LegacyRandom::new(42)).unwrap();
|
||||
let mut reference = [0, 1, 2, 3];
|
||||
let mut random = LegacyRandom::new(42);
|
||||
for i in (2..=4).rev() {
|
||||
let j = random.next_int_bound(i).unwrap() as usize;
|
||||
reference.swap(i as usize - 1, j);
|
||||
}
|
||||
assert_eq!(values, reference);
|
||||
}
|
||||
}
|
||||
@@ -8,8 +8,21 @@ use serde_json::value::RawValue;
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum FloatProvider {
|
||||
Constant(f32),
|
||||
Uniform { min: f32, max: f32 },
|
||||
Trapezoid { min: f32, max: f32, plateau: f32 },
|
||||
Uniform {
|
||||
min: f32,
|
||||
max: f32,
|
||||
},
|
||||
Trapezoid {
|
||||
min: f32,
|
||||
max: f32,
|
||||
plateau: f32,
|
||||
},
|
||||
ClampedNormal {
|
||||
mean: f32,
|
||||
deviation: f32,
|
||||
min: f32,
|
||||
max: f32,
|
||||
},
|
||||
}
|
||||
impl FloatProvider {
|
||||
pub fn from_json(json: &str) -> Result<Self, DecodeError> {
|
||||
@@ -38,13 +51,27 @@ impl FloatProvider {
|
||||
}
|
||||
Ok(Self::Trapezoid { min, max, plateau })
|
||||
}
|
||||
"minecraft:clamped_normal" => {
|
||||
let (min, max) = (field("min")?, field("max")?);
|
||||
if max < min {
|
||||
return Err(DecodeError::Field("clamped normal float bounds"));
|
||||
}
|
||||
Ok(Self::ClampedNormal {
|
||||
mean: field("mean")?,
|
||||
deviation: field("deviation")?,
|
||||
min,
|
||||
max,
|
||||
})
|
||||
}
|
||||
_ => Err(DecodeError::Field("float provider type")),
|
||||
}
|
||||
}
|
||||
pub fn bounds(&self) -> [f32; 2] {
|
||||
match *self {
|
||||
Self::Constant(value) => [value; 2],
|
||||
Self::Uniform { min, max } | Self::Trapezoid { min, max, .. } => [min, max],
|
||||
Self::Uniform { min, max }
|
||||
| Self::Trapezoid { min, max, .. }
|
||||
| Self::ClampedNormal { min, max, .. } => [min, max],
|
||||
}
|
||||
}
|
||||
pub fn sample(&self, random: &mut impl RandomSource) -> f32 {
|
||||
@@ -57,6 +84,15 @@ impl FloatProvider {
|
||||
let middle = range - slope;
|
||||
(min + random.next_float() * middle) + random.next_float() * slope
|
||||
}
|
||||
Self::ClampedNormal {
|
||||
mean,
|
||||
deviation,
|
||||
min,
|
||||
max,
|
||||
} => {
|
||||
let value = mean + random.next_gaussian() as f32 * deviation;
|
||||
if value < min { min } else { value.min(max) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -87,6 +123,12 @@ pub enum IntProvider {
|
||||
min: i32,
|
||||
max: i32,
|
||||
},
|
||||
ClampedNormal {
|
||||
mean: f32,
|
||||
deviation: f32,
|
||||
min: i32,
|
||||
max: i32,
|
||||
},
|
||||
}
|
||||
impl IntProvider {
|
||||
pub fn from_json(json: &str) -> Result<Self, DecodeError> {
|
||||
@@ -134,6 +176,12 @@ impl IntProvider {
|
||||
}
|
||||
Ok(Self::Trapezoid { min, max, plateau })
|
||||
}
|
||||
"minecraft:clamped_normal" => Ok(Self::ClampedNormal {
|
||||
mean: required(&object, "mean").and_then(float)?,
|
||||
deviation: required(&object, "deviation").and_then(float)?,
|
||||
min,
|
||||
max,
|
||||
}),
|
||||
"minecraft:clamped" => Ok(Self::Clamped {
|
||||
source: Box::new(Self::decode(
|
||||
required(&object, "source")?,
|
||||
@@ -160,7 +208,8 @@ impl IntProvider {
|
||||
Self::Uniform { min, max }
|
||||
| Self::BiasedToBottom { min, max }
|
||||
| Self::VeryBiasedToBottom { min, max }
|
||||
| Self::Trapezoid { min, max, .. } => [*min, *max],
|
||||
| Self::Trapezoid { min, max, .. }
|
||||
| Self::ClampedNormal { min, max, .. } => [*min, *max],
|
||||
Self::Clamped { source, min, max } => {
|
||||
let bounds = source.bounds();
|
||||
[(*min).max(bounds[0]), (*max).min(bounds[1])]
|
||||
@@ -200,6 +249,17 @@ impl IntProvider {
|
||||
let value = source.sample(random)?;
|
||||
Ok(if value < *min { *min } else { value.min(*max) })
|
||||
}
|
||||
// Mth.normal, then float Mth.clamp and a saturating int cast.
|
||||
Self::ClampedNormal {
|
||||
mean,
|
||||
deviation,
|
||||
min,
|
||||
max,
|
||||
} => {
|
||||
let value = mean + random.next_gaussian() as f32 * deviation;
|
||||
let (min, max) = (*min as f32, *max as f32);
|
||||
Ok((if value < min { min } else { value.min(max) }) as i32)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,847 @@
|
||||
//! Vegetation and cave-decoration features: vegetation patches (plain and
|
||||
//! waterlogged), coral trees/claws, huge mushrooms and multiface growth.
|
||||
use super::{
|
||||
DecodeError, Object,
|
||||
block_feature::FeatureBlockBindings,
|
||||
block_predicate::BlockPredicate,
|
||||
feature::FeatureWorld,
|
||||
feature_graph::{FeatureExecutionError, PlacedFeatureDefinition},
|
||||
int_range, optional,
|
||||
placement::PlacementContext,
|
||||
required,
|
||||
state_provider::BlockStateProvider,
|
||||
tree::{TreeDecoder, TreeResult, kind, read, sample_state, unit_float, write},
|
||||
tree_blocks::{self as tb, PosSet, TreeBlocks},
|
||||
value_provider::IntProvider,
|
||||
};
|
||||
use crate::registry::BlockStateId;
|
||||
use horizon_core::{geometry::Direction, random::RandomSource};
|
||||
use std::{collections::BTreeSet, sync::Arc};
|
||||
|
||||
/// Places a nested placed feature with the caller's run budget.
|
||||
pub(crate) type PlacedPlacer<'a, W, R> = dyn FnMut(
|
||||
&PlacedFeatureDefinition,
|
||||
&mut W,
|
||||
&mut R,
|
||||
[i32; 3],
|
||||
) -> TreeResult<bool, <W as FeatureWorld>::Error>
|
||||
+ 'a;
|
||||
pub(crate) type PlacedDecoder<'a> =
|
||||
dyn Fn(&str, usize, &mut usize) -> Result<PlacedFeatureDefinition, DecodeError> + 'a;
|
||||
|
||||
fn query<E>(error: super::placement::PlacementQueryError) -> FeatureExecutionError<E> {
|
||||
FeatureExecutionError::Query(error)
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct VegetationPatchFeature {
|
||||
replaceable: Arc<BTreeSet<BlockStateId>>,
|
||||
ground: BlockStateProvider,
|
||||
vegetation: Box<PlacedFeatureDefinition>,
|
||||
/// CaveSurface direction: DOWN for floor, UP for ceiling.
|
||||
inwards: Direction,
|
||||
depth: IntProvider,
|
||||
extra_bottom: f32,
|
||||
vertical_range: i32,
|
||||
vegetation_chance: f32,
|
||||
xz_radius: IntProvider,
|
||||
extra_edge: f32,
|
||||
waterlogged: bool,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
impl VegetationPatchFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
nested: &PlacedDecoder<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
let waterlogged = match kind(&object)?.as_str() {
|
||||
"minecraft:vegetation_patch" => false,
|
||||
"minecraft:waterlogged_vegetation_patch" => true,
|
||||
_ => return Err(DecodeError::Field("vegetation patch type")),
|
||||
};
|
||||
let blocks = bindings.tree_blocks()?;
|
||||
let mut decoder = TreeDecoder {
|
||||
bindings,
|
||||
depth,
|
||||
remaining,
|
||||
};
|
||||
let surface: String = serde_json::from_str(required(&object, "surface")?.get())?;
|
||||
let inwards = match surface.as_str() {
|
||||
"floor" => Direction::Down,
|
||||
"ceiling" => Direction::Up,
|
||||
_ => return Err(DecodeError::Field("cave surface")),
|
||||
};
|
||||
let vegetation = nested(
|
||||
required(&object, "vegetation_feature")?.get(),
|
||||
depth + 1,
|
||||
decoder.remaining,
|
||||
)?;
|
||||
Ok(Self {
|
||||
replaceable: decoder.block_set(required(&object, "replaceable")?)?,
|
||||
ground: decoder.provider(required(&object, "ground_state")?)?,
|
||||
vegetation: Box::new(vegetation),
|
||||
inwards,
|
||||
depth: decoder.int_provider(required(&object, "depth")?, 1, 128)?,
|
||||
extra_bottom: unit_float(
|
||||
required(&object, "extra_bottom_block_chance")?,
|
||||
"extra_bottom_block_chance",
|
||||
)?,
|
||||
vertical_range: int_range(
|
||||
required(&object, "vertical_range")?,
|
||||
"vertical_range",
|
||||
1,
|
||||
256,
|
||||
)?,
|
||||
vegetation_chance: unit_float(
|
||||
required(&object, "vegetation_chance")?,
|
||||
"vegetation_chance",
|
||||
)?,
|
||||
xz_radius: IntProvider::decode(
|
||||
required(&object, "xz_radius")?,
|
||||
depth + 1,
|
||||
decoder.remaining,
|
||||
)?,
|
||||
extra_edge: unit_float(
|
||||
required(&object, "extra_edge_column_chance")?,
|
||||
"extra_edge_column_chance",
|
||||
)?,
|
||||
waterlogged,
|
||||
blocks,
|
||||
})
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
nested: &mut PlacedPlacer<'_, W, R>,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let x_radius = self.xz_radius.sample(random)?.wrapping_add(1);
|
||||
let z_radius = self.xz_radius.sample(random)?.wrapping_add(1);
|
||||
let mut surface = self.ground_patch(world, random, origin, x_radius, z_radius)?;
|
||||
if self.waterlogged {
|
||||
let mut water = PosSet::default();
|
||||
for p in surface.to_vec() {
|
||||
let mut exposed = false;
|
||||
for direction in [
|
||||
Direction::North,
|
||||
Direction::East,
|
||||
Direction::South,
|
||||
Direction::West,
|
||||
Direction::Down,
|
||||
] {
|
||||
let q = tb::relative(p, direction, 1);
|
||||
let state = read(world, q)?;
|
||||
if !world
|
||||
.state_face_sturdy(state, q, direction.opposite())
|
||||
.map_err(query)?
|
||||
{
|
||||
exposed = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if !exposed {
|
||||
water.insert(p);
|
||||
}
|
||||
}
|
||||
let water_state = self
|
||||
.blocks
|
||||
.default_state("minecraft:water")
|
||||
.ok_or(FeatureExecutionError::InvalidState)?;
|
||||
for p in water.to_vec() {
|
||||
write(world, p, water_state, 2)?;
|
||||
}
|
||||
surface = water;
|
||||
}
|
||||
let positions = surface.to_vec();
|
||||
for p in &positions {
|
||||
if self.vegetation_chance > 0.0 && random.next_float() < self.vegetation_chance {
|
||||
self.place_vegetation(world, random, *p, nested)?;
|
||||
}
|
||||
}
|
||||
Ok(!positions.is_empty())
|
||||
}
|
||||
fn place_vegetation<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
position: [i32; 3],
|
||||
nested: &mut PlacedPlacer<'_, W, R>,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let outwards = self.inwards.opposite();
|
||||
if !self.waterlogged {
|
||||
return nested(
|
||||
&self.vegetation,
|
||||
world,
|
||||
random,
|
||||
tb::relative(position, outwards, 1),
|
||||
);
|
||||
}
|
||||
// WaterloggedVegetationPatchFeature passes placementPos.below() to super.
|
||||
let below = tb::offset(position, 0, -1, 0);
|
||||
if nested(
|
||||
&self.vegetation,
|
||||
world,
|
||||
random,
|
||||
tb::relative(below, outwards, 1),
|
||||
)? {
|
||||
let placed = read(world, position)?;
|
||||
if self.blocks.has(placed, tb::WATERLOGGABLE)
|
||||
&& self.blocks.properties.value(placed, "waterlogged") == Some("false")
|
||||
{
|
||||
write(world, position, self.blocks.waterlogged(placed, true), 2)?;
|
||||
}
|
||||
return Ok(true);
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
fn ground_patch<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
x_radius: i32,
|
||||
z_radius: i32,
|
||||
) -> TreeResult<PosSet, W::Error> {
|
||||
let inwards = self.inwards;
|
||||
let outwards = inwards.opposite();
|
||||
let mut surface = PosSet::default();
|
||||
let mut dx = x_radius.wrapping_neg();
|
||||
while dx <= x_radius {
|
||||
let x_edge = dx == x_radius.wrapping_neg() || dx == x_radius;
|
||||
let mut dz = z_radius.wrapping_neg();
|
||||
while dz <= z_radius {
|
||||
let z_edge = dz == z_radius.wrapping_neg() || dz == z_radius;
|
||||
let edge = x_edge || z_edge;
|
||||
let corner = x_edge && z_edge;
|
||||
let edge_not_corner = edge && !corner;
|
||||
if !corner
|
||||
&& (!edge_not_corner
|
||||
|| (self.extra_edge != 0.0 && random.next_float() <= self.extra_edge))
|
||||
{
|
||||
let mut pos = tb::offset(origin, dx, 0, dz);
|
||||
let mut offset = 0;
|
||||
while self.blocks.is_air(read(world, pos)?) && offset < self.vertical_range {
|
||||
pos = tb::relative(pos, inwards, 1);
|
||||
offset += 1;
|
||||
}
|
||||
let mut offset = 0;
|
||||
while !self.blocks.is_air(read(world, pos)?) && offset < self.vertical_range {
|
||||
pos = tb::relative(pos, outwards, 1);
|
||||
offset += 1;
|
||||
}
|
||||
let below = tb::relative(pos, inwards, 1);
|
||||
let below_state = read(world, below)?;
|
||||
if self.blocks.is_air(read(world, pos)?)
|
||||
&& world
|
||||
.state_face_sturdy(below_state, below, outwards)
|
||||
.map_err(query)?
|
||||
{
|
||||
let depth = self.depth.sample(random)?.wrapping_add(i32::from(
|
||||
self.extra_bottom > 0.0 && random.next_float() < self.extra_bottom,
|
||||
));
|
||||
if self.place_ground(world, random, below, depth)? {
|
||||
surface.insert(below);
|
||||
}
|
||||
}
|
||||
}
|
||||
dz += 1;
|
||||
}
|
||||
dx += 1;
|
||||
}
|
||||
Ok(surface)
|
||||
}
|
||||
fn place_ground<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
mut below: [i32; 3],
|
||||
depth: i32,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
for i in 0..depth {
|
||||
let state = sample_state(&self.ground, world, random, below)?;
|
||||
let existing = read(world, below)?;
|
||||
if !self.blocks.same_block(state, existing) {
|
||||
if !self.replaceable.contains(&existing) {
|
||||
return Ok(i != 0);
|
||||
}
|
||||
write(world, below, state, 2)?;
|
||||
below = tb::relative(below, self.inwards, 1);
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct CoralFeature {
|
||||
claw: bool,
|
||||
feature: Box<PlacedFeatureDefinition>,
|
||||
}
|
||||
impl CoralFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
nested: &PlacedDecoder<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
let claw = match kind(&object)?.as_str() {
|
||||
"minecraft:coral_tree" => false,
|
||||
"minecraft:coral_claw" => true,
|
||||
_ => return Err(DecodeError::Field("coral feature type")),
|
||||
};
|
||||
Ok(Self {
|
||||
claw,
|
||||
feature: Box::new(nested(
|
||||
required(&object, "feature")?.get(),
|
||||
depth + 1,
|
||||
remaining,
|
||||
)?),
|
||||
})
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
nested: &mut PlacedPlacer<'_, W, R>,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let feature = &*self.feature;
|
||||
if !self.claw {
|
||||
let mut pos = origin;
|
||||
let trunk = random.next_int_bound(3)? + 1;
|
||||
for _ in 0..trunk {
|
||||
if !nested(feature, world, random, pos)? {
|
||||
return Ok(true);
|
||||
}
|
||||
pos = tb::offset(pos, 0, 1, 0);
|
||||
}
|
||||
let top = pos;
|
||||
let branches = random.next_int_bound(3)? + 2;
|
||||
let mut directions = tb::HORIZONTAL;
|
||||
tb::shuffle(&mut directions, random)?;
|
||||
for &direction in directions.iter().take(branches as usize) {
|
||||
let mut pos = tb::relative(top, direction, 1);
|
||||
let height = random.next_int_bound(5)? + 2;
|
||||
let mut segment = 0;
|
||||
let mut j = 0;
|
||||
while j < height && nested(feature, world, random, pos)? {
|
||||
segment += 1;
|
||||
pos = tb::offset(pos, 0, 1, 0);
|
||||
if j == 0 || (segment >= 2 && random.next_float() < 0.25) {
|
||||
pos = tb::relative(pos, direction, 1);
|
||||
segment = 0;
|
||||
}
|
||||
j += 1;
|
||||
}
|
||||
}
|
||||
return Ok(true);
|
||||
}
|
||||
if !nested(feature, world, random, origin)? {
|
||||
return Ok(false);
|
||||
}
|
||||
let claw = tb::HORIZONTAL[random.next_int_bound(4)? as usize];
|
||||
let branches = random.next_int_bound(2)? + 2;
|
||||
let mut possible = [claw, tb::clockwise(claw), counter_clockwise(claw)];
|
||||
tb::shuffle(&mut possible, random)?;
|
||||
for &branch in possible.iter().take(branches as usize) {
|
||||
let mut pos = origin;
|
||||
let sideways = random.next_int_bound(2)? + 1;
|
||||
pos = tb::relative(pos, branch, 1);
|
||||
let (segment, inway) = if branch == claw {
|
||||
(claw, random.next_int_bound(3)? + 2)
|
||||
} else {
|
||||
pos = tb::offset(pos, 0, 1, 0);
|
||||
let options = [branch, Direction::Up];
|
||||
let segment = options[random.next_int_bound(2)? as usize];
|
||||
(segment, random.next_int_bound(3)? + 3)
|
||||
};
|
||||
let mut i = 0;
|
||||
while i < sideways && nested(feature, world, random, pos)? {
|
||||
pos = tb::relative(pos, segment, 1);
|
||||
i += 1;
|
||||
}
|
||||
pos = tb::relative(pos, segment.opposite(), 1);
|
||||
pos = tb::offset(pos, 0, 1, 0);
|
||||
for _ in 0..inway {
|
||||
pos = tb::relative(pos, claw, 1);
|
||||
if !nested(feature, world, random, pos)? {
|
||||
break;
|
||||
}
|
||||
if random.next_float() < 0.25 {
|
||||
pos = tb::offset(pos, 0, 1, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
pub(crate) fn counter_clockwise(direction: Direction) -> Direction {
|
||||
match direction {
|
||||
Direction::North => Direction::West,
|
||||
Direction::East => Direction::North,
|
||||
Direction::South => Direction::East,
|
||||
Direction::West => Direction::South,
|
||||
other => other,
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct HugeMushroomFeature {
|
||||
red: bool,
|
||||
cap: BlockStateProvider,
|
||||
stem: BlockStateProvider,
|
||||
foliage_radius: i32,
|
||||
can_place_on: BlockPredicate,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
impl HugeMushroomFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
depth: usize,
|
||||
remaining: &mut usize,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
let red = match kind(&object)?.as_str() {
|
||||
"minecraft:huge_red_mushroom" => true,
|
||||
"minecraft:huge_brown_mushroom" => false,
|
||||
_ => return Err(DecodeError::Field("huge mushroom type")),
|
||||
};
|
||||
let blocks = bindings.tree_blocks()?;
|
||||
let mut decoder = TreeDecoder {
|
||||
bindings,
|
||||
depth,
|
||||
remaining,
|
||||
};
|
||||
let cap = decoder.provider(required(&object, "cap_provider")?)?;
|
||||
let stem = decoder.provider(required(&object, "stem_provider")?)?;
|
||||
let foliage_radius = optional(&object, "foliage_radius")
|
||||
.map(super::integer)
|
||||
.transpose()?
|
||||
.unwrap_or(2);
|
||||
let can_place_on = BlockPredicate::decode_with_blocks(
|
||||
required(&object, "can_place_on")?.get(),
|
||||
depth + 1,
|
||||
decoder.remaining,
|
||||
Some(bindings),
|
||||
)?;
|
||||
Ok(Self {
|
||||
red,
|
||||
cap,
|
||||
stem,
|
||||
foliage_radius,
|
||||
can_place_on,
|
||||
blocks,
|
||||
})
|
||||
}
|
||||
fn radius_for_height(&self, tree_height: i32, leaf_radius: i32, yo: i32) -> i32 {
|
||||
if self.red {
|
||||
if (yo < tree_height && yo >= tree_height - 3) || yo == tree_height {
|
||||
leaf_radius
|
||||
} else {
|
||||
0
|
||||
}
|
||||
} else if yo <= 3 {
|
||||
0
|
||||
} else {
|
||||
leaf_radius
|
||||
}
|
||||
}
|
||||
fn place_block<W: FeatureWorld>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
p: [i32; 3],
|
||||
state: BlockStateId,
|
||||
) -> TreeResult<(), W::Error> {
|
||||
let current = read(world, p)?;
|
||||
if self.blocks.has(current, tb::AIR | tb::MUSHROOM_REPLACEABLE) {
|
||||
write(world, p, state, 3)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn faces(&self, state: BlockStateId, faces: &[(&str, bool)]) -> BlockStateId {
|
||||
if faces
|
||||
.iter()
|
||||
.all(|(name, _)| self.blocks.properties.value(state, name).is_some())
|
||||
{
|
||||
faces.iter().fold(state, |state, (name, value)| {
|
||||
self.blocks
|
||||
.with(state, name, if *value { "true" } else { "false" })
|
||||
.unwrap_or(state)
|
||||
})
|
||||
} else {
|
||||
state
|
||||
}
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let mut height = random.next_int_bound(3)? + 4;
|
||||
if random.next_int_bound(12)? == 0 {
|
||||
height *= 2;
|
||||
}
|
||||
let y = origin[1];
|
||||
let min = world.min_y().map_err(query)?;
|
||||
let max = world.max_y().map_err(query)?;
|
||||
if y < min.wrapping_add(1) || y.wrapping_add(height).wrapping_add(1) > max {
|
||||
return Ok(false);
|
||||
}
|
||||
if !self
|
||||
.can_place_on
|
||||
.test(world, tb::offset(origin, 0, -1, 0))
|
||||
.map_err(query)?
|
||||
{
|
||||
return Ok(false);
|
||||
}
|
||||
for dy in 0..=height {
|
||||
let radius = self.radius_for_height(-1, self.foliage_radius, dy);
|
||||
for dx in -radius..=radius {
|
||||
for dz in -radius..=radius {
|
||||
let state = read(world, tb::offset(origin, dx, dy, dz))?;
|
||||
if !self.blocks.has(state, tb::AIR | tb::LEAVES) {
|
||||
return Ok(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let r = self.foliage_radius;
|
||||
if self.red {
|
||||
for dy in height - 3..=height {
|
||||
let radius = if dy < height { r } else { r - 1 };
|
||||
let center = r - 2;
|
||||
for dx in -radius..=radius {
|
||||
for dz in -radius..=radius {
|
||||
let x_edge = dx == -radius || dx == radius;
|
||||
let z_edge = dz == -radius || dz == radius;
|
||||
if dy >= height || x_edge != z_edge {
|
||||
let p = tb::offset(origin, dx, dy, dz);
|
||||
let state = sample_state(&self.cap, world, random, origin)?;
|
||||
let state = self.faces(
|
||||
state,
|
||||
&[
|
||||
("west", dx < -center),
|
||||
("east", dx > center),
|
||||
("north", dz < -center),
|
||||
("south", dz > center),
|
||||
("up", dy >= height - 1),
|
||||
],
|
||||
);
|
||||
self.place_block(world, p, state)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for dx in -r..=r {
|
||||
for dz in -r..=r {
|
||||
let (min_x, max_x, min_z, max_z) = (dx == -r, dx == r, dz == -r, dz == r);
|
||||
let x_edge = min_x || max_x;
|
||||
let z_edge = min_z || max_z;
|
||||
if !x_edge || !z_edge {
|
||||
let p = tb::offset(origin, dx, height, dz);
|
||||
let west = min_x || (z_edge && dx == 1 - r);
|
||||
let east = max_x || (z_edge && dx == r - 1);
|
||||
let north = min_z || (x_edge && dz == 1 - r);
|
||||
let south = max_z || (x_edge && dz == r - 1);
|
||||
let state = sample_state(&self.cap, world, random, origin)?;
|
||||
let state = self.faces(
|
||||
state,
|
||||
&[
|
||||
("west", west),
|
||||
("east", east),
|
||||
("north", north),
|
||||
("south", south),
|
||||
],
|
||||
);
|
||||
self.place_block(world, p, state)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for dy in 0..height {
|
||||
let state = sample_state(&self.stem, world, random, origin)?;
|
||||
self.place_block(world, tb::offset(origin, 0, dy, 0), state)?;
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct MultifaceGrowthFeature {
|
||||
block: BlockStateId,
|
||||
sculk: bool,
|
||||
search_range: i32,
|
||||
directions: Vec<Direction>,
|
||||
chance_of_spreading: f32,
|
||||
can_be_placed_on: Arc<BTreeSet<BlockStateId>>,
|
||||
blocks: Arc<TreeBlocks>,
|
||||
}
|
||||
#[derive(Clone, Copy)]
|
||||
enum Spread {
|
||||
SamePosition,
|
||||
SamePlane,
|
||||
WrapAround,
|
||||
}
|
||||
impl MultifaceGrowthFeature {
|
||||
pub(crate) fn decode(
|
||||
json: &str,
|
||||
bindings: &FeatureBlockBindings<'_>,
|
||||
) -> Result<Self, DecodeError> {
|
||||
let object: Object = serde_json::from_str(json)?;
|
||||
if kind(&object)? != "minecraft:multiface_growth" {
|
||||
return Err(DecodeError::Field("multiface growth type"));
|
||||
}
|
||||
let blocks = bindings.tree_blocks()?;
|
||||
let name = super::density::identifier(&serde_json::from_str::<String>(
|
||||
required(&object, "block")?.get(),
|
||||
)?)?;
|
||||
// The 26.3 MultifaceSpreadeableBlock subclasses.
|
||||
let sculk = match name.as_str() {
|
||||
"minecraft:glow_lichen" => false,
|
||||
"minecraft:sculk_vein" => true,
|
||||
_ => return Err(DecodeError::Field("multiface spreadeable block")),
|
||||
};
|
||||
let block = blocks
|
||||
.default_state(&name)
|
||||
.ok_or(DecodeError::Field("multiface block"))?;
|
||||
let flag = |key: &str| -> Result<bool, DecodeError> {
|
||||
Ok(optional(&object, key)
|
||||
.map(|raw| serde_json::from_str::<bool>(raw.get()))
|
||||
.transpose()?
|
||||
.unwrap_or(false))
|
||||
};
|
||||
let mut directions = Vec::new();
|
||||
if flag("can_place_on_ceiling")? {
|
||||
directions.push(Direction::Up);
|
||||
}
|
||||
if flag("can_place_on_floor")? {
|
||||
directions.push(Direction::Down);
|
||||
}
|
||||
if flag("can_place_on_wall")? {
|
||||
directions.extend(tb::HORIZONTAL);
|
||||
}
|
||||
Ok(Self {
|
||||
block,
|
||||
sculk,
|
||||
search_range: optional(&object, "search_range")
|
||||
.map(|raw| int_range(raw, "search_range", 1, 64))
|
||||
.transpose()?
|
||||
.unwrap_or(10),
|
||||
directions,
|
||||
chance_of_spreading: optional(&object, "chance_of_spreading")
|
||||
.map(|raw| unit_float(raw, "chance_of_spreading"))
|
||||
.transpose()?
|
||||
.unwrap_or(0.5),
|
||||
can_be_placed_on: super::block_predicate::PredicateBlockResolver::predicate_block_set(
|
||||
bindings,
|
||||
required(&object, "can_be_placed_on")?.get(),
|
||||
)?,
|
||||
blocks,
|
||||
})
|
||||
}
|
||||
fn air_or_water(&self, state: BlockStateId) -> bool {
|
||||
self.blocks.has(state, tb::AIR | tb::WATER_BLOCK)
|
||||
}
|
||||
fn is_block(&self, state: BlockStateId) -> bool {
|
||||
self.blocks.same_block(state, self.block)
|
||||
}
|
||||
fn has_face(&self, state: BlockStateId, face: Direction) -> bool {
|
||||
self.blocks
|
||||
.properties
|
||||
.value(state, tb::direction_name(face))
|
||||
== Some("true")
|
||||
}
|
||||
pub(crate) fn place<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
origin: [i32; 3],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let here = read(world, origin)?;
|
||||
if !self.air_or_water(here) {
|
||||
return Ok(false);
|
||||
}
|
||||
let mut directions = self.directions.clone();
|
||||
tb::shuffle(&mut directions, random)?;
|
||||
let here = read(world, origin)?;
|
||||
if self.place_growth(world, random, origin, here, &directions)? {
|
||||
return Ok(true);
|
||||
}
|
||||
for &search in &directions {
|
||||
let mut placement: Vec<Direction> = self
|
||||
.directions
|
||||
.iter()
|
||||
.copied()
|
||||
.filter(|d| *d != search.opposite())
|
||||
.collect();
|
||||
tb::shuffle(&mut placement, random)?;
|
||||
for _ in 0..self.search_range {
|
||||
// Native setWithOffset(origin, ...) revisits the first neighbor.
|
||||
let pos = tb::relative(origin, search, 1);
|
||||
let state = read(world, pos)?;
|
||||
if !self.air_or_water(state) && !self.is_block(state) {
|
||||
break;
|
||||
}
|
||||
if self.place_growth(world, random, pos, state, &placement)? {
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
fn place_growth<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
random: &mut R,
|
||||
pos: [i32; 3],
|
||||
old: BlockStateId,
|
||||
directions: &[Direction],
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
for &direction in directions {
|
||||
let neighbor = read(world, tb::relative(pos, direction, 1))?;
|
||||
if self.can_be_placed_on.contains(&neighbor) {
|
||||
let Some(state) = self.state_for_placement(world, old, pos, direction)? else {
|
||||
return Ok(false);
|
||||
};
|
||||
write(world, pos, state, 3)?;
|
||||
world.mark_postprocessing(pos).map_err(query)?;
|
||||
if random.next_float() < self.chance_of_spreading {
|
||||
let mut all = Direction::ALL;
|
||||
tb::shuffle(&mut all, random)?;
|
||||
for spread in all {
|
||||
if self.spread(world, state, pos, direction, spread)? {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
fn valid_for_placement<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
old: BlockStateId,
|
||||
pos: [i32; 3],
|
||||
direction: Direction,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if self.is_block(old) && self.has_face(old, direction) {
|
||||
return Ok(false);
|
||||
}
|
||||
world.attachment_at(pos, direction).map_err(query)
|
||||
}
|
||||
fn state_for_placement<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
old: BlockStateId,
|
||||
pos: [i32; 3],
|
||||
direction: Direction,
|
||||
) -> TreeResult<Option<BlockStateId>, W::Error> {
|
||||
if !self.valid_for_placement(world, old, pos, direction)? {
|
||||
return Ok(None);
|
||||
}
|
||||
let state = if self.is_block(old) {
|
||||
old
|
||||
} else if self.blocks.has(old, tb::WATER_SOURCE) {
|
||||
self.blocks.waterlogged(self.block, true)
|
||||
} else {
|
||||
self.block
|
||||
};
|
||||
Ok(Some(
|
||||
self.blocks
|
||||
.with(state, tb::direction_name(direction), "true")
|
||||
.ok_or(FeatureExecutionError::InvalidState)?,
|
||||
))
|
||||
}
|
||||
fn spread_types(&self) -> [Spread; 3] {
|
||||
[Spread::SamePosition, Spread::SamePlane, Spread::WrapAround]
|
||||
}
|
||||
/// spreadFromFaceTowardDirection with postProcess = true.
|
||||
fn spread<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
state: BlockStateId,
|
||||
pos: [i32; 3],
|
||||
from: Direction,
|
||||
direction: Direction,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
if tb::Axis::of(direction) == tb::Axis::of(from) {
|
||||
return Ok(false);
|
||||
}
|
||||
let other_source = self.sculk && !self.blocks.has(state, tb::SCULK_VEIN);
|
||||
if !(other_source || (self.has_face(state, from) && !self.has_face(state, direction))) {
|
||||
return Ok(false);
|
||||
}
|
||||
for kind in self.spread_types() {
|
||||
let (target, face) = match kind {
|
||||
Spread::SamePosition => (pos, direction),
|
||||
Spread::SamePlane => (tb::relative(pos, direction, 1), from),
|
||||
Spread::WrapAround => (
|
||||
tb::relative(tb::relative(pos, direction, 1), from, 1),
|
||||
direction.opposite(),
|
||||
),
|
||||
};
|
||||
if self.can_spread_into(world, pos, target, face)? {
|
||||
let old = read(world, target)?;
|
||||
let Some(new) = self.state_for_placement(world, old, target, face)? else {
|
||||
return Ok(false);
|
||||
};
|
||||
world.mark_postprocessing(target).map_err(query)?;
|
||||
return write(world, target, new, 2);
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
fn can_spread_into<W: FeatureWorld + PlacementContext>(
|
||||
&self,
|
||||
world: &mut W,
|
||||
source: [i32; 3],
|
||||
target: [i32; 3],
|
||||
face: Direction,
|
||||
) -> TreeResult<bool, W::Error> {
|
||||
let existing = read(world, target)?;
|
||||
let replaceable = if self.sculk {
|
||||
let against = read(world, tb::relative(target, face, 1))?;
|
||||
if self.blocks.has(against, tb::SCULK_BLOCKER) {
|
||||
false
|
||||
} else {
|
||||
let mut blocked = false;
|
||||
if tb::dist_manhattan(source, target) == 2 {
|
||||
let neighbor = tb::relative(source, face.opposite(), 1);
|
||||
let state = read(world, neighbor)?;
|
||||
blocked = world
|
||||
.state_face_sturdy(state, neighbor, face)
|
||||
.map_err(query)?;
|
||||
}
|
||||
if blocked
|
||||
|| (self.blocks.has(existing, tb::ANY_FLUID)
|
||||
&& !self.blocks.has(existing, tb::WATER_SOURCE))
|
||||
|| self.blocks.has(existing, tb::FIRE)
|
||||
{
|
||||
false
|
||||
} else {
|
||||
self.blocks.has(existing, tb::REPLACEABLE) || self.default_replaceable(existing)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
self.default_replaceable(existing)
|
||||
};
|
||||
Ok(replaceable && self.valid_for_placement(world, existing, target, face)?)
|
||||
}
|
||||
fn default_replaceable(&self, existing: BlockStateId) -> bool {
|
||||
self.blocks.is_air(existing)
|
||||
|| self.is_block(existing)
|
||||
|| (self.blocks.has(existing, tb::WATER_BLOCK)
|
||||
&& self.blocks.has(existing, tb::WATER_SOURCE))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,178 @@
|
||||
package dev.horizonlab.parity;
|
||||
import com.google.gson.*;
|
||||
import com.mojang.serialization.JsonOps;
|
||||
import java.io.*;
|
||||
import java.lang.reflect.*;
|
||||
import java.nio.file.*;
|
||||
import java.util.*;
|
||||
import net.minecraft.core.*;
|
||||
import net.minecraft.core.registries.*;
|
||||
import net.minecraft.resources.*;
|
||||
import net.minecraft.util.RandomSource;
|
||||
import net.minecraft.world.level.*;
|
||||
import net.minecraft.world.level.biome.*;
|
||||
import net.minecraft.world.level.block.*;
|
||||
import net.minecraft.world.level.block.entity.*;
|
||||
import net.minecraft.world.level.block.state.BlockState;
|
||||
import net.minecraft.world.level.chunk.*;
|
||||
import net.minecraft.world.level.levelgen.*;
|
||||
import net.minecraft.world.level.levelgen.feature.Feature;
|
||||
import net.minecraft.world.level.levelgen.feature.stateproviders.BlockStateProvider;
|
||||
|
||||
/**
|
||||
* Actual native tree, fallen-tree and ore features over a layered synthetic
|
||||
* world backed by proto-chunk sections. Logs ordered level writes, beehive
|
||||
* occupants, post-processing marks, results, random tails and the final diff.
|
||||
*/
|
||||
public final class VanillaTreeFeatureOracle {
|
||||
private static final int MIN_Y=-64,HEIGHT=384;
|
||||
private static BlockPos pos(JsonArray a){return new BlockPos(a.get(0).getAsInt(),a.get(1).getAsInt(),a.get(2).getAsInt());}
|
||||
private static String xyz(BlockPos p){return p.getX()+" "+p.getY()+" "+p.getZ();}
|
||||
private static final class Chunks {
|
||||
static final PalettedContainerFactory FACTORY;
|
||||
static {
|
||||
Holder<Biome> biome=Holder.Reference.createStandAlone(new HolderOwner<Biome>(){},Biomes.PLAINS);
|
||||
var ids=new IdMapper<Holder<Biome>>();ids.add(biome);
|
||||
FACTORY=new PalettedContainerFactory(Strategy.createForBlockStates(Block.BLOCK_STATE_REGISTRY),Blocks.AIR.defaultBlockState(),null,Strategy.createForBiomes(ids),biome,null);
|
||||
}
|
||||
}
|
||||
/** Shared with the Rust fixture: layered column, pseudo-random holes and obstacles, overrides. */
|
||||
static final class Terrain {
|
||||
final int[][] layers;final int[][] boxes;final int holeMod,holeState,obstacleMod,obstacleState,obstacleMin;final Map<BlockPos,Integer> overrides=new HashMap<>();
|
||||
Terrain(JsonObject f){
|
||||
var raw=f.getAsJsonArray("layers");layers=new int[raw.size()][];for(int i=0;i<raw.size();i++){var l=raw.get(i).getAsJsonArray();layers[i]=new int[]{l.get(0).getAsInt(),l.get(1).getAsInt()};}
|
||||
var rawBoxes=f.has("boxes")?f.getAsJsonArray("boxes"):new JsonArray();boxes=new int[rawBoxes.size()][7];
|
||||
for(int i=0;i<rawBoxes.size();i++)for(int j=0;j<7;j++)boxes[i][j]=rawBoxes.get(i).getAsJsonArray().get(j).getAsInt();
|
||||
holeMod=f.get("hole_mod").getAsInt();holeState=f.get("hole_state").getAsInt();obstacleMod=f.get("obstacle_mod").getAsInt();obstacleState=f.get("obstacle_state").getAsInt();obstacleMin=f.get("obstacle_min").getAsInt();
|
||||
for(var e:f.getAsJsonArray("states")){var v=e.getAsJsonArray();overrides.put(pos(v),v.get(3).getAsInt());}
|
||||
}
|
||||
static int hash(int x,int y,int z){int h=x*73856093^y*19349663^z*83492791;h^=h>>>13;h*=0x5bd1e995;h^=h>>>15;return h&0x7fffffff;}
|
||||
int at(int x,int y,int z){
|
||||
var o=overrides.get(new BlockPos(x,y,z));if(o!=null)return o;
|
||||
for(var b:boxes)if(x>=b[0]&&y>=b[1]&&z>=b[2]&&x<=b[3]&&y<=b[4]&&z<=b[5])return b[6];
|
||||
int base=-1;for(var l:layers)if(y<=l[0]){base=l[1];break;}
|
||||
int h=hash(x,y,z);
|
||||
if(base>=0){if(holeMod>0&&h%holeMod==0)return holeState;return base;}
|
||||
if(obstacleMod>0&&y>=obstacleMin&&h%obstacleMod==0)return obstacleState;
|
||||
return Block.getId(Blocks.AIR.defaultBlockState());
|
||||
}
|
||||
}
|
||||
private static final class World implements InvocationHandler {
|
||||
final JsonObject f;final PrintWriter out;final Terrain terrain;final Map<ChunkPos,ProtoChunk> chunks=new HashMap<>();final Map<BlockPos,BeehiveBlockEntity> hives=new HashMap<>();final Map<BlockPos,ChestBlockEntity> chests=new HashMap<>();final Map<BlockPos,SpawnerBlockEntity> spawners=new HashMap<>();
|
||||
final RandomSource shapeRandom=RandomSource.create(0);
|
||||
World(JsonObject f,PrintWriter out){this.f=f;this.out=out;this.terrain=new Terrain(f);}
|
||||
ProtoChunk chunk(int cx,int cz){
|
||||
return chunks.computeIfAbsent(new ChunkPos(cx,cz),cp->{
|
||||
var chunk=new ProtoChunk(cp,UpgradeData.EMPTY,LevelHeightAccessor.create(MIN_Y,HEIGHT),Chunks.FACTORY,null){
|
||||
@Override public void markPosForPostProcessing(BlockPos position){out.println("post "+xyz(position));super.markPosForPostProcessing(position);}
|
||||
};
|
||||
for(int s=0;s<HEIGHT/16;s++){var section=chunk.getSection(s);for(int ly=0;ly<16;ly++)for(int lz=0;lz<16;lz++)for(int lx=0;lx<16;lx++){
|
||||
var state=Block.stateById(terrain.at(cx*16+lx,MIN_Y+s*16+ly,cz*16+lz));if(!state.isAir()||!state.is(Blocks.AIR))section.setBlockState(lx,ly,lz,state,false);}}
|
||||
return chunk;
|
||||
});
|
||||
}
|
||||
BlockState get(BlockPos p){
|
||||
if(p.getY()<MIN_Y||p.getY()>=MIN_Y+HEIGHT)return Blocks.VOID_AIR.defaultBlockState();
|
||||
return chunk(p.getX()>>4,p.getZ()>>4).getBlockState(p);
|
||||
}
|
||||
public Object invoke(Object proxy,Method method,Object[] args)throws Throwable {
|
||||
String name=method.getName();
|
||||
switch(name){
|
||||
case "getBlockState":return get((BlockPos)args[0]);
|
||||
case "getFluidState":return get((BlockPos)args[0]).getFluidState();
|
||||
case "isStateAtPosition":return ((java.util.function.Predicate<BlockState>)args[1]).test(get((BlockPos)args[0]));
|
||||
case "isFluidAtPosition":return ((java.util.function.Predicate<net.minecraft.world.level.material.FluidState>)args[1]).test(get((BlockPos)args[0]).getFluidState());
|
||||
case "getMinY":return MIN_Y;
|
||||
case "getSeaLevel":return 63;
|
||||
case "getRawBrightness":case "getMaxLocalRawBrightness":return 15;
|
||||
case "getBrightness":return 15;
|
||||
case "getSeed":return f.get("world_seed").getAsLong();
|
||||
case "ensureCanWrite":return true;
|
||||
case "getRandom":return shapeRandom;
|
||||
case "scheduleTick":return null; // Edge shape updates also schedule ticks; not compared.
|
||||
case "setCurrentlyGenerating":case "playSound":case "levelEvent":case "gameEvent":case "blockEvent":return null;
|
||||
case "getEntities":return java.util.List.of();
|
||||
case "getBlockEntity":{
|
||||
if(args.length!=1)break;var p=((BlockPos)args[0]).immutable();var state=get(p);
|
||||
if(state.is(Blocks.CHEST))return chests.computeIfAbsent(p,key->new ChestBlockEntity(key,state){@Override public void setLootTable(net.minecraft.resources.ResourceKey<net.minecraft.world.level.storage.loot.LootTable> table,long seed){out.println("loot "+xyz(key)+" "+table.identifier()+" "+seed);super.setLootTable(table,seed);}});
|
||||
if(state.is(Blocks.SPAWNER))return spawners.computeIfAbsent(p,key->new SpawnerBlockEntity(key,state){@Override public void setEntityId(net.minecraft.world.entity.EntityType<?> type,RandomSource r){super.setEntityId(type,r);out.println("spawner "+xyz(key)+" "+BuiltInRegistries.ENTITY_TYPE.getKey(type));}});
|
||||
if(!state.is(Blocks.BEE_NEST))return null;
|
||||
return hives.computeIfAbsent(p,key->new BeehiveBlockEntity(key,state){@Override public void storeBee(BeehiveBlockEntity.Occupant occupant){out.println("bee "+xyz(key)+" "+occupant.ticksInHive());}});
|
||||
}
|
||||
case "setBlock":{
|
||||
var p=((BlockPos)args[0]).immutable();var state=(BlockState)args[1];out.println("set "+xyz(p)+" "+Block.getId(state)+" "+args[2]);
|
||||
if(p.getY()<MIN_Y||p.getY()>=MIN_Y+HEIGHT)return false;
|
||||
chunk(p.getX()>>4,p.getZ()>>4).getSection((p.getY()-MIN_Y)>>4).setBlockState(p.getX()&15,p.getY()&15,p.getZ()&15,state,false);return true;
|
||||
}
|
||||
case "getHeight":if(args==null||args.length==0)return HEIGHT;return f.get("height").getAsInt();
|
||||
case "getChunk":
|
||||
if(args.length==1&&args[0] instanceof BlockPos p)return chunk(p.getX()>>4,p.getZ()>>4);
|
||||
if(args.length>=2&&args[0] instanceof Integer x&&args[1] instanceof Integer z)return chunk(x,z);
|
||||
break;
|
||||
default:break;
|
||||
}
|
||||
if(method.isDefault())return InvocationHandler.invokeDefault(proxy,method,args);
|
||||
throw new AssertionError(method);
|
||||
}
|
||||
}
|
||||
/** Parses named holders on first use from the bundled vanilla resources. */
|
||||
static final class Lazy<T> implements HolderGetter<T>, HolderOwner<T> {
|
||||
JsonObject json;com.mojang.serialization.Codec<T> codec;RegistryOps<JsonElement> ops;final Map<ResourceKey<T>,Holder.Reference<T>> cache=new HashMap<>();
|
||||
public Optional<Holder.Reference<T>> get(ResourceKey<T> key){
|
||||
var cached=cache.get(key);if(cached!=null)return Optional.of(cached);
|
||||
var text=json.get(key.identifier().toString());if(text==null)return Optional.empty();
|
||||
var ref=Holder.Reference.createStandAlone(this,key);cache.put(key,ref);
|
||||
T value=codec.parse(ops,JsonParser.parseString(text.getAsString())).getOrThrow();
|
||||
try{var bind=Holder.Reference.class.getDeclaredMethod("bindValue",Object.class);bind.setAccessible(true);bind.invoke(ref,value);}catch(ReflectiveOperationException e){throw new IllegalStateException(e);}
|
||||
return Optional.of(ref);
|
||||
}
|
||||
public Optional<HolderSet.Named<T>> get(net.minecraft.tags.TagKey<T> tag){return Optional.empty();}
|
||||
}
|
||||
static final Lazy<Feature> lazyFeatures=new Lazy<>();
|
||||
static final Lazy<net.minecraft.world.level.levelgen.placement.PlacedFeature> lazyPlaced=new Lazy<>();
|
||||
@SuppressWarnings("unchecked")
|
||||
public static void main(String[] args)throws Exception {
|
||||
net.minecraft.SharedConstants.tryDetectVersion();net.minecraft.server.Bootstrap.bootStrap();Path dir=Path.of(args[1]);
|
||||
VanillaHeightmapOracle.bindTags(JsonParser.parseString(Files.readString(dir.resolve("tags.json"))).getAsJsonObject());
|
||||
var bind=VanillaBlockSurvivalOracle.class.getDeclaredMethod("bindFluidTags",JsonObject.class);bind.setAccessible(true);bind.invoke(null,JsonParser.parseString(Files.readString(dir.resolve("fluid-tags.json"))).getAsJsonObject());
|
||||
var providers=new MappedRegistry<BlockStateProvider>(Registries.BLOCK_STATE_PROVIDER,com.mojang.serialization.Lifecycle.stable());
|
||||
var ops=RegistryOps.create(JsonOps.INSTANCE,new RegistryOps.RegistryInfoLookup(){public <T> Optional<HolderGetter<T>> lookup(ResourceKey<? extends Registry<? extends T>> key){
|
||||
if(key.equals(Registries.BLOCK_STATE_PROVIDER))return (Optional<HolderGetter<T>>)(Optional<?>)Optional.of(providers);
|
||||
if(key.equals(Registries.FEATURE))return (Optional<HolderGetter<T>>)(Optional<?>)Optional.of(lazyFeatures);
|
||||
if(key.equals(Registries.PLACED_FEATURE))return (Optional<HolderGetter<T>>)(Optional<?>)Optional.of(lazyPlaced);
|
||||
if(key.equals(Registries.FLUID))return (Optional<HolderGetter<T>>)(Optional<?>)Optional.of(BuiltInRegistries.FLUID);
|
||||
return key.equals(Registries.BLOCK)?(Optional<HolderGetter<T>>)(Optional<?>)Optional.of(BuiltInRegistries.BLOCK):Optional.empty();
|
||||
}});
|
||||
var bundle=JsonParser.parseString(Files.readString(dir.resolve("vanilla-features.json"))).getAsJsonObject();
|
||||
for(var entry:bundle.getAsJsonObject("providers").entrySet())
|
||||
providers.register(ResourceKey.create(Registries.BLOCK_STATE_PROVIDER,Identifier.parse(entry.getKey())),BlockStateProvider.DIRECT_CODEC.parse(ops,JsonParser.parseString(entry.getValue().getAsString())).getOrThrow(),RegistrationInfo.BUILT_IN);
|
||||
providers.freeze();
|
||||
var features=bundle.getAsJsonObject("features");var placedJson=bundle.getAsJsonObject("placed");
|
||||
lazyFeatures.json=features;lazyPlaced.json=placedJson;lazyFeatures.codec=Feature.DIRECT_CODEC;lazyPlaced.codec=net.minecraft.world.level.levelgen.placement.PlacedFeature.DIRECT_CODEC;lazyFeatures.ops=ops;lazyPlaced.ops=ops;
|
||||
var contextMethod=VanillaPlacementOracle.class.getDeclaredMethod("context",JsonObject.class);contextMethod.setAccessible(true);
|
||||
var bounds=new JsonObject();bounds.add("context",JsonParser.parseString("[-64,384,63]"));
|
||||
var generator=((net.minecraft.world.level.levelgen.placement.PlacementContext)contextMethod.invoke(null,bounds)).generator();
|
||||
try(var out=new PrintWriter(Files.newBufferedWriter(dir.resolve(args[0]+".txt")));var inputs=Files.lines(dir.resolve("inputs.txt"))) {
|
||||
for(var line:(Iterable<String>)inputs::iterator){
|
||||
var f=JsonParser.parseString(line).getAsJsonObject();long seed=f.get("seed").getAsLong();
|
||||
RandomSource random=f.get("legacy").getAsBoolean()?new LegacyRandomSource(seed):new XoroshiroRandomSource(seed);
|
||||
out.println("fixture "+f.get("feature").getAsString());
|
||||
Optional<Feature> decoded;
|
||||
try{decoded=Feature.DIRECT_CODEC.parse(ops,JsonParser.parseString(features.get(f.get("feature").getAsString()).getAsString())).result();}catch(Throwable error){decoded=Optional.empty();}
|
||||
if(decoded.isEmpty()){out.println("decode error");continue;}
|
||||
var handler=new World(f,out);var world=(WorldGenLevel)Proxy.newProxyInstance(WorldGenLevel.class.getClassLoader(),new Class<?>[]{WorldGenLevel.class},handler);
|
||||
try{out.println("place "+decoded.get().place(world,generator,random,pos(f.getAsJsonArray("origin"))));}catch(Throwable error){out.println("place error");System.err.println(f.get("feature").getAsString()+": "+error);}
|
||||
out.println("next "+random.nextLong());
|
||||
var keys=new ArrayList<>(handler.chunks.keySet());keys.sort(Comparator.<ChunkPos>comparingInt(ChunkPos::x).thenComparingInt(ChunkPos::z));
|
||||
var changes=new TreeMap<BlockPos,Integer>(Comparator.<BlockPos>comparingInt(BlockPos::getX).thenComparingInt(BlockPos::getY).thenComparingInt(BlockPos::getZ));
|
||||
for(var key:keys){var chunk=handler.chunks.get(key);
|
||||
for(int y=MIN_Y;y<MIN_Y+HEIGHT;y++)for(int lz=0;lz<16;lz++)for(int lx=0;lx<16;lx++){
|
||||
int x=key.x()*16+lx,z=key.z()*16+lz;int id=Block.getId(chunk.getSection((y-MIN_Y)>>4).getBlockState(lx,y&15,lz));
|
||||
if(id!=handler.terrain.at(x,y,z))changes.put(new BlockPos(x,y,z),id);
|
||||
}}
|
||||
for(var e:changes.entrySet())out.println("final "+xyz(e.getKey())+" "+e.getValue());
|
||||
out.println("end");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Compare vanilla tree, fallen-tree and ore features block-for-block with vanilla."""
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import platform
|
||||
import subprocess
|
||||
import zipfile
|
||||
try:
|
||||
from . import lab, test_rust_parity as base, test_worldgen_parity as worldgen, test_block_survival_parity as survival
|
||||
except ImportError:
|
||||
import lab
|
||||
import test_rust_parity as base
|
||||
import test_worldgen_parity as worldgen
|
||||
import test_block_survival_parity as survival
|
||||
|
||||
|
||||
def feature_resources(jar):
|
||||
"""Vanilla configured features and named state providers from the authenticated JAR."""
|
||||
result={'features':{},'providers':{},'placed':{}}
|
||||
with zipfile.ZipFile(jar) as archive:
|
||||
for kind,key in [('feature','features'),('block_state_provider','providers'),('placed_feature','placed')]:
|
||||
prefix=f'data/minecraft/worldgen/{kind}/'
|
||||
for name in sorted(archive.namelist()):
|
||||
if name.startswith(prefix) and name.endswith('.json'):
|
||||
result[key]['minecraft:'+name[len(prefix):-5]]=archive.read(name).decode('utf-8')
|
||||
return result
|
||||
|
||||
|
||||
def fixture_hashes(paths):
|
||||
# Build outputs may live behind a linked private directory outside ROOT.
|
||||
return {path.name:lab.digest(path,'sha256') for path in paths}
|
||||
|
||||
|
||||
def corpus(facts,resources):
|
||||
get=lambda name:facts['defaults']['minecraft:'+name]
|
||||
def fixture(feature,**extra):
|
||||
f={'feature':feature,'seed':0,'legacy':False,'origin':[8,65,8],'height':65,'layers':[[59,get('stone')],[63,get('dirt')],[64,get('grass_block')]],
|
||||
'hole_mod':0,'hole_state':get('air'),'obstacle_mod':0,'obstacle_state':get('air'),'obstacle_min':0,'states':[]}
|
||||
f.update(extra);f.setdefault('world_seed',f['seed']^0x2545F4914F6CDD1D);return f
|
||||
seeds=[0,1,-1,0x5DEECE66D,0x123456789abcdef,-8070450532247928832]
|
||||
origins=[[8,65,8],[15,65,0],[0,65,15],[-1,65,-17],[31,65,-16],[100003,65,-4097]]
|
||||
trees,ores,others=[],[],[]
|
||||
for name,text in resources['features'].items():
|
||||
value=json.loads(text);kind=value['type'].removeprefix('minecraft:')
|
||||
if kind in ('tree','fallen_tree'):
|
||||
if 'pale_moss' in text:continue # needs the level's feature registry and server level
|
||||
trees.append(name)
|
||||
elif kind in ('ore','scattered_ore'):ores.append(name)
|
||||
elif kind not in ('freeze_top_layer','template','fossil'):others.append(name) # templates need structure resources
|
||||
worlds=[
|
||||
{},
|
||||
{'obstacle_mod':37,'obstacle_state':get('oak_leaves'),'obstacle_min':66},
|
||||
{'obstacle_mod':23,'obstacle_state':get('stone'),'obstacle_min':65},
|
||||
{'obstacle_mod':19,'obstacle_state':get('vine'),'obstacle_min':65},
|
||||
{'layers':[[59,get('stone')],[64,get('mud')],[67,get('water')]],'height':68},
|
||||
{'layers':[[300,get('stone')],[310,get('dirt')],[311,get('grass_block')]],'origin_y':312,'height':312},
|
||||
{'layers':[[59,get('stone')],[63,get('dirt')],[64,get('podzol')]],'hole_mod':11,'hole_state':get('short_grass')},
|
||||
]
|
||||
for name in trees:
|
||||
for w,world in enumerate(worlds):
|
||||
for s,seed in enumerate(seeds):
|
||||
extra=dict(world);origin=list(origins[(s+w)%len(origins)]);origin[1]=extra.pop('origin_y',extra.get('height',65))
|
||||
yield fixture(name,seed=seed,legacy=s%3==2,origin=origin,**extra)
|
||||
ore_worlds=[
|
||||
{'layers':[[-1,get('deepslate')],[250,get('stone')]],'height':251},
|
||||
{'layers':[[-1,get('deepslate')],[250,get('stone')]],'height':251,'hole_mod':5,'hole_state':get('air')},
|
||||
{'layers':[[-1,get('deepslate')],[250,get('stone')]],'height':-100},
|
||||
{'layers':[[250,get('netherrack')]],'height':251,'hole_mod':9,'hole_state':get('cave_air')},
|
||||
{'layers':[[30,get('tuff')],[250,get('granite')]],'height':251,'hole_mod':13,'hole_state':get('water')},
|
||||
]
|
||||
for name in ores:
|
||||
for w,world in enumerate(ore_worlds):
|
||||
for s,seed in enumerate(seeds):
|
||||
origin=list(origins[(s+w)%len(origins)]);origin[1]=[-60,-3,0,40,316,-64][(s*5+w)%6]
|
||||
yield fixture(name,seed=seed,legacy=s%3==2,origin=origin,**world)
|
||||
|
||||
air,water,stone=get('air'),get('water'),get('stone')
|
||||
generic_worlds=[
|
||||
({},[65]),
|
||||
({'layers':[[200,stone]],'height':201,'boxes':[[-40,20,-40,56,35,56,air]]},[20,35,27]),
|
||||
({'layers':[[200,stone]],'height':201,'boxes':[[-40,23,-40,56,35,56,air],[-40,20,-40,56,22,56,water]]},[21,23]),
|
||||
({'layers':[[35,stone],[39,get('sand')],[62,water]],'height':40},[40,63]),
|
||||
({'layers':[[31,get('lava')],[100,get('netherrack')]],'height':101,'boxes':[[-40,32,-40,56,60,56,air]]},[32,60]),
|
||||
]
|
||||
for name in others:
|
||||
for w,(world,ys) in enumerate(generic_worlds):
|
||||
for y in ys:
|
||||
for s,seed in enumerate(seeds[:4]):
|
||||
origin=list(origins[(s+w)%len(origins)]);origin[1]=y
|
||||
yield fixture(name,seed=seed,legacy=s%3==2,origin=origin,**world)
|
||||
|
||||
|
||||
def main():
|
||||
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--prepare',action='store_true');args=parser.parse_args()
|
||||
build=lab.LOCAL/'rust-tree-feature-parity';build.mkdir(parents=True,exist_ok=True);report_path=build/'report.json';report_path.unlink(missing_ok=True)
|
||||
if args.prepare:lab.prepare()
|
||||
lock,jars,libraries=base.verify_artifacts();parity=lab.ROOT/'mods/horizon/src/test/java/dev/horizonlab/parity'
|
||||
oracle=parity/'VanillaTreeFeatureOracle.java';exporter=parity/'VanillaSimpleBlockOracle.java'
|
||||
helpers=[parity/(name+'.java') for name in ['VanillaPlacementOracle','VanillaBlockSurvivalOracle','VanillaBlockPropertiesOracle','VanillaBlockSupportOracle','VanillaBlockStateCodecOracle','VanillaCollisionOracle','VanillaHeightmapOracle']]
|
||||
sources=[oracle,exporter,*helpers,Path(__file__),*[lab.ROOT/'tools'/name for name in ['test_block_survival_parity.py','test_worldgen_parity.py','test_rust_parity.py','lab.py']],lab.ROOT/'Cargo.toml',lab.ROOT/'Cargo.lock',
|
||||
*sorted((lab.ROOT/'crates/horizon-core/src').rglob('*.rs')),*sorted((lab.ROOT/'crates/horizon-world/src').rglob('*.rs')),lab.ROOT/'crates/horizon-world/examples/tree_feature_fixture.rs']
|
||||
tested_sources=base.source_hashes(sources);classes=build/'classes';classes.mkdir(exist_ok=True)
|
||||
def run(command,name):
|
||||
with (build/(name+'.log')).open('w',encoding='utf-8') as log:subprocess.run(list(map(str,command)),cwd=lab.ROOT,check=True,timeout=7200,stdout=log,stderr=subprocess.STDOUT)
|
||||
dependency_path=os.pathsep.join(map(str,libraries))
|
||||
def java(main_class,side,mode,path):run(['java','-Xmx2G','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.'+main_class,mode,path],side+'-'+mode)
|
||||
tags=worldgen.tag_resources(jars['server']);fluid_tags=survival.fluid_tag_resources(jars['server']);resources=feature_resources(jars['server'])
|
||||
if tags!=worldgen.tag_resources(jars['client']) or fluid_tags!=survival.fluid_tag_resources(jars['client']) or resources!=feature_resources(jars['client']):raise ValueError('reference resources differ')
|
||||
for name,value in [('tags.json',tags),('fluid-tags.json',fluid_tags),('vanilla-features.json',resources)]:(build/name).write_text(json.dumps(value,separators=(',',':')))
|
||||
run(['javac','--release',lock['minecraft']['java_major'],'-proc:none','-cp',str(jars['server'])+os.pathsep+dependency_path,'-d',classes,oracle,exporter,*helpers],'compile-java')
|
||||
for side in jars:
|
||||
export=build/(side+'-definitions');export.mkdir(exist_ok=True);java('VanillaSimpleBlockOracle',side,'export',export)
|
||||
for path in (build/'server-definitions').iterdir():
|
||||
if path.name=='inputs.txt':continue # survival export's own corpus
|
||||
if path.read_bytes()!=(build/'client-definitions'/path.name).read_bytes():raise ValueError('reference definitions differ: '+path.name)
|
||||
(build/path.name).write_bytes(path.read_bytes())
|
||||
facts=json.loads((build/'facts.json').read_text())
|
||||
rules=survival.bind_definitions(*[json.loads((build/name).read_text()) for name in ['survival-classes.json','survival-placement-classes.json','survival-support-tags.json']]);(build/'survival-rules.json').write_text(json.dumps(rules,separators=(',',':')))
|
||||
inputs=build/'inputs.txt';count=0
|
||||
with inputs.open('w',encoding='utf-8') as output:
|
||||
only=os.environ.get('FEATURE_FILTER') # optional regex over feature names for focused reruns
|
||||
for fixture in corpus(facts,resources):
|
||||
if only and not __import__('re').search(only,fixture['feature']):continue
|
||||
output.write(json.dumps(fixture,separators=(',',':'))+'\n');count+=1
|
||||
fixtures=[inputs,*sorted(build.glob('*.nbt')),*[p for p in sorted(build.glob('*.json')) if p.name!='report.json']];tested_fixtures=fixture_hashes(fixtures)
|
||||
print(f'Prepared {count:,} feature fixtures',flush=True)
|
||||
run(['cargo','build','--release','-p','horizon-world','--example','tree_feature_fixture'],'compile-rust')
|
||||
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
|
||||
binary=Path(metadata['target_directory'])/'release/examples'/('tree_feature_fixture.exe' if os.name=='nt' else 'tree_feature_fixture')
|
||||
run([binary,build],'rust');references=[]
|
||||
for side,jar in jars.items():
|
||||
java('VanillaTreeFeatureOracle',side,side,build);matched=base.compare(build/(side+'.txt'),build/'rust.txt');print(f'{side}: {matched:,} tree/ore output lines match Rust',flush=True)
|
||||
references.append({'side':side,'jar_sha256':lab.digest(jar,'sha256'),'output_sha256':lab.digest(build/(side+'.txt'),'sha256'),'matched_output_lines':matched})
|
||||
base.ensure_sources_unchanged(sources,tested_sources);
|
||||
if fixture_hashes(fixtures)!=tested_fixtures:raise ValueError('fixtures changed during the run')
|
||||
report={'schema':1,'minecraft':lock['minecraft']['version'],'manifest_sha1':lock['minecraft']['manifest_sha1'],'platform':platform.platform(),'java':subprocess.check_output(['java','--version'],text=True).splitlines()[0],
|
||||
'rustc':subprocess.check_output(['rustc','--version'],text=True).strip(),'fixtures':count,'sources_sha256':tested_sources,'fixtures_sha256':tested_fixtures,'rust_output_sha256':lab.digest(build/'rust.txt','sha256'),'references':references,
|
||||
'scope':'Every vanilla 26.3 minecraft:tree (except pale-moss decorated), minecraft:fallen_tree, minecraft:ore and minecraft:scattered_ore configured feature, decoded from the authenticated JAR data, placed with both random kinds over layered synthetic worlds (open ground, leaf/stone/vine obstacles, flooded mud, near the build limit, podzol with grass) backed by native proto-chunk sections. Ordered level writes and flags, beehive occupants, post-processing marks, results, random tails and the final block diff of every touched chunk are compared, including native leaf distances and edge shape updates. Pale-moss ground patches, real WorldGenRegion write policy, heightmaps and decoration scheduling remain covered elsewhere or pending.'}
|
||||
lab.write_json(report_path,report);print(f'Scoped tree/ore feature parity passed: {report_path}',flush=True)
|
||||
|
||||
|
||||
if __name__=='__main__':main()
|
||||
Reference in New Issue
Block a user