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

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

use crate::util::rng::RandomSource;
use crate::world::worldgen::feature::features::blockpos_iter::between_closed;
use crate::world::worldgen::region::WorldGenRegion;
use shulkr::util as shapes;
use shulkr::util::BlockPosition;
use shulkr::util::Direction;

#[derive(Debug, Deserialize)]
pub struct UnderwaterMagmaConfig {
    pub floor_search_range: i32,
    pub placement_radius_around_floor: i32,
    pub placement_probability_per_valid_position: f32,
}

fn is_water(region: &WorldGenRegion<'_>, pos: BlockPosition) -> bool {
    region.get_block(pos).is(Block::WATER)
}

fn get_floor_y(
    region: &WorldGenRegion<'_>,
    origin: BlockPosition,
    search_range: i32,
) -> Option<i32> {
    if !is_water(region, origin) {
        return None;
    }

    let mut pos = origin;
    let mut i = 1;
    while i < search_range && is_water(region, pos) {
        pos = pos.below();
        i += 1;
    }

    if is_water(region, pos) {
        None
    } else {
        Some(pos.y())
    }
}

fn is_water_or_air(region: &WorldGenRegion<'_>, pos: BlockPosition) -> bool {
    let state = region.get_block(pos);
    state.is(Block::WATER) || state.is_air()
}

fn is_visible_from_outside(
    region: &WorldGenRegion<'_>,
    pos: BlockPosition,
    covered_direction: Direction,
) -> bool {
    !shapes::is_face_full(
        *region.get_block(pos).get_occlusion_shape(),
        covered_direction,
    )
}

fn is_valid_placement(region: &WorldGenRegion<'_>, pos: BlockPosition) -> bool {
    if is_water_or_air(region, pos) || is_visible_from_outside(region, pos.below(), Direction::Up) {
        return false;
    }

    for direction in Direction::HORIZONTAL {
        if is_visible_from_outside(region, pos.relative(direction), direction.opposite()) {
            return false;
        }
    }

    true
}

pub fn place(
    region: &WorldGenRegion<'_>,
    random: &mut RandomSource,
    origin: BlockPosition,
    config: &UnderwaterMagmaConfig,
) -> bool {
    let Some(floor_y) = get_floor_y(region, origin, config.floor_search_range) else {
        return false;
    };

    let floor_pos = origin.at_y(floor_y);
    let r = config.placement_radius_around_floor;
    let magma = Block::MAGMA_BLOCK.default_state();
    let mut placed = 0;

    for pos in between_closed(floor_pos.offset(-r, -r, -r), floor_pos.offset(r, r, r)) {
        if random.next_f32() < config.placement_probability_per_valid_position
            && is_valid_placement(region, pos)
        {
            region.set_block(pos, magma);
            placed += 1;
        }
    }

    placed > 0
}