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

use crate::world::chunk::heightmap::HeightmapType;
use crate::world::worldgen::region::WorldGenRegion;
use crate::world::worldgen::structure::structure_piece::PieceBase;
use shulkr::util::BlockPosition;
use shulkr::util::BoundingBox;
use shulkr::util::Direction;

#[derive(Debug)]
pub struct ScatteredFeature {
    pub width: i32,
    pub height: i32,
    pub depth: i32,
    pub height_position: i32,
}

impl ScatteredFeature {
    pub const fn new(width: i32, height: i32, depth: i32) -> Self {
        Self {
            width,
            height,
            depth,
            height_position: -1,
        }
    }

    pub const fn make_base(
        west: i32,
        floor: i32,
        north: i32,
        width: i32,
        height: i32,
        depth: i32,
        direction: Direction,
    ) -> PieceBase {
        let mut base = PieceBase::new(
            0,
            PieceBase::make_bounding_box(west, floor, north, direction, width, height, depth),
        );
        base.set_orientation(Some(direction));
        base
    }

    pub fn update_average_ground_height(
        &mut self,
        base: &mut PieceBase,
        region: &WorldGenRegion<'_>,
        chunk_bb: BoundingBox,
        offset: i32,
    ) -> bool {
        if self.height_position >= 0 {
            return true;
        }

        let mut total = 0;
        let mut count = 0;
        let box_ = base.bounding_box;
        for z in box_.min_z()..=box_.max_z() {
            for x in box_.min_x()..=box_.max_x() {
                if chunk_bb.is_inside(BlockPosition::new(x, 64, z)) {
                    total += region.get_height(HeightmapType::MotionBlockingNoLeaves, x, z);
                    count += 1;
                }
            }
        }

        if count == 0 {
            return false;
        }

        self.height_position = total / count;
        base.move_by(0, self.height_position - box_.min_y() + offset, 0);
        true
    }

    pub fn update_height_position_to_lowest_ground_height(
        &mut self,
        base: &mut PieceBase,
        region: &WorldGenRegion<'_>,
        offset: i32,
    ) -> bool {
        if self.height_position >= 0 {
            return true;
        }

        let mut lowest_ground_height = region.max_y() + 1;
        let mut found = false;
        let box_ = base.bounding_box;
        for z in box_.min_z()..=box_.max_z() {
            for x in box_.min_x()..=box_.max_x() {
                lowest_ground_height = lowest_ground_height.min(region.get_height(
                    HeightmapType::MotionBlockingNoLeaves,
                    x,
                    z,
                ));
                found = true;
            }
        }

        if !found {
            return false;
        }

        self.height_position = lowest_ground_height;
        base.move_by(0, self.height_position - box_.min_y() + offset, 0);
        true
    }
}