Struct LegacyRandom 

pub struct LegacyRandom {
    seed: i64,
    next_gaussian: f64,
}

Legacy Minecraft random number generator based on a Linear Congruential Generator (LCG). This implementation mirrors Java’s java.util.Random which Minecraft originally used.

Fields

seed: i64

next_gaussian: f64

Implementations

impl LegacyRandom

pub const fn from_seed(seed: u64) -> Self

Creates a new LegacyRandom instance from the given seed. The seed is XORed with the LCG multiplier and masked to 48 bits, matching Java’s behavior.

pub const fn get_seed(&self) -> i64

Returns the internal seed (for debugging/checkpointing).

pub const fn set_seed(&mut self, seed: i64)

Re-seeds this generator, matching Java’s Random.setSeed.

pub fn set_large_feature_seed(&mut self, seed: i64, chunk_x: i32, chunk_z: i32)

Matches vanilla’s WorldgenRandom.setLargeFeatureSeed.

pub fn set_large_feature_with_salt( &mut self, seed: i64, x: i32, z: i32, salt: i32, )

Matches vanilla’s WorldgenRandom.setLargeFeatureWithSalt.

const fn next(&mut self, bits: u64) -> i32

const fn next_random(&mut self) -> i64

const fn skip(&mut self, count: u64)

Advance the LCG by count steps in O(log count) time.

Equivalent to calling next_random() count times and discarding the results. Each LCG step is the affine map T(s) = LCG_A · s + LCG_C (mod 2^48). Composing two such maps (A₂, C₂) ∘ (A₁, C₁) yields (A₂·A₁, A₂·C₁ + C₂), so binary exponentiation over the composition computes T^count in O(log count) without ever evaluating individual steps.

const fn so the compiler can fold the entire skip when count is a compile-time constant (as in EndIslands::new where it’s literally 17292).

Trait Implementations

impl From<LegacyRandom> for RandomSource

fn from(v: LegacyRandom) -> RandomSource

Converts to this type from the input type.

impl MarsagliaPolarGaussian for LegacyRandom

fn stored_next_gaussian(&self) -> Option<f64>

Gets the stored next gaussian.

fn set_stored_next_gaussian(&mut self, value: Option<f64>)

Sets the stored next gaussian.

fn calculate_gaussian(&mut self) -> f64

Calculates the next gaussian.

impl Random for LegacyRandom

fn fork(&mut self) -> Self

fn next_i32(&mut self) -> i32

fn next_i32_bounded(&mut self, bound: i32) -> i32

fn next_i64(&mut self) -> i64

fn next_f32(&mut self) -> f32

fn next_f64(&mut self) -> f64

fn next_bool(&mut self) -> bool

fn next_gaussian(&mut self) -> f64

fn next_positional(&mut self) -> RandomSplitter

fn consume_count(&mut self, count: i32)

fn next_i32_between(&mut self, min: i32, max: i32) -> i32

fn next_i32_between_exclusive(&mut self, min: i32, max: i32) -> i32

fn triangle(&mut self, min: f64, max: f64) -> f64

fn triangle_f32(&mut self, min: f32, max: f32) -> f32

impl TryInto<LegacyRandom> for RandomSource

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<LegacyRandom, <Self as TryInto<LegacyRandom>>::Error>

Performs the conversion.