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