babalcore 0.5.1

Babal core logic library, low-level things which are game-engine agnostic.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use rand::prelude::*;
use std::collections::HashMap;

use super::row::*;
use super::skill::*;
use super::slab_def::*;

#[derive(PartialEq, PartialOrd)]
struct DefDensity {
    def: SlabDef,
    density: f64,
}

impl std::cmp::Eq for DefDensity {}

impl std::cmp::Ord for DefDensity {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.def.cmp(&other.def)
    }
}

fn build_rng_seed(seed: u64, row_index: usize) -> [u8; 32] {
    let mut buf: [u8; 32] = [0; 32];
    let buf1 = bincode::serialize(&seed).unwrap();
    let mut i: usize = 0;
    for v in buf1.into_iter() {
        buf[i] = v;
        i += 1;
    }
    let buf2 = bincode::serialize(&row_index).unwrap();
    for v in buf2.into_iter() {
        buf[i] = v;
        i += 1;
    }
    buf
}

pub fn generate_first_row(seed: u64, width: usize, skill: Skill) -> Row {
    let rng_seed = build_rng_seed(seed, 0);
    let rng: StdRng = SeedableRng::from_seed(rng_seed);
    let def_density = skill.def_density0();
    row_from_def_density(rng, width, &def_density)
}

pub fn generate_next_row(seed: u64, j: usize, previous_row: &Row, skill: Skill) -> Row {
    let rng_seed = build_rng_seed(seed, j);
    let rng: StdRng = SeedableRng::from_seed(rng_seed);
    let def_density = skill.def_density();
    row_from_previous(rng, previous_row, &def_density, skill.mutability())
}

fn row_from_def_density(
    mut rng: impl Rng,
    width: usize,
    def_density: &HashMap<SlabDef, f64>,
) -> Row {
    let mut row = Row::default();
    let mut v: Vec<DefDensity> = Vec::new();
    for (def, density) in def_density {
        v.push(DefDensity {
            def: *def,
            density: *density,
        });
    }
    v.sort();
    for i in 0..width {
        let f: f64 = rng.gen();
        let mut limit: f64 = 0.0;
        for dd in &v {
            if f >= limit && f < limit + dd.density {
                row.set(i as isize, dd.def);
                break;
            }
            limit += dd.density;
        }
    }
    row
}

fn row_from_previous(
    mut rng: impl Rng,
    previous_row: &Row,
    def_density: &HashMap<SlabDef, f64>,
    mutability: f64,
) -> Row {
    let mut row = Row::default();
    let mut v: Vec<DefDensity> = Vec::new();
    for (def, density) in def_density {
        v.push(DefDensity {
            def: *def,
            density: *density,
        });
    }
    v.sort();
    for i in 0..(previous_row.slabs.len() as isize) {
        let f: f64 = rng.gen();
        let mut limit: f64 = 0.0;
        for dd in &v {
            if f >= limit && f < limit + dd.density {
                row.set(i, dd.def);
                break;
            }
            limit += dd.density;
        }
        let change: f64 = rng.gen();
        let previous_def = previous_row.get(i);
        if change >= mutability && !previous_def.is_special() && !row.get(i).is_special() {
            row.set(i as isize, previous_def);
        }
    }
    row
}