ee485056fb
I see that there is an confusion between the pumpkin-core crate, People often think that this is the most important one
797 lines
30 KiB
Rust
797 lines
30 KiB
Rust
use std::sync::{Arc, LazyLock};
|
|
|
|
use crate::generation::{
|
|
noise::density::{
|
|
apply_blend_density,
|
|
basic::RangeFunction,
|
|
built_in_density_function::{
|
|
CAVES_ENTRANCES_OVERWORLD, CAVES_NOODLE_OVERWORLD, CONTINENTS_OVERWORLD,
|
|
CONTINENTS_OVERWORLD_LARGE_BIOME, EROSION_OVERWORLD, EROSION_OVERWORLD_LARGE_BIOME,
|
|
RIDGES_OVERWORLD, Y,
|
|
},
|
|
vertical_range_choice,
|
|
},
|
|
ore_sampler::vein_type,
|
|
};
|
|
|
|
use super::{
|
|
built_in_noise_params,
|
|
density::{
|
|
basic::{ConstantFunction, WrapperFunction, WrapperType, YClampedFunction},
|
|
built_in_density_function::{
|
|
CAVES_PILLARS_OVERWORLD, CAVES_SPAGHETTI_2D_OVERWORLD,
|
|
CAVES_SPAGHETTI_ROUGHNESS_FUNCTION_OVERWORLD, DEPTH_OVERWORLD,
|
|
DEPTH_OVERWORLD_AMPLIFIED, DEPTH_OVERWORLD_LARGE_BIOME, FACTOR_OVERWORLD,
|
|
FACTOR_OVERWORLD_AMPLIFIED, FACTOR_OVERWORLD_LARGE_BIOME, SHIFT_X, SHIFT_Z,
|
|
SLOPED_CHEESE_OVERWORLD, SLOPED_CHEESE_OVERWORLD_AMPLIFIED,
|
|
SLOPED_CHEESE_OVERWORLD_LARGE_BIOME, ZERO,
|
|
},
|
|
component_functions::{
|
|
ComponentReference, ComponentReferenceMap, ComponentReferenceMath, ConverterImpl,
|
|
DensityFunctionEnvironment, NoEnvironment, SharedComponentReference,
|
|
},
|
|
lerp_density_static_start,
|
|
noise::{InternalNoise, NoiseFunction, ShiftedNoiseFunction},
|
|
},
|
|
};
|
|
|
|
pub static OVERWORLD_NOISE_ROUTER: LazyLock<BaseRouter> =
|
|
LazyLock::new(|| BaseRouter::create_surface_noise_router(false, false));
|
|
pub static OVERWORLD_NOISE_ROUTER_LARGE: LazyLock<BaseRouter> =
|
|
LazyLock::new(|| BaseRouter::create_surface_noise_router(true, false));
|
|
pub static OVERWORLD_NOISE_ROUTER_AMPLIFIED: LazyLock<BaseRouter> =
|
|
LazyLock::new(|| BaseRouter::create_surface_noise_router(false, true));
|
|
|
|
pub struct BaseRouter {
|
|
pub(crate) barrier: SharedComponentReference,
|
|
pub(crate) fluid_level_floodedness: SharedComponentReference,
|
|
pub(crate) fluid_level_spread: SharedComponentReference,
|
|
pub(crate) lava: SharedComponentReference,
|
|
pub(crate) temperature: SharedComponentReference,
|
|
pub(crate) vegetation: SharedComponentReference,
|
|
pub(crate) continents: SharedComponentReference,
|
|
pub(crate) erosion: SharedComponentReference,
|
|
pub(crate) depth: SharedComponentReference,
|
|
pub(crate) ridges: SharedComponentReference,
|
|
pub(crate) internal_density: SharedComponentReference,
|
|
pub(crate) final_density: SharedComponentReference,
|
|
pub(crate) vein_toggle: SharedComponentReference,
|
|
pub(crate) vein_ridged: SharedComponentReference,
|
|
pub(crate) vein_gap: SharedComponentReference,
|
|
}
|
|
|
|
// TODO: This is double indirection... can we do something about that?
|
|
pub struct NoiseRouter<E: DensityFunctionEnvironment> {
|
|
pub(crate) barrier: Box<dyn ComponentReference<E>>,
|
|
pub(crate) fluid_level_floodedness: Box<dyn ComponentReference<E>>,
|
|
pub(crate) fluid_level_spread: Box<dyn ComponentReference<E>>,
|
|
pub(crate) lava: Box<dyn ComponentReference<E>>,
|
|
pub(crate) temperature: Box<dyn ComponentReference<E>>,
|
|
pub(crate) vegetation: Box<dyn ComponentReference<E>>,
|
|
pub(crate) continents: Box<dyn ComponentReference<E>>,
|
|
pub(crate) erosion: Box<dyn ComponentReference<E>>,
|
|
pub(crate) depth: Box<dyn ComponentReference<E>>,
|
|
pub(crate) ridges: Box<dyn ComponentReference<E>>,
|
|
pub(crate) internal_density: Box<dyn ComponentReference<E>>,
|
|
pub(crate) final_density: Box<dyn ComponentReference<E>>,
|
|
pub(crate) vein_toggle: Box<dyn ComponentReference<E>>,
|
|
pub(crate) vein_ridged: Box<dyn ComponentReference<E>>,
|
|
pub(crate) vein_gap: Box<dyn ComponentReference<E>>,
|
|
}
|
|
|
|
impl BaseRouter {
|
|
pub fn convert_assert_shared(
|
|
&self,
|
|
converter: &mut dyn ConverterImpl<NoEnvironment>,
|
|
) -> BaseRouter {
|
|
BaseRouter {
|
|
barrier: self.barrier.clone().convert(converter).assert_shared(),
|
|
fluid_level_floodedness: self
|
|
.fluid_level_floodedness
|
|
.clone()
|
|
.convert(converter)
|
|
.assert_shared(),
|
|
fluid_level_spread: self
|
|
.fluid_level_spread
|
|
.clone()
|
|
.convert(converter)
|
|
.assert_shared(),
|
|
lava: self.lava.clone().convert(converter).assert_shared(),
|
|
temperature: self.temperature.clone().convert(converter).assert_shared(),
|
|
vegetation: self.vegetation.clone().convert(converter).assert_shared(),
|
|
continents: self.continents.clone().convert(converter).assert_shared(),
|
|
erosion: self.erosion.clone().convert(converter).assert_shared(),
|
|
depth: self.depth.clone().convert(converter).assert_shared(),
|
|
ridges: self.ridges.clone().convert(converter).assert_shared(),
|
|
internal_density: self
|
|
.internal_density
|
|
.clone()
|
|
.convert(converter)
|
|
.assert_shared(),
|
|
final_density: self
|
|
.final_density
|
|
.clone()
|
|
.convert(converter)
|
|
.assert_shared(),
|
|
vein_toggle: self.vein_toggle.clone().convert(converter).assert_shared(),
|
|
vein_ridged: self.vein_ridged.clone().convert(converter).assert_shared(),
|
|
vein_gap: self.vein_gap.clone().convert(converter).assert_shared(),
|
|
}
|
|
}
|
|
|
|
pub fn convert<E: DensityFunctionEnvironment>(
|
|
&self,
|
|
converter: &mut dyn ConverterImpl<E>,
|
|
) -> NoiseRouter<E> {
|
|
NoiseRouter {
|
|
barrier: self.barrier.clone().convert(converter).boxed(),
|
|
fluid_level_floodedness: self
|
|
.fluid_level_floodedness
|
|
.clone()
|
|
.convert(converter)
|
|
.boxed(),
|
|
fluid_level_spread: self.fluid_level_spread.clone().convert(converter).boxed(),
|
|
lava: self.lava.clone().convert(converter).boxed(),
|
|
temperature: self.temperature.clone().convert(converter).boxed(),
|
|
vegetation: self.vegetation.clone().convert(converter).boxed(),
|
|
continents: self.continents.clone().convert(converter).boxed(),
|
|
erosion: self.erosion.clone().convert(converter).boxed(),
|
|
depth: self.depth.clone().convert(converter).boxed(),
|
|
ridges: self.ridges.clone().convert(converter).boxed(),
|
|
internal_density: self.internal_density.clone().convert(converter).boxed(),
|
|
final_density: self.final_density.clone().convert(converter).boxed(),
|
|
vein_toggle: self.vein_toggle.clone().convert(converter).boxed(),
|
|
vein_ridged: self.vein_ridged.clone().convert(converter).boxed(),
|
|
vein_gap: self.vein_gap.clone().convert(converter).boxed(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl BaseRouter {
|
|
pub fn create_surface_noise_router(large_biomes: bool, amplified: bool) -> Self {
|
|
#[cfg(debug_assertions)]
|
|
assert!(!(large_biomes && amplified));
|
|
|
|
let aquifier_barrier = NoiseFunction::new(
|
|
Arc::new(InternalNoise::new(
|
|
&built_in_noise_params::AQUIFER_BARRIER,
|
|
None,
|
|
)),
|
|
1f64,
|
|
0.5f64,
|
|
);
|
|
|
|
let aquifier_fluid_level_floodedness = NoiseFunction::new(
|
|
Arc::new(InternalNoise::new(
|
|
&built_in_noise_params::AQUIFER_FLUID_LEVEL_FLOODEDNESS,
|
|
None,
|
|
)),
|
|
1f64,
|
|
0.67f64,
|
|
);
|
|
|
|
let aquifer_fluid_level_spread = NoiseFunction::new(
|
|
Arc::new(InternalNoise::new(
|
|
&built_in_noise_params::AQUIFER_FLUID_LEVEL_SPREAD,
|
|
None,
|
|
)),
|
|
1f64,
|
|
0.7142857142857143f64,
|
|
);
|
|
|
|
let aquifer_lava = NoiseFunction::new(
|
|
Arc::new(InternalNoise::new(
|
|
&built_in_noise_params::AQUIFER_LAVA,
|
|
None,
|
|
)),
|
|
1f64,
|
|
1f64,
|
|
);
|
|
|
|
let temperature = ShiftedNoiseFunction::<
|
|
NoEnvironment,
|
|
SharedComponentReference,
|
|
SharedComponentReference,
|
|
SharedComponentReference,
|
|
>::new(
|
|
SHIFT_X.clone(),
|
|
ZERO.clone(),
|
|
SHIFT_Z.clone(),
|
|
0.25f64,
|
|
0f64,
|
|
Arc::new(InternalNoise::new(
|
|
if large_biomes {
|
|
&built_in_noise_params::TEMPERATURE_LARGE
|
|
} else {
|
|
&built_in_noise_params::TEMPERATURE
|
|
},
|
|
None,
|
|
)),
|
|
);
|
|
|
|
let vegetation = ShiftedNoiseFunction::<
|
|
NoEnvironment,
|
|
SharedComponentReference,
|
|
SharedComponentReference,
|
|
SharedComponentReference,
|
|
>::new(
|
|
SHIFT_X.clone(),
|
|
ZERO.clone(),
|
|
SHIFT_Z.clone(),
|
|
0.25f64,
|
|
0f64,
|
|
Arc::new(InternalNoise::new(
|
|
if large_biomes {
|
|
&built_in_noise_params::VEGETATION_LARGE
|
|
} else {
|
|
&built_in_noise_params::VEGETATION
|
|
},
|
|
None,
|
|
)),
|
|
);
|
|
|
|
let factor_overworld = if large_biomes {
|
|
FACTOR_OVERWORLD_LARGE_BIOME.clone()
|
|
} else if amplified {
|
|
FACTOR_OVERWORLD_AMPLIFIED.clone()
|
|
} else {
|
|
FACTOR_OVERWORLD.clone()
|
|
};
|
|
|
|
let depth_overworld = if large_biomes {
|
|
DEPTH_OVERWORLD_LARGE_BIOME.clone()
|
|
} else if amplified {
|
|
DEPTH_OVERWORLD_AMPLIFIED.clone()
|
|
} else {
|
|
DEPTH_OVERWORLD.clone()
|
|
};
|
|
|
|
let mapped_depth_overworld = ConstantFunction::new(4f64).mul(
|
|
depth_overworld
|
|
.clone()
|
|
.mul(
|
|
WrapperFunction::<NoEnvironment, SharedComponentReference>::new(
|
|
factor_overworld,
|
|
WrapperType::Cache2D,
|
|
)
|
|
.into(),
|
|
)
|
|
.quarter_negative(),
|
|
);
|
|
|
|
let sloped_cheese_overworld = if large_biomes {
|
|
SLOPED_CHEESE_OVERWORLD_LARGE_BIOME.clone()
|
|
} else if amplified {
|
|
SLOPED_CHEESE_OVERWORLD_AMPLIFIED.clone()
|
|
} else {
|
|
SLOPED_CHEESE_OVERWORLD.clone()
|
|
};
|
|
|
|
let cave_entrances_overworld = sloped_cheese_overworld
|
|
.clone()
|
|
.min(ConstantFunction::new(5f64).mul(CAVES_ENTRANCES_OVERWORLD.clone()));
|
|
|
|
let mapped_cave_entrances_overworld = RangeFunction::<
|
|
NoEnvironment,
|
|
SharedComponentReference,
|
|
SharedComponentReference,
|
|
SharedComponentReference,
|
|
>::new(
|
|
sloped_cheese_overworld.clone(),
|
|
-1000000f64,
|
|
1.5625f64,
|
|
cave_entrances_overworld,
|
|
create_caves(sloped_cheese_overworld),
|
|
);
|
|
|
|
let blended_cave_entrances_overworld = apply_blend_density(apply_surface_slides(
|
|
amplified,
|
|
mapped_cave_entrances_overworld.into(),
|
|
))
|
|
.min(CAVES_NOODLE_OVERWORLD.clone());
|
|
|
|
let i = vein_type::MIN_Y;
|
|
let j = vein_type::MAX_Y;
|
|
let ore_veininess = vertical_range_choice(
|
|
Y.clone(),
|
|
NoiseFunction::new(
|
|
Arc::new(InternalNoise::new(
|
|
&built_in_noise_params::ORE_VEININESS,
|
|
None,
|
|
)),
|
|
1.5f64,
|
|
1.5f64,
|
|
)
|
|
.into(),
|
|
i,
|
|
j,
|
|
0,
|
|
);
|
|
|
|
let ore_vein_a = vertical_range_choice(
|
|
Y.clone(),
|
|
NoiseFunction::new(
|
|
Arc::new(InternalNoise::new(&built_in_noise_params::ORE_VEIN_A, None)),
|
|
4f64,
|
|
4f64,
|
|
)
|
|
.into(),
|
|
i,
|
|
j,
|
|
0,
|
|
)
|
|
.abs();
|
|
|
|
let ore_vein_b = vertical_range_choice(
|
|
Y.clone(),
|
|
NoiseFunction::new(
|
|
Arc::new(InternalNoise::new(&built_in_noise_params::ORE_VEIN_B, None)),
|
|
4f64,
|
|
4f64,
|
|
)
|
|
.into(),
|
|
i,
|
|
j,
|
|
0,
|
|
)
|
|
.abs();
|
|
|
|
let ore_vein = ConstantFunction::new(-0.08f32 as f64).add(ore_vein_a.max(ore_vein_b));
|
|
|
|
let ore_gap = NoiseFunction::new(
|
|
Arc::new(InternalNoise::new(&built_in_noise_params::ORE_GAP, None)),
|
|
1f64,
|
|
1f64,
|
|
);
|
|
|
|
Self {
|
|
barrier: aquifier_barrier.into(),
|
|
fluid_level_floodedness: aquifier_fluid_level_floodedness.into(),
|
|
fluid_level_spread: aquifer_fluid_level_spread.into(),
|
|
lava: aquifer_lava.into(),
|
|
temperature: temperature.into(),
|
|
vegetation: vegetation.into(),
|
|
continents: if large_biomes {
|
|
CONTINENTS_OVERWORLD_LARGE_BIOME.clone()
|
|
} else {
|
|
CONTINENTS_OVERWORLD.clone()
|
|
},
|
|
erosion: if large_biomes {
|
|
EROSION_OVERWORLD_LARGE_BIOME.clone()
|
|
} else {
|
|
EROSION_OVERWORLD.clone()
|
|
},
|
|
depth: depth_overworld,
|
|
ridges: RIDGES_OVERWORLD.clone(),
|
|
internal_density: apply_surface_slides(
|
|
amplified,
|
|
mapped_depth_overworld
|
|
.add_const(-0.703125f64)
|
|
.clamp(-64f64, 64f64),
|
|
),
|
|
final_density: blended_cave_entrances_overworld,
|
|
vein_toggle: ore_veininess,
|
|
vein_ridged: ore_vein,
|
|
vein_gap: ore_gap.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn apply_surface_slides(
|
|
amplified: bool,
|
|
density: SharedComponentReference,
|
|
) -> SharedComponentReference {
|
|
apply_slides(
|
|
density,
|
|
-64,
|
|
384,
|
|
if amplified { 16 } else { 80 },
|
|
if amplified { 0 } else { 64 },
|
|
-0.078125f64,
|
|
0,
|
|
24,
|
|
if amplified { 0.4f64 } else { 0.1171875f64 },
|
|
)
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn apply_slides(
|
|
density: SharedComponentReference,
|
|
y_min: i32,
|
|
y_max: i32,
|
|
top_rel_y_min: i32,
|
|
top_rel_y_max: i32,
|
|
top_density: f64,
|
|
bottom_rel_y_min: i32,
|
|
bottom_rel_y_max: i32,
|
|
bottom_density: f64,
|
|
) -> SharedComponentReference {
|
|
let function2 = YClampedFunction::new(
|
|
y_min + y_max - top_rel_y_min,
|
|
y_min + y_max - top_rel_y_max,
|
|
1f64,
|
|
0f64,
|
|
);
|
|
let function = lerp_density_static_start(function2.into(), top_density, density);
|
|
let function3 = YClampedFunction::new(
|
|
y_min + bottom_rel_y_min,
|
|
y_min + bottom_rel_y_max,
|
|
0f64,
|
|
1f64,
|
|
);
|
|
lerp_density_static_start(function3.into(), bottom_density, function)
|
|
}
|
|
|
|
fn create_caves(sloped_cheese: SharedComponentReference) -> SharedComponentReference {
|
|
let cave_layer = NoiseFunction::new(
|
|
Arc::new(InternalNoise::new(&built_in_noise_params::CAVE_LAYER, None)),
|
|
1f64,
|
|
8f64,
|
|
);
|
|
let scaled_cave_layer = ConstantFunction::new(4f64).mul(cave_layer.square());
|
|
let cave_cheese = NoiseFunction::new(
|
|
Arc::new(InternalNoise::new(
|
|
&built_in_noise_params::CAVE_CHEESE,
|
|
None,
|
|
)),
|
|
1f64,
|
|
0.6666666666666666f64,
|
|
);
|
|
let scaled_cave_cheese = ConstantFunction::new(0.27f64)
|
|
.add(cave_cheese.into())
|
|
.clamp(-1f64, 1f64)
|
|
.add(
|
|
ConstantFunction::new(1.5f64)
|
|
.add(ConstantFunction::new(-0.64f64).mul(sloped_cheese))
|
|
.clamp(0f64, 0.5f64),
|
|
);
|
|
let final_cave_layer = scaled_cave_layer.add(scaled_cave_cheese);
|
|
let cave_entrances = final_cave_layer.min(CAVES_ENTRANCES_OVERWORLD.clone()).min(
|
|
CAVES_SPAGHETTI_2D_OVERWORLD
|
|
.clone()
|
|
.add(CAVES_SPAGHETTI_ROUGHNESS_FUNCTION_OVERWORLD.clone()),
|
|
);
|
|
let scaled_pillars = RangeFunction::<
|
|
NoEnvironment,
|
|
SharedComponentReference,
|
|
SharedComponentReference,
|
|
SharedComponentReference,
|
|
>::new(
|
|
CAVES_PILLARS_OVERWORLD.clone(),
|
|
-1000000f64,
|
|
0.03f64,
|
|
ConstantFunction::new(-1000000f64).into(),
|
|
CAVES_PILLARS_OVERWORLD.clone(),
|
|
);
|
|
cave_entrances.max(scaled_pillars.into())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use std::{fs, path::Path, sync::Arc};
|
|
|
|
use pumpkin_util::{
|
|
assert_eq_delta,
|
|
random::{legacy_rand::LegacyRand, xoroshiro128::Xoroshiro, RandomDeriver, RandomImpl},
|
|
};
|
|
|
|
use crate::{
|
|
generation::noise::{
|
|
config::LegacyChunkNoiseVisitor,
|
|
density::{
|
|
built_in_density_function::{EROSION_OVERWORLD, SLOPED_CHEESE_OVERWORLD},
|
|
component_functions::{
|
|
ComponentReference, ComponentReferenceImplementation, ConversionResultPre,
|
|
ConverterEnvironment, ConverterImpl, NoEnvironment, OwnedConverterEnvironment,
|
|
},
|
|
noise::InternalNoise,
|
|
NoisePos, UnblendedNoisePos,
|
|
},
|
|
perlin::DoublePerlinNoiseSampler,
|
|
router::OVERWORLD_NOISE_ROUTER,
|
|
},
|
|
read_data_from_file,
|
|
};
|
|
|
|
use super::{apply_surface_slides, create_caves};
|
|
|
|
pub struct TestConverter {
|
|
pub splitter: RandomDeriver,
|
|
}
|
|
|
|
impl ConverterImpl<NoEnvironment> for TestConverter {
|
|
fn convert_noise(&mut self, noise: &Arc<InternalNoise>) -> Option<Arc<InternalNoise>> {
|
|
let id = noise.parameters.id();
|
|
let mut rand = self.splitter.split_string(id);
|
|
let sampler = DoublePerlinNoiseSampler::new(&mut rand, noise.parameters, false);
|
|
|
|
Some(Arc::new(InternalNoise::new(
|
|
noise.parameters,
|
|
Some(sampler),
|
|
)))
|
|
}
|
|
|
|
fn convert_env_pre_internal(
|
|
&mut self,
|
|
_component: ConverterEnvironment<NoEnvironment>,
|
|
) -> ConversionResultPre<NoEnvironment> {
|
|
ConversionResultPre::Default
|
|
}
|
|
|
|
fn converts_post_internal(
|
|
&mut self,
|
|
_component: ConverterEnvironment<NoEnvironment>,
|
|
) -> bool {
|
|
false
|
|
}
|
|
|
|
fn convert_env_post_internal(
|
|
&mut self,
|
|
_component: OwnedConverterEnvironment<NoEnvironment>,
|
|
) -> ComponentReferenceImplementation<NoEnvironment> {
|
|
unreachable!()
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_apply_surface_slides() {
|
|
let mut rand = LegacyRand::from_seed(0);
|
|
let splitter = rand.next_splitter();
|
|
let mut converter = TestConverter {
|
|
splitter: RandomDeriver::Legacy(splitter),
|
|
};
|
|
let converted_func = EROSION_OVERWORLD
|
|
.clone()
|
|
.convert(&mut converter)
|
|
.assert_shared();
|
|
|
|
let values = [
|
|
((-1000, -1000), -0.30208879996359317f64),
|
|
((-1000, -800), -0.1076130122697041f64),
|
|
((-1000, -600), 0.05906607850421469f64),
|
|
((-1000, -400), 0.24726986724384714f64),
|
|
((-1000, -200), 0.2706794457383526f64),
|
|
((-1000, 0), 0.2697306747800193f64),
|
|
((-1000, 200), 0.21391910117663293f64),
|
|
((-1000, 400), 0.18535143299569468f64),
|
|
((-1000, 600), 0.1294413488921486f64),
|
|
((-1000, 800), 0.061580256900142794f64),
|
|
((-1000, 1000), 0.12530753721310528f64),
|
|
((-800, -1000), -0.26334816753858103f64),
|
|
((-800, -800), -0.020687744964915544f64),
|
|
((-800, -600), 0.023225727811309105f64),
|
|
((-800, -400), 0.07746776104719977f64),
|
|
((-800, -200), 0.09992470719841956f64),
|
|
((-800, 0), 0.1146551050894824f64),
|
|
((-800, 200), 0.06564485641223794f64),
|
|
((-800, 400), 0.08848851954273917f64),
|
|
((-800, 600), 0.056160953033021266f64),
|
|
((-800, 800), 0.011045253253628817f64),
|
|
((-800, 1000), 0.015198372445202502f64),
|
|
((-600, -1000), -0.16525687371490894f64),
|
|
((-600, -800), 0.05293810125583154f64),
|
|
((-600, -600), 0.17475689197213684f64),
|
|
((-600, -400), 0.16103184321844596f64),
|
|
((-600, -200), 0.04702586800266029f64),
|
|
((-600, 0), 0.008498755101605193f64),
|
|
((-600, 200), -0.05632912234656379f64),
|
|
((-600, 400), -0.03331984537443711f64),
|
|
((-600, 600), -0.15304483622814935f64),
|
|
((-600, 800), -0.10634904956802882f64),
|
|
((-600, 1000), -0.10145702807865031f64),
|
|
((-400, -1000), 0.014509904002985907f64),
|
|
((-400, -800), 0.1617721780377955f64),
|
|
((-400, -600), 0.1538795562844772f64),
|
|
((-400, -400), 0.09291099527948621f64),
|
|
((-400, -200), 0.016032945505656093f64),
|
|
((-400, 0), -0.12944528371858455f64),
|
|
((-400, 200), -0.22407726246974746f64),
|
|
((-400, 400), -0.18164279264712324f64),
|
|
((-400, 600), -0.15374226930846258f64),
|
|
((-400, 800), -0.14225372340399312f64),
|
|
((-400, 1000), -0.1707662008691604f64),
|
|
((-200, -1000), 0.1737449324031909f64),
|
|
((-200, -800), 0.15588767399915038f64),
|
|
((-200, -600), 0.09807388580637255f64),
|
|
((-200, -400), 0.04134584798831298f64),
|
|
((-200, -200), 0.07633793620513718f64),
|
|
((-200, 0), -0.16636855652213256f64),
|
|
((-200, 200), -0.13472373172620833f64),
|
|
((-200, 400), -0.22022531422260827f64),
|
|
((-200, 600), -0.1733817125721101f64),
|
|
((-200, 800), -0.25850640558184435f64),
|
|
((-200, 1000), -0.3016979165025152f64),
|
|
((0, -1000), 0.251814304135237f64),
|
|
((0, -800), 0.13332966941629143f64),
|
|
((0, -600), 0.10348476729023426f64),
|
|
((0, -400), 0.05536479756994106f64),
|
|
((0, -200), -0.01381233701693424f64),
|
|
((0, 0), -0.19098385460723655f64),
|
|
((0, 200), -0.2404237434218891f64),
|
|
((0, 400), -0.2610517555168873f64),
|
|
((0, 600), -0.2903199404423026f64),
|
|
((0, 800), -0.3374524245257239f64),
|
|
((0, 1000), -0.46305810978001316f64),
|
|
((200, -1000), 0.28709965377682267f64),
|
|
((200, -800), 0.19268673409560028f64),
|
|
((200, -600), 0.0041189472733734744f64),
|
|
((200, -400), -0.047481063682935865f64),
|
|
((200, -200), -0.17715255198738433f64),
|
|
((200, 0), -0.2656740328018877f64),
|
|
((200, 200), -0.38846940763264115f64),
|
|
((200, 400), -0.3771208707257109f64),
|
|
((200, 600), -0.42164320098305474f64),
|
|
((200, 800), -0.45957304404559196f64),
|
|
((200, 1000), -0.3886247688972352f64),
|
|
((400, -1000), 0.2946831456942509f64),
|
|
((400, -800), 0.15366391689596104f64),
|
|
((400, -600), -0.03683895527138398f64),
|
|
((400, -400), -0.12286969762482891f64),
|
|
((400, -200), -0.279692934897965f64),
|
|
((400, 0), -0.3299116026613176f64),
|
|
((400, 200), -0.4397636078519035f64),
|
|
((400, 400), -0.5016687095505773f64),
|
|
((400, 600), -0.4593088249355858f64),
|
|
((400, 800), -0.4120918663615397f64),
|
|
((400, 1000), -0.33349227727910835f64),
|
|
((600, -1000), 0.22507430288840974f64),
|
|
((600, -800), 0.11690723489828847f64),
|
|
((600, -600), -0.07736959302795038f64),
|
|
((600, -400), -0.3103436858126015f64),
|
|
((600, -200), -0.4646135074970098f64),
|
|
((600, 0), -0.42802179309528376f64),
|
|
((600, 200), -0.5031234101517712f64),
|
|
((600, 400), -0.43980110641169434f64),
|
|
((600, 600), -0.418150522213239f64),
|
|
((600, 800), -0.2858012217898377f64),
|
|
((600, 1000), -0.2078009597778817f64),
|
|
((800, -1000), 0.02646235055281687f64),
|
|
((800, -800), -0.0025711457048024355f64),
|
|
((800, -600), -0.22091967015314884f64),
|
|
((800, -400), -0.36062363978247114f64),
|
|
((800, -200), -0.5267644629903612f64),
|
|
((800, 0), -0.5221952728781099f64),
|
|
((800, 200), -0.5583524962468077f64),
|
|
((800, 400), -0.6064703416700034f64),
|
|
((800, 600), -0.42124877767264723f64),
|
|
((800, 800), -0.41023710661537083f64),
|
|
((800, 1000), -0.31011231029109043f64),
|
|
((1000, -1000), -0.13246158771459038f64),
|
|
((1000, -800), -0.21539115619228733f64),
|
|
((1000, -600), -0.2583347168279443f64),
|
|
((1000, -400), -0.3998592325985889f64),
|
|
((1000, -200), -0.5387601014248653f64),
|
|
((1000, 0), -0.5666190345839045f64),
|
|
((1000, 200), -0.6213722075094567f64),
|
|
((1000, 400), -0.671739773000314f64),
|
|
((1000, 600), -0.6238217558734026f64),
|
|
((1000, 800), -0.49441693548204757f64),
|
|
((1000, 1000), -0.3843933568068797f64),
|
|
];
|
|
let amplified = apply_surface_slides(true, converted_func);
|
|
for ((x, z), value) in values {
|
|
let pos = &NoisePos::Unblended(UnblendedNoisePos::new(x, 60, z));
|
|
assert_eq!(amplified.sample(pos), value);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_normal_surface_functions() {
|
|
let pos = &NoisePos::Unblended(UnblendedNoisePos::new(0, 0, 0));
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.barrier.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.fluid_level_floodedness.sample(pos),
|
|
0f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.fluid_level_spread.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.lava.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.temperature.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.vegetation.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.continents.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.erosion.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.depth.sample(pos),
|
|
0.3962499722838402f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.ridges.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.internal_density.sample(pos),
|
|
8.093466727565826f64
|
|
);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.final_density.sample(pos),
|
|
-0.07500000000000001f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.vein_toggle.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.vein_ridged.sample(pos),
|
|
-0.07999999821186066f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.vein_gap.sample(pos), 0f64);
|
|
|
|
let pos = &NoisePos::Unblended(UnblendedNoisePos::new(0, 60, 0));
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.barrier.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.fluid_level_floodedness.sample(pos),
|
|
0f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.fluid_level_spread.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.lava.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.temperature.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.vegetation.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.continents.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.erosion.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.depth.sample(pos),
|
|
-0.07250002771615982f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.ridges.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.internal_density.sample(pos),
|
|
-1.105492942375168f64
|
|
);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.final_density.sample(pos),
|
|
-0.15607060320915436f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.vein_toggle.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.vein_ridged.sample(pos),
|
|
-0.07999999821186066f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.vein_gap.sample(pos), 0f64);
|
|
|
|
let pos = &NoisePos::Unblended(UnblendedNoisePos::new(0, 120, 0));
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.barrier.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.fluid_level_floodedness.sample(pos),
|
|
0f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.fluid_level_spread.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.lava.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.temperature.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.vegetation.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.continents.sample(pos), 0f64);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.erosion.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.depth.sample(pos),
|
|
-0.5412500277161598f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.ridges.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.internal_density.sample(pos),
|
|
-3.7070088166417925f64
|
|
);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.final_density.sample(pos),
|
|
-0.4583333333333333f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.vein_toggle.sample(pos), 0f64);
|
|
assert_eq!(
|
|
OVERWORLD_NOISE_ROUTER.vein_ridged.sample(pos),
|
|
-0.07999999821186066f64
|
|
);
|
|
assert_eq!(OVERWORLD_NOISE_ROUTER.vein_gap.sample(pos), 0f64);
|
|
}
|
|
|
|
#[test]
|
|
fn test_converted_cave() {
|
|
let mut rand = Xoroshiro::from_seed(0);
|
|
let mut converter =
|
|
LegacyChunkNoiseVisitor::new(RandomDeriver::Xoroshiro(rand.next_splitter()), 0);
|
|
|
|
let expected_data: Vec<(i32, i32, i32, f64)> =
|
|
read_data_from_file!("../../../assets/converted_cave_7_4.json");
|
|
|
|
let function = create_caves(SLOPED_CHEESE_OVERWORLD.clone())
|
|
.maybe_convert(&mut converter)
|
|
.unwrap()
|
|
.assert_shared();
|
|
|
|
for (x, y, z, sample) in expected_data {
|
|
let pos = NoisePos::Unblended(UnblendedNoisePos::new(x, y, z));
|
|
assert_eq_delta!(function.sample(&pos), sample, f64::EPSILON);
|
|
}
|
|
}
|
|
}
|