thedes_gen/
lib.rs

1use random::{PickedReproducibleRng, Seed, create_reproducible_rng};
2use thedes_async_util::progress;
3use thedes_domain::game::Game;
4use thiserror::Error;
5
6pub mod random;
7pub mod matter;
8pub mod map;
9pub mod game;
10
11#[derive(Debug, Error)]
12pub enum InitError {
13    #[error("Failed to initialize game generator")]
14    Game(
15        #[source]
16        #[from]
17        game::InitError,
18    ),
19}
20
21#[derive(Debug, Error)]
22pub enum Error {
23    #[error("Failed to generate game")]
24    Game(
25        #[source]
26        #[from]
27        game::Error,
28    ),
29}
30
31#[derive(Debug)]
32pub struct Config {
33    game: game::Config,
34    seed: Seed,
35}
36
37impl Default for Config {
38    fn default() -> Self {
39        Self::new()
40    }
41}
42
43impl Config {
44    pub fn new() -> Self {
45        Self { game: game::Config::new(), seed: 1 }
46    }
47
48    pub fn with_game(self, config: game::Config) -> Self {
49        Self { game: config, ..self }
50    }
51
52    pub fn with_seed(self, seed: Seed) -> Self {
53        Self { seed, ..self }
54    }
55
56    pub fn finish(self) -> Result<Generator, InitError> {
57        let mut rng = create_reproducible_rng(self.seed);
58        let game_gen = self.game.finish(&mut rng)?;
59        let goal = game_gen.progress_goal();
60        let (progress_logger, progress_monitor) = progress::open(goal);
61        Ok(Generator { game_gen, rng, progress_monitor, progress_logger })
62    }
63}
64
65#[derive(Debug)]
66pub struct Generator {
67    game_gen: game::Generator,
68    rng: PickedReproducibleRng,
69    progress_monitor: progress::Monitor,
70    progress_logger: progress::Logger,
71}
72
73impl Generator {
74    pub fn progress_monitor(&self) -> progress::Monitor {
75        self.progress_monitor.clone()
76    }
77
78    pub async fn execute(mut self) -> Result<Game, Error> {
79        let game =
80            self.game_gen.execute(&mut self.rng, self.progress_logger).await?;
81        Ok(game)
82    }
83}