426 lines
12 KiB
Rust
426 lines
12 KiB
Rust
use std::{
|
||
sync::atomic::{AtomicU64, Ordering},
|
||
time,
|
||
};
|
||
|
||
use legacy_rand::{LegacyRand, LegacySplitter};
|
||
use worldgen_random::WorldgenRandom;
|
||
use xoroshiro128::{Xoroshiro, XoroshiroSplitter};
|
||
|
||
mod gaussian;
|
||
pub mod legacy_rand;
|
||
pub mod worldgen_random;
|
||
pub mod xoroshiro128;
|
||
|
||
/// Global seed uniquifier used to generate unique seeds based on time.
|
||
static SEED_UNIQUIFIER: AtomicU64 = AtomicU64::new(8682522807148012u64);
|
||
|
||
pub fn get_seed() -> u64 {
|
||
let seed = SEED_UNIQUIFIER
|
||
.try_update(Ordering::Relaxed, Ordering::Relaxed, |val| {
|
||
Some(val.wrapping_mul(1181783497276652981u64))
|
||
})
|
||
.unwrap_or(0);
|
||
|
||
let nanos = time::SystemTime::now()
|
||
.duration_since(time::SystemTime::UNIX_EPOCH)
|
||
.map_or(0, |d| d.as_nanos());
|
||
|
||
let nano_upper = (nanos >> 8) as u64;
|
||
let nano_lower = nanos as u64;
|
||
seed ^ nano_upper ^ nano_lower
|
||
}
|
||
|
||
pub enum RandomGenerator {
|
||
/// Xoroshiro128+ random number generator (modern, fast implementation).
|
||
Xoroshiro(Xoroshiro),
|
||
/// Xoroshiro wrapped with Java `WorldgenRandom` bit-source semantics.
|
||
Worldgen(WorldgenRandom),
|
||
/// Legacy random number generator (compatible with older Minecraft versions).
|
||
Legacy(LegacyRand),
|
||
}
|
||
|
||
/// Unified random number deriver enum for creating child RNGs.
|
||
pub enum RandomDeriver {
|
||
/// Xoroshiro splitter implementation.
|
||
Xoroshiro(XoroshiroSplitter),
|
||
/// Legacy splitter implementation.
|
||
Legacy(LegacySplitter),
|
||
}
|
||
|
||
// TODO: Write unit test for this
|
||
#[macro_export]
|
||
macro_rules! population_seed_fn {
|
||
() => {
|
||
/// Generates a population seed for structure placement.
|
||
///
|
||
/// Population seeds are used to determine the placement of structures
|
||
/// like villages, temples, and other features. They combine the world seed
|
||
/// with block coordinates to create a unique seed for each chunk.
|
||
///
|
||
/// # Arguments
|
||
/// - `world_seed` – The base world seed.
|
||
/// - `block_x` – The X block coordinate.
|
||
/// - `block_z` – The Z block coordinate.
|
||
///
|
||
/// # Returns
|
||
/// A population seed for the given location.
|
||
pub fn get_population_seed(world_seed: u64, block_x: i32, block_z: i32) -> u64 {
|
||
let mut rand = Self::from_seed(world_seed);
|
||
let l = rand.next_i64() | 1;
|
||
let m = rand.next_i64() | 1;
|
||
let base = (block_x as i64)
|
||
.wrapping_mul(l)
|
||
.wrapping_add((block_z as i64).wrapping_mul(m));
|
||
(base as u64) ^ world_seed
|
||
}
|
||
};
|
||
}
|
||
|
||
/// Generates a decorator seed for feature placement.
|
||
///
|
||
/// Decorator seeds are used for placing individual features like trees,
|
||
/// flowers, and ores within a chunk.
|
||
///
|
||
/// # Arguments
|
||
/// - `population_seed` – The base population seed for the area.
|
||
/// - `index` – The index of the decorator.
|
||
/// - `step` – The decoration step number.
|
||
///
|
||
/// # Returns
|
||
/// A decorator seed for the given parameters.
|
||
// TODO: Write unit test for this
|
||
#[inline]
|
||
#[must_use]
|
||
pub const fn get_decorator_seed(population_seed: u64, index: u64, step: u64) -> u64 {
|
||
population_seed
|
||
.wrapping_add(index)
|
||
.wrapping_add(10_000u64.wrapping_mul(step))
|
||
}
|
||
|
||
/// Generates a region seed for large-scale feature placement.
|
||
///
|
||
/// Region seeds are used for features that span multiple chunks, such as
|
||
/// slime chunks or specific biome placements.
|
||
///
|
||
/// # Arguments
|
||
/// - `world_seed` – The base world seed.
|
||
/// - `region_x` – The X region coordinate.
|
||
/// - `region_z` – The Z region coordinate.
|
||
/// - `salt` – A salt value to make the seed unique for specific features.
|
||
///
|
||
/// # Returns
|
||
/// A region seed for the given location.
|
||
#[inline]
|
||
#[must_use]
|
||
pub fn get_region_seed(world_seed: u64, region_x: i32, region_z: i32, salt: u32) -> u64 {
|
||
let x_part = i64::from(region_x).wrapping_mul(341873128712) as u64;
|
||
let z_part = i64::from(region_z).wrapping_mul(132897987541) as u64;
|
||
|
||
world_seed
|
||
.wrapping_add(x_part)
|
||
.wrapping_add(z_part)
|
||
.wrapping_add(i64::from(salt) as u64)
|
||
}
|
||
|
||
/// Generates a seed for slime chunk determination.
|
||
///
|
||
/// This follows Minecraft's specific formula for identifying if a chunk
|
||
/// is a "slime chunk" where slimes can spawn regardless of light levels.
|
||
///
|
||
/// # Arguments
|
||
/// - `x` – The X chunk coordinate.
|
||
/// - `z` – The Z chunk coordinate.
|
||
/// - `seed` – The world seed.
|
||
/// - `salt` – A salt value (default is 987234911).
|
||
///
|
||
/// # Returns
|
||
/// A seed value to be used with a legacy random generator.
|
||
#[inline]
|
||
#[must_use]
|
||
pub const fn seed_slime_chunk(x: i32, z: i32, seed: u64, salt: u64) -> u64 {
|
||
(seed
|
||
.wrapping_add((x.wrapping_mul(x).wrapping_mul(4_987_142)) as i64 as u64)
|
||
.wrapping_add((x.wrapping_mul(5_947_611)) as i64 as u64)
|
||
.wrapping_add((z.wrapping_mul(z) as i64).wrapping_mul(4_392_871) as u64)
|
||
.wrapping_add((z.wrapping_mul(389_711)) as i64 as u64))
|
||
^ salt
|
||
}
|
||
|
||
/// Generates a carver seed for cave and ravine generation.
|
||
///
|
||
/// Carver seeds are used for terrain carving features like caves and ravines.
|
||
///
|
||
/// # Arguments
|
||
/// - `world_seed` – The base world seed (plus carver index).
|
||
/// - `chunk_x` – The X chunk coordinate.
|
||
/// - `chunk_z` – The Z chunk coordinate.
|
||
///
|
||
/// # Returns
|
||
/// A carver seed for the given chunk.
|
||
#[inline]
|
||
#[must_use]
|
||
pub fn get_carver_seed(world_seed: u64, chunk_x: i32, chunk_z: i32) -> u64 {
|
||
let mut random = LegacyRand::from_seed(world_seed);
|
||
let l = random.next_i64() | 1;
|
||
let m = random.next_i64() | 1;
|
||
((chunk_x as i64)
|
||
.wrapping_mul(l)
|
||
.wrapping_add((chunk_z as i64).wrapping_mul(m)) as u64)
|
||
^ world_seed
|
||
}
|
||
|
||
/// Generates a large feature seed for structure selection and placement.
|
||
///
|
||
/// Matches vanilla Minecraft's `WorldgenRandom.setLargeFeatureSeed`.
|
||
///
|
||
/// # Arguments
|
||
/// - `world_seed` – The base world seed.
|
||
/// - `chunk_x` – The X chunk coordinate.
|
||
/// - `chunk_z` – The Z chunk coordinate.
|
||
///
|
||
/// # Returns
|
||
/// A large feature seed for the given chunk.
|
||
#[inline]
|
||
#[must_use]
|
||
pub fn get_large_feature_seed(world_seed: u64, chunk_x: i32, chunk_z: i32) -> u64 {
|
||
let mut random = LegacyRand::from_seed(world_seed);
|
||
let x_scale = random.next_i64();
|
||
let z_scale = random.next_i64();
|
||
((chunk_x as i64).wrapping_mul(x_scale)
|
||
^ (chunk_z as i64).wrapping_mul(z_scale)
|
||
^ (world_seed as i64)) as u64
|
||
}
|
||
|
||
#[expect(clippy::return_self_not_must_use)]
|
||
pub trait RandomImpl {
|
||
fn split(&mut self) -> Self;
|
||
|
||
fn next_splitter(&mut self) -> RandomDeriver;
|
||
|
||
fn next_i32(&mut self) -> i32;
|
||
|
||
fn next_bounded_i32(&mut self, bound: i32) -> i32;
|
||
|
||
fn next_inbetween_i32(&mut self, min: i32, max: i32) -> i32 {
|
||
if min >= max {
|
||
return min;
|
||
}
|
||
self.next_bounded_i32(max - min + 1) + min
|
||
}
|
||
|
||
fn next_inbetween_f32(&mut self, min: f32, max: f32) -> f32 {
|
||
self.next_f32() * (max - min) + min
|
||
}
|
||
|
||
fn next_i64(&mut self) -> i64;
|
||
|
||
fn next_bool(&mut self) -> bool;
|
||
|
||
fn next_f32(&mut self) -> f32;
|
||
|
||
fn next_f64(&mut self) -> f64;
|
||
|
||
fn next_gaussian(&mut self) -> f64;
|
||
|
||
#[allow(clippy::suboptimal_flops)]
|
||
fn next_triangular(&mut self, mode: f64, deviation: f64) -> f64 {
|
||
mode + deviation * (self.next_f64() - self.next_f64())
|
||
}
|
||
|
||
fn skip(&mut self, count: i32) {
|
||
for _ in 0..count {
|
||
self.next_i64();
|
||
}
|
||
}
|
||
|
||
fn next_inbetween_i32_exclusive(&mut self, min: i32, max: i32) -> i32 {
|
||
if min >= max {
|
||
return min;
|
||
}
|
||
min + self.next_bounded_i32(max - min)
|
||
}
|
||
}
|
||
|
||
impl RandomImpl for RandomGenerator {
|
||
#[inline]
|
||
fn split(&mut self) -> Self {
|
||
match self {
|
||
Self::Xoroshiro(x) => Self::Xoroshiro(x.split()),
|
||
Self::Worldgen(x) => Self::Worldgen(x.split()),
|
||
Self::Legacy(l) => Self::Legacy(l.split()),
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn next_splitter(&mut self) -> RandomDeriver {
|
||
match self {
|
||
Self::Xoroshiro(x) => RandomDeriver::Xoroshiro(x.next_splitter()),
|
||
Self::Worldgen(x) => x.next_splitter(),
|
||
Self::Legacy(l) => l.next_splitter(),
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn next_i32(&mut self) -> i32 {
|
||
match self {
|
||
Self::Xoroshiro(x) => x.next_i32(),
|
||
Self::Worldgen(x) => x.next_i32(),
|
||
Self::Legacy(l) => l.next_i32(),
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn next_bounded_i32(&mut self, bound: i32) -> i32 {
|
||
match self {
|
||
Self::Xoroshiro(x) => x.next_bounded_i32(bound),
|
||
Self::Worldgen(x) => x.next_bounded_i32(bound),
|
||
Self::Legacy(l) => l.next_bounded_i32(bound),
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn next_i64(&mut self) -> i64 {
|
||
match self {
|
||
Self::Xoroshiro(x) => x.next_i64(),
|
||
Self::Worldgen(x) => x.next_i64(),
|
||
Self::Legacy(l) => l.next_i64(),
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn next_bool(&mut self) -> bool {
|
||
match self {
|
||
Self::Xoroshiro(x) => x.next_bool(),
|
||
Self::Worldgen(x) => x.next_bool(),
|
||
Self::Legacy(l) => l.next_bool(),
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn next_f32(&mut self) -> f32 {
|
||
match self {
|
||
Self::Xoroshiro(x) => x.next_f32(),
|
||
Self::Worldgen(x) => x.next_f32(),
|
||
Self::Legacy(l) => l.next_f32(),
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn next_f64(&mut self) -> f64 {
|
||
match self {
|
||
Self::Xoroshiro(x) => x.next_f64(),
|
||
Self::Worldgen(x) => x.next_f64(),
|
||
Self::Legacy(l) => l.next_f64(),
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn next_gaussian(&mut self) -> f64 {
|
||
match self {
|
||
Self::Xoroshiro(x) => x.next_gaussian(),
|
||
Self::Worldgen(x) => x.next_gaussian(),
|
||
Self::Legacy(l) => l.next_gaussian(),
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn skip(&mut self, count: i32) {
|
||
match self {
|
||
Self::Xoroshiro(x) => x.skip(count),
|
||
Self::Worldgen(x) => x.skip(count),
|
||
Self::Legacy(l) => l.skip(count),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub trait RandomDeriverImpl {
|
||
fn split_string(&self, seed: &str) -> RandomGenerator;
|
||
|
||
fn split_u64(&self, seed: u64) -> RandomGenerator;
|
||
|
||
fn split_pos(&self, x: i32, y: i32, z: i32) -> RandomGenerator;
|
||
}
|
||
|
||
impl RandomDeriverImpl for RandomDeriver {
|
||
#[inline]
|
||
fn split_string(&self, seed: &str) -> RandomGenerator {
|
||
match self {
|
||
Self::Xoroshiro(x) => RandomGenerator::Xoroshiro(x.split_string(seed)),
|
||
Self::Legacy(l) => l.split_string(seed),
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn split_u64(&self, seed: u64) -> RandomGenerator {
|
||
match self {
|
||
Self::Xoroshiro(x) => x.split_u64(seed),
|
||
Self::Legacy(l) => l.split_u64(seed),
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn split_pos(&self, x: i32, y: i32, z: i32) -> RandomGenerator {
|
||
match self {
|
||
Self::Xoroshiro(s) => RandomGenerator::Xoroshiro(s.split_pos(x, y, z)),
|
||
Self::Legacy(s) => s.split_pos(x, y, z),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Hashes a block position into a 64-bit value for use in RNG seeding.
|
||
///
|
||
/// This hash function is designed to produce well-distributed values for
|
||
/// use as seeds for position-dependent random generation.
|
||
///
|
||
/// # Arguments
|
||
/// - `x` – The X coordinate.
|
||
/// - `y` – The Y coordinate.
|
||
/// - `z` – The Z coordinate.
|
||
///
|
||
/// # Returns
|
||
/// A 64-bit hash value.
|
||
#[must_use]
|
||
pub const fn hash_block_pos(x: i32, y: i32, z: i32) -> i64 {
|
||
let l =
|
||
((x.wrapping_mul(3129871)) as i64) ^ ((z as i64).wrapping_mul(116129781i64)) ^ (y as i64);
|
||
|
||
let l = l
|
||
.wrapping_mul(l)
|
||
.wrapping_mul(42317861i64)
|
||
.wrapping_add(l.wrapping_mul(11i64));
|
||
|
||
l >> 16
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use crate::random::get_region_seed;
|
||
|
||
use super::hash_block_pos;
|
||
|
||
#[test]
|
||
fn region_seed() {
|
||
let seed = get_region_seed(12345612, 1, 1, 14357620);
|
||
assert_eq!(seed, 474797819485);
|
||
}
|
||
|
||
#[test]
|
||
fn block_position_hash() {
|
||
let values: [((i32, i32, i32), i64); 8] = [
|
||
((0, 0, 0), 0),
|
||
((1, 1, 1), 60311958971344),
|
||
((4, 4, 4), 120566413180880),
|
||
((25, 25, 25), 111753446486209),
|
||
((676, 676, 676), 75210837988243),
|
||
((458329, 458329, 458329), -43764888250),
|
||
((-387008604, -387008604, -387008604), 8437923733503),
|
||
((176771161, 176771161, 176771161), 18421337580760),
|
||
];
|
||
|
||
for ((x, y, z), value) in values {
|
||
assert_eq!(hash_block_pos(x, y, z), value);
|
||
}
|
||
}
|
||
}
|