use rand::{Rng, RngCore, SeedableRng};
use rand_pcg::Pcg64;
pub(crate) fn fnv1a_64(data: &[u8]) -> u64 {
const FNV_OFFSET: u64 = 0xcbf29ce484222325;
const FNV_PRIME: u64 = 0x100000001b3;
let mut hash = FNV_OFFSET;
for &byte in data {
hash ^= byte as u64;
hash = hash.wrapping_mul(FNV_PRIME);
}
hash
}
pub(crate) fn fnv1a_64_chain(a: &[u8], b: &[u8]) -> u64 {
const FNV_OFFSET: u64 = 0xcbf29ce484222325;
const FNV_PRIME: u64 = 0x100000001b3;
let mut hash = FNV_OFFSET;
for &byte in a {
hash ^= byte as u64;
hash = hash.wrapping_mul(FNV_PRIME);
}
for &byte in b {
hash ^= byte as u64;
hash = hash.wrapping_mul(FNV_PRIME);
}
hash
}
#[non_exhaustive]
pub struct StableRng {
inner: Pcg64,
seed: u64,
}
impl StableRng {
pub fn from_seed(seed: u64) -> Self {
Self {
inner: Pcg64::seed_from_u64(seed),
seed,
}
}
pub fn from_seed_bytes(seed: [u8; 32]) -> Self {
let s = fnv1a_64(&seed);
Self::from_seed(s)
}
pub fn derive(&self, label: &str) -> Self {
let derived = fnv1a_64_chain(&self.seed.to_le_bytes(), label.as_bytes());
Self::from_seed(derived)
}
pub fn seed(&self) -> u64 {
self.seed
}
pub fn random_range<T>(&mut self, min: T, max: T) -> T
where
T: rand::distr::uniform::SampleUniform + PartialOrd,
{
self.inner.random_range(min..max)
}
pub fn gen_bool(&mut self) -> bool {
self.inner.random()
}
pub fn gen_bool_with_probability(&mut self, probability: f64) -> bool {
if !probability.is_finite() {
return false;
}
if probability <= 0.0 {
return false;
}
if probability >= 1.0 {
return true;
}
self.inner.random_bool(probability)
}
pub fn gen_f64(&mut self) -> f64 {
self.inner.random()
}
pub fn gen_f32(&mut self) -> f32 {
self.inner.random()
}
pub fn choose<'a, T>(&mut self, slice: &'a [T]) -> Option<&'a T> {
if slice.is_empty() {
return None;
}
let index = self.random_range(0, slice.len());
Some(&slice[index])
}
pub fn choose_mut<'a, T>(&mut self, slice: &'a mut [T]) -> Option<&'a mut T> {
if slice.is_empty() {
return None;
}
let index = self.random_range(0, slice.len());
Some(&mut slice[index])
}
pub fn shuffle<T>(&mut self, slice: &mut [T]) {
let len = slice.len();
for i in (1..len).rev() {
let j = self.random_range(0, i + 1);
slice.swap(i, j);
}
}
pub fn sample<T: Clone>(&mut self, slice: &[T], n: usize) -> Vec<T> {
if n >= slice.len() {
let mut result = slice.to_vec();
self.shuffle(&mut result);
return result;
}
let mut indices: Vec<usize> = (0..slice.len()).collect();
self.shuffle(&mut indices);
indices
.into_iter()
.take(n)
.map(|i| slice[i].clone())
.collect()
}
pub fn choose_weighted<'a, T>(&mut self, slice: &'a [T], weights: &[f64]) -> Option<&'a T> {
if slice.len() != weights.len() {
return None;
}
if slice.is_empty() {
return None;
}
if weights.iter().any(|&w| w < 0.0) {
return None;
}
let total_weight: f64 = weights.iter().sum();
if !total_weight.is_finite() || total_weight <= 0.0 {
return None;
}
let mut random_value = self.gen_f64() * total_weight;
for (i, &weight) in weights.iter().enumerate() {
random_value -= weight;
if random_value <= 0.0 {
return Some(&slice[i]);
}
}
Some(&slice[slice.len() - 1])
}
}
impl RngCore for StableRng {
fn next_u32(&mut self) -> u32 {
self.inner.next_u32()
}
fn next_u64(&mut self) -> u64 {
self.inner.next_u64()
}
fn fill_bytes(&mut self, dest: &mut [u8]) {
self.inner.fill_bytes(dest);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_deterministic_generation() {
let mut rng1 = StableRng::from_seed(12345);
let mut rng2 = StableRng::from_seed(12345);
for _ in 0..100 {
assert_eq!(rng1.random::<u32>(), rng2.random::<u32>());
}
}
#[test]
fn test_different_seeds_produce_different_results() {
let mut rng1 = StableRng::from_seed(12345);
let mut rng2 = StableRng::from_seed(54321);
let values1: Vec<u32> = (0..10).map(|_| rng1.random()).collect();
let values2: Vec<u32> = (0..10).map(|_| rng2.random()).collect();
assert_ne!(values1, values2);
}
#[test]
fn test_derive_stream() {
let root_rng = StableRng::from_seed(12345);
let mut topology_rng1 = root_rng.derive("topology");
let mut topology_rng2 = root_rng.derive("topology");
for _ in 0..100 {
assert_eq!(topology_rng1.random::<u32>(), topology_rng2.random::<u32>());
}
}
#[test]
fn test_different_derive_labels() {
let root_rng = StableRng::from_seed(12345);
let mut topology_rng = root_rng.derive("topology");
let mut layout_rng = root_rng.derive("layout");
let topology_values: Vec<u32> = (0..10).map(|_| topology_rng.random()).collect();
let layout_values: Vec<u32> = (0..10).map(|_| layout_rng.random()).collect();
assert_ne!(topology_values, layout_values);
}
#[test]
fn test_nested_derive() {
let root_rng = StableRng::from_seed(12345);
let topology_rng = root_rng.derive("topology");
let mut room_0_rng1 = topology_rng.derive("room:0");
let mut room_0_rng2 = topology_rng.derive("room:0");
for _ in 0..100 {
assert_eq!(room_0_rng1.random::<u32>(), room_0_rng2.random::<u32>());
}
}
#[test]
fn test_debug_stream_isolation() {
let root_rng = StableRng::from_seed(12345);
let mut gameplay_rng1 = root_rng.derive("topology");
let gameplay_values1: Vec<u32> = (0..10).map(|_| gameplay_rng1.random()).collect();
let mut gameplay_rng2 = root_rng.derive("topology");
let mut _debug_rng = root_rng.derive("debug:visualization");
for _ in 0..100 {
_debug_rng.random::<u32>();
}
let gameplay_values2: Vec<u32> = (0..10).map(|_| gameplay_rng2.random()).collect();
assert_eq!(gameplay_values1, gameplay_values2);
}
#[test]
fn test_random_range() {
let mut rng = StableRng::from_seed(42);
for _ in 0..100 {
let value = rng.random_range(1, 10);
assert!((1..10).contains(&value));
}
}
#[test]
fn test_gen_bool_with_probability() {
let mut rng = StableRng::from_seed(42);
assert!(!rng.gen_bool_with_probability(0.0));
assert!(rng.gen_bool_with_probability(1.0));
let mut true_count = 0;
let iterations = 10000;
for _ in 0..iterations {
if rng.gen_bool_with_probability(0.7) {
true_count += 1;
}
}
let ratio = true_count as f64 / iterations as f64;
assert!((ratio - 0.7).abs() < 0.05);
}
#[test]
fn test_choose() {
let mut rng = StableRng::from_seed(42);
let items = vec![1, 2, 3, 4, 5];
for _ in 0..100 {
if let Some(&item) = rng.choose(&items) {
assert!(items.contains(&item));
}
}
let empty: Vec<i32> = vec![];
assert!(rng.choose(&empty).is_none());
}
#[test]
fn test_shuffle() {
let mut rng = StableRng::from_seed(42);
let mut items = vec![1, 2, 3, 4, 5];
let original = items.clone();
rng.shuffle(&mut items);
let mut sorted_items = items.clone();
sorted_items.sort();
assert_eq!(sorted_items, original);
}
#[test]
fn test_shuffle_deterministic() {
let mut rng1 = StableRng::from_seed(42);
let mut items1 = vec![1, 2, 3, 4, 5];
rng1.shuffle(&mut items1);
let mut rng2 = StableRng::from_seed(42);
let mut items2 = vec![1, 2, 3, 4, 5];
rng2.shuffle(&mut items2);
assert_eq!(items1, items2);
}
#[test]
fn test_sample() {
let mut rng = StableRng::from_seed(42);
let items = vec![1, 2, 3, 4, 5];
let sampled = rng.sample(&items, 3);
assert_eq!(sampled.len(), 3);
for item in &sampled {
assert!(items.contains(item));
}
let mut sorted_sampled = sampled.clone();
sorted_sampled.sort();
sorted_sampled.dedup();
assert_eq!(sorted_sampled.len(), sampled.len());
}
#[test]
fn test_sample_oversized() {
let mut rng = StableRng::from_seed(42);
let items = vec![1, 2, 3];
let sampled = rng.sample(&items, 10);
assert_eq!(sampled.len(), 3);
let mut sorted_sampled = sampled.clone();
sorted_sampled.sort();
assert_eq!(sorted_sampled, items);
}
#[test]
fn test_choose_weighted() {
let mut rng = StableRng::from_seed(42);
let items = vec!["common", "rare", "epic"];
let weights = vec![70.0, 25.0, 5.0];
let mut counts = [0, 0, 0];
let iterations = 10000;
for _ in 0..iterations {
if let Some(&item) = rng.choose_weighted(&items, &weights) {
let index = items.iter().position(|&x| x == item).unwrap();
counts[index] += 1;
}
}
let ratios: Vec<f64> = counts
.iter()
.map(|&c| c as f64 / iterations as f64)
.collect();
assert!((ratios[0] - 0.70).abs() < 0.10);
assert!((ratios[1] - 0.25).abs() < 0.10);
assert!((ratios[2] - 0.05).abs() < 0.10);
}
#[test]
fn test_choose_weighted_empty() {
let mut rng = StableRng::from_seed(42);
let items: Vec<i32> = vec![];
let weights: Vec<f64> = vec![];
assert!(rng.choose_weighted(&items, &weights).is_none());
}
#[test]
fn test_choose_weighted_zero_weights() {
let mut rng = StableRng::from_seed(42);
let items = vec![1, 2, 3];
let weights = vec![0.0, 0.0, 0.0];
assert!(rng.choose_weighted(&items, &weights).is_none());
}
#[test]
fn test_seed_retrieval() {
let rng = StableRng::from_seed(12345);
assert_eq!(rng.seed(), 12345);
let derived = rng.derive("test");
assert_ne!(derived.seed(), 12345);
}
#[test]
fn test_from_seed_bytes() {
let seed_bytes = [42u8; 32];
let rng = StableRng::from_seed_bytes(seed_bytes);
let expected_seed = fnv1a_64(&seed_bytes);
assert_eq!(
rng.seed(),
expected_seed,
"seed 字段应等于 fnv1a_64(seed_bytes)"
);
let rng_from_seed = StableRng::from_seed(expected_seed);
assert_eq!(
rng.seed(),
rng_from_seed.seed(),
"from_seed_bytes 应等价于 from_seed(fnv1a_64(bytes))"
);
let mut rng1 = StableRng::from_seed_bytes(seed_bytes);
let mut rng2 = StableRng::from_seed_bytes(seed_bytes);
for _ in 0..100 {
assert_eq!(rng1.random::<u32>(), rng2.random::<u32>());
}
}
#[test]
fn test_fnv1a_stability() {
assert_eq!(
fnv1a_64(b"topology"),
0x516188458c0dece4,
"fnv1a_64(\"topology\") 漂移"
);
assert_eq!(
fnv1a_64(b"layout"),
0x9c4f784aa5ce135f,
"fnv1a_64(\"layout\") 漂移"
);
assert_eq!(
fnv1a_64(b"terrain"),
0x3f8b069c872d66ae,
"fnv1a_64(\"terrain\") 漂移"
);
assert_eq!(
fnv1a_64(b"spawn"),
0x4328f78ab20e1f98,
"fnv1a_64(\"spawn\") 漂移"
);
}
#[test]
fn test_seed_from_u64_stability() {
let mut rng = StableRng::from_seed(42);
let val: u32 = rng.random_range(0, 100);
assert_eq!(val, 63, "from_seed(42).random_range(0, 100) 漂移");
}
#[test]
fn test_derive_stability() {
let root = StableRng::from_seed(42);
let topo = root.derive("topology");
assert_eq!(
topo.seed(),
0x4f75c6aa467c06de,
"derive(\"topology\").seed() 漂移"
);
let layout = root.derive("layout");
assert_eq!(
layout.seed(),
0xc2c2a6698173ab15,
"derive(\"layout\").seed() 漂移"
);
}
#[test]
fn test_fnv1a_64_chain_equivalence() {
let a = 42u64.to_le_bytes();
let b = b"topology";
let mut concat = Vec::new();
concat.extend_from_slice(&a);
concat.extend_from_slice(b);
assert_eq!(
fnv1a_64_chain(&a, b),
fnv1a_64(&concat),
"chain 与 concat 不一致"
);
assert_eq!(fnv1a_64_chain(&[], b), fnv1a_64(b));
assert_eq!(fnv1a_64_chain(&a, &[]), fnv1a_64(&a));
assert_eq!(fnv1a_64_chain(&[], &[]), fnv1a_64(&[]));
}
}