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
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use serde::Deserialize;
use shulkr::util::Key;
use shulkr::world::block::Block;

use crate::util::rng::RandomSource;
use crate::util::shuffle;
use crate::world::worldgen::block_predicate::HolderSet;
use crate::world::worldgen::feature::multiface::{self, Spreader};
use crate::world::worldgen::region::WorldGenRegion;
use shulkr::util::BlockPosition;
use shulkr::util::Direction;
use shulkr::world::block::BlockState;

#[derive(Debug, Deserialize)]
pub struct MultifaceGrowthConfig {
    pub block: Key,
    #[serde(default = "default_search_range")]
    pub search_range: i32,
    #[serde(default)]
    pub can_place_on_floor: bool,
    #[serde(default)]
    pub can_place_on_ceiling: bool,
    #[serde(default)]
    pub can_place_on_wall: bool,
    #[serde(default = "default_chance_of_spreading")]
    pub chance_of_spreading: f32,
    pub can_be_placed_on: HolderSet,
}

const fn default_search_range() -> i32 {
    10
}

const fn default_chance_of_spreading() -> f32 {
    0.5
}

fn is_air_or_water(state: BlockState) -> bool {
    state.is_air() || state.is(Block::WATER)
}

fn valid_directions(config: &MultifaceGrowthConfig) -> Vec<Direction> {
    let mut dirs = Vec::with_capacity(6);
    if config.can_place_on_ceiling {
        dirs.push(Direction::Up);
    }
    if config.can_place_on_floor {
        dirs.push(Direction::Down);
    }
    if config.can_place_on_wall {
        dirs.extend(Direction::HORIZONTAL);
    }
    dirs
}

fn shuffled_directions(
    config: &MultifaceGrowthConfig,
    random: &mut RandomSource,
) -> Vec<Direction> {
    let mut dirs = valid_directions(config);
    shuffle(&mut dirs, random);
    dirs
}

fn shuffled_directions_except(
    config: &MultifaceGrowthConfig,
    random: &mut RandomSource,
    except: Direction,
) -> Vec<Direction> {
    let mut dirs = valid_directions(config);
    dirs.retain(|&d| d != except);
    shuffle(&mut dirs, random);
    dirs
}

pub fn place(
    region: &WorldGenRegion<'_>,
    random: &mut RandomSource,
    origin: BlockPosition,
    config: &MultifaceGrowthConfig,
) -> bool {
    if !is_air_or_water(region.get_block(origin)) {
        return false;
    }
    let Some(placer_block) = Block::from_key(config.block.clone()).copied() else {
        return false;
    };

    let search_dirs = shuffled_directions(config, random);
    if place_growth_if_possible(
        region,
        random,
        placer_block,
        origin,
        region.get_block(origin),
        config,
        &search_dirs,
    ) {
        return true;
    }

    for &search_dir in &search_dirs {
        let placement_dirs = shuffled_directions_except(config, random, search_dir.opposite());
        let pos = origin.relative(search_dir);
        for _ in 0..config.search_range {
            let state = region.get_block(pos);
            if !is_air_or_water(state) && !state.is(placer_block) {
                break;
            }
            if place_growth_if_possible(
                region,
                random,
                placer_block,
                pos,
                state,
                config,
                &placement_dirs,
            ) {
                return true;
            }
        }
    }

    false
}

fn place_growth_if_possible(
    region: &WorldGenRegion<'_>,
    random: &mut RandomSource,
    placer_block: Block,
    pos: BlockPosition,
    old_state: BlockState,
    config: &MultifaceGrowthConfig,
    placement_dirs: &[Direction],
) -> bool {
    for &dir in placement_dirs {
        let neighbor = region.get_block(pos.relative(dir));
        if config.can_be_placed_on.contains_block(neighbor) {
            let Some(new_state) =
                multiface::state_for_placement(region, placer_block, old_state, pos, dir)
            else {
                return false;
            };
            region.set_block(pos, new_state);
            region.mark_pos_for_postprocessing(pos);
            if random.next_f32() < config.chance_of_spreading {
                Spreader::Default(placer_block).spread_from_face_toward_random_direction(
                    new_state, region, pos, dir, random, true,
                );
            }
            return true;
        }
    }
    false
}