alex/beta-minecraft-rust

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

//! Ports of `WorldGenMinable` and `WorldGenClay`: blobs along a random segment.

use std::f32::consts::PI;

use common::JavaRandom;
use common::math::{self, floor_f64};
use common::world::{Block, Material};

use crate::level::Level;

/// `WorldGenMinable`: replaces stone.
pub fn vein(level: &mut Level, pos: [i32; 3], rand: &mut JavaRandom, ore: Block, size: i32) {
    blob(level, pos, rand, size, [Block::STONE, ore]);
}

/// `WorldGenClay`: replaces sand, starting only in water.
pub fn clay(level: &mut Level, [x, y, z]: [i32; 3], rand: &mut JavaRandom, size: i32) {
    if level.material(x, y, z) == Material::Water {
        blob(level, [x, y, z], rand, size, [Block::SAND, Block::CLAY]);
    }
}

/// `size + 1` spheres of varying radii along a segment centered around (x + 8, z + 8),
/// replacing `from` with `to`.
fn blob(
    level: &mut Level,
    [x, y, z]: [i32; 3],
    rand: &mut JavaRandom,
    size: i32,
    [from, to]: [Block; 2],
) {
    let angle = rand.next_float() * PI;
    let reach = |offset: f32| offset * size as f32 / 8.0;
    let (sin, cos) = (reach(math::sin(angle)), reach(math::cos(angle)));
    let (x, z) = ((x + 8) as f32, (z + 8) as f32);
    let start = [
        f64::from(x + sin),
        f64::from(y + rand.next_int(3) + 2),
        f64::from(z + cos),
    ];
    let end = [
        f64::from(x - sin),
        f64::from(y + rand.next_int(3) + 2),
        f64::from(z - cos),
    ];
    for step in 0..=size {
        let t = |axis: usize| {
            start[axis] + (end[axis] - start[axis]) * f64::from(step) / f64::from(size)
        };
        let (cx, cy, cz) = (t(0), t(1), t(2));
        let scale = rand.next_double() * f64::from(size) / 16.0;
        let bulge = math::sin(step as f32 * PI / size as f32) + 1.0;
        let radius = (f64::from(bulge) * scale + 1.0) / 2.0;
        for bx in floor_f64(cx - radius)..=floor_f64(cx + radius) {
            let dx = (f64::from(bx) + 0.5 - cx) / radius;
            if dx * dx >= 1.0 {
                continue;
            }
            for by in floor_f64(cy - radius)..=floor_f64(cy + radius) {
                let dy = (f64::from(by) + 0.5 - cy) / radius;
                if dx * dx + dy * dy >= 1.0 {
                    continue;
                }
                for bz in floor_f64(cz - radius)..=floor_f64(cz + radius) {
                    let dz = (f64::from(bz) + 0.5 - cz) / radius;
                    if dx * dx + dy * dy + dz * dz < 1.0 && level.block(bx, by, bz) == from {
                        level.set_block(bx, by, bz, to);
                    }
                }
            }
        }
    }
}