Skip to main content

oscyl_core/
generate.rs

1//! Driver-independent parts of generation: dealing a hand of distinct
2//! programs from any driver's generate, vary or breed.
3
4use oscyl_driver::{Driver, DriverError};
5
6/// SplitMix64, the same stream drivers seed from.
7struct Rng(u64);
8
9impl Rng {
10    fn next_u64(&mut self) -> u64 {
11        self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
12        let mut z = self.0;
13        z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
14        z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
15        z ^ (z >> 31)
16    }
17}
18
19/// A dealt program, and the seed that makes it again when one does.
20pub type Dealt = (Vec<u8>, Option<u64>);
21
22/// Deal `n` programs that differ in at least one field and carry
23/// different names. `make` is called with a fresh seed derived from
24/// `seed` until each program differs from those before it; a maker that
25/// keeps repeating itself is nudged apart with [`Driver::vary`]. Names
26/// come from [`Driver::generated_name`] for `character`. Deterministic.
27pub fn hand(
28    d: &dyn Driver,
29    character: usize,
30    seed: u64,
31    n: usize,
32    make: impl FnMut(u64) -> Result<Vec<u8>, DriverError>,
33) -> Result<Vec<Vec<u8>>, DriverError> {
34    let dealt = deal(d, character, seed, (u64::MAX, None, false), n, make)?;
35    Ok(dealt.into_iter().map(|(p, _)| p).collect())
36}
37
38/// [`hand`], telling for each program the seed `make` made it from, so a
39/// caller can make it again. For that, a program whose own name
40/// ([`Driver::generated_name`] of its seed) is taken is made from another
41/// seed, not renamed; `None` for the rare one that had to be renamed or
42/// nudged apart all the same. Seeds are cut to `mask` (short seeds make
43/// short recipe codes); the first program is made from `first` when given.
44pub fn hand_seeded(
45    d: &dyn Driver,
46    character: usize,
47    seed: u64,
48    mask: u64,
49    first: Option<u64>,
50    n: usize,
51    make: impl FnMut(u64) -> Result<Vec<u8>, DriverError>,
52) -> Result<Vec<Dealt>, DriverError> {
53    deal(d, character, seed, (mask, first, true), n, make)
54}
55
56/// Both hands: `(mask, first, own_names)`, the last for [`hand_seeded`]'s
57/// rule on names.
58fn deal(
59    d: &dyn Driver,
60    character: usize,
61    seed: u64,
62    (mask, first, own_names): (u64, Option<u64>, bool),
63    n: usize,
64    mut make: impl FnMut(u64) -> Result<Vec<u8>, DriverError>,
65) -> Result<Vec<Dealt>, DriverError> {
66    let fields = d.fields().len();
67    let differs = |out: &[Dealt], p: &[u8]| {
68        out.iter()
69            .all(|(q, _)| (0..fields).any(|i| d.get(q, i) != d.get(p, i)))
70    };
71    let mut r = Rng(seed);
72    let mut out: Vec<Dealt> = Vec::with_capacity(n);
73    while out.len() < n {
74        let mut s = r.next_u64() & mask;
75        if let (true, Some(first)) = (out.is_empty(), first) {
76            s = first;
77        }
78        let mut p = make(s)?;
79        let mut tries = 0;
80        let taken =
81            |out: &[Dealt], name: &str| out.iter().any(|(q, _)| d.name(q).is_ok_and(|m| m == name));
82        let own = |s: u64| d.generated_name(character, s);
83        while !differs(&out, &p) || (own_names && tries < 8 && taken(&out, &own(s))) {
84            s = r.next_u64() & mask;
85            p = if tries < 8 {
86                make(s)?
87            } else {
88                d.vary(&p, 0.2, s)?
89            };
90            tries += 1;
91        }
92        let name = (0..64)
93            .map(|k| own(s.wrapping_add(k)))
94            .find(|name| !taken(&out, name))
95            .unwrap_or_else(|| {
96                let title = d.characters().get(character).map_or("Sound", |c| c.title);
97                format!("{title} {}", out.len() + 1)
98            });
99        d.set_name(&mut p, &name)?;
100        out.push((p, (tries <= 8 && name == own(s)).then_some(s)));
101    }
102    Ok(out)
103}