chunkgen 0.2.0

Minecraft world generation library
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

#![feature(portable_simd, const_cmp, const_trait_impl)]

pub mod datapack;
pub mod error;
pub mod preset;
pub mod registry;
pub mod util;
pub mod world;

pub use error::Error;
pub use preset::{
    AmplifiedPreset, DatapackPreset, DebugPreset, DefaultPreset, LargeBiomesPreset,
    SingleBiomePreset, SuperflatPreset, SuperflatPresetBuilder, WorldPreset,
};
use shulkr::util::Key;
pub use util::pos::ChunkPos;
pub use world::chunk::status::ChunkStatus;
pub use world::chunk::view::ChunkView;
pub use world::worldgen::{Result, Worldgen, WorldgenSettings};

use crate::datapack::Datapack;

pub struct WorldgenBuilder {
    seed: i64,
    dimension: Key,
    datapack: Datapack,
    preset: WorldPreset,
}

impl WorldgenBuilder {
    pub fn new() -> Self {
        Self {
            seed: 0,
            dimension: Key::vanilla("overworld"),
            datapack: Datapack::builtin(),
            preset: WorldPreset::default(),
        }
    }

    #[must_use]
    pub const fn with_seed(mut self, seed: i64) -> Self {
        self.seed = seed;
        self
    }

    #[must_use]
    pub fn with_dimension(mut self, dimension: Key) -> Self {
        self.dimension = dimension;
        self
    }

    #[must_use]
    pub fn with_datapack(mut self, datapack: Datapack) -> Self {
        self.datapack = datapack;
        self
    }

    #[must_use]
    pub fn with_preset(mut self, preset: impl Into<WorldPreset>) -> Self {
        self.preset = preset.into();
        self
    }

    pub fn build(self) -> Result<Worldgen> {
        Worldgen::new(WorldgenSettings {
            seed: self.seed,
            dimension: self.dimension,
            datapack: self.datapack,
            preset: self.preset,
        })
    }
}

impl Default for WorldgenBuilder {
    fn default() -> Self {
        Self::new()
    }
}