yog-cli 0.49.1

Yog build tool — `yog build` compiles a mod and packages it as .yog.
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

//! The `.ydef` dimension designer's preview: its `terrain` generated by
//! yog-worldgen — the code the runtime generates the game's chunks with —
//! and drawn from above and in a slice.

use yog_worldgen::{Generator, Terrain, preview};

#[derive(yog_data::Schema)]
pub struct Preview {
    /// `size`×`size` blocks from above, `data:image/png;base64,…`.
    top: String,
    /// A slice down along x through the middle, `size` wide.
    slice: String,
    /// The slice's height, top and bottom.
    slice_top: i32,
    slice_bottom: i32,
}

fn png(pixels: &[u32], w: u32, h: u32) -> Result<String, String> {
    let rgba: Vec<u8> = pixels
        .iter()
        .flat_map(|&p| [(p >> 16) as u8, (p >> 8) as u8, p as u8, (p >> 24) as u8])
        .collect();
    let mut out = Vec::new();
    let mut enc = png::Encoder::new(&mut out, w, h);
    enc.set_color(png::ColorType::Rgba);
    enc.set_depth(png::BitDepth::Eight);
    enc.set_compression(png::Compression::Fast);
    let mut writer = enc.write_header().map_err(|e| e.to_string())?;
    writer.write_image_data(&rgba).map_err(|e| e.to_string())?;
    writer.finish().map_err(|e| e.to_string())?;
    Ok(super::raster::png_url(&out))
}

/// The terrain of `text` (a `.ydef` of kind `dimension`) around 0, 0: `size` blocks across.
pub fn render(text: &str, size: u32) -> Result<Preview, String> {
    let size = size.clamp(16, 1024);
    let def = yog_data::text::parse_value(text)
        .map_err(|e| format!("{}:{}: {}", e.at.line, e.at.col, e.message))?;
    let terrain = def
        .get(yog_ids::dimension_field::TERRAIN)
        .ok_or("no `terrain` — this dimension's chunks come from a generator in code")?;
    let terrain = yog_data::read_value::<Terrain>(terrain).map_err(|ps| {
        ps.iter()
            .map(|p| format!("terrain.{}: {}", p.path, p.message))
            .collect::<Vec<_>>()
            .join("\n")
    })?;
    let int = |k: &str| {
        def.get(yog_ids::dimension_field::DIMENSION_TYPE)
            .and_then(|t| t.get(k))
            .and_then(|v| v.as_i64())
            .map(|v| v as i32)
    };
    let min_y = int("min_y").unwrap_or(-64);
    let height = int("height").unwrap_or(384);
    let g = Generator::new(terrain);
    let half = size as i32 / 2;
    let top = preview::top_down(
        &g,
        preview::Area {
            x: -half,
            z: -half,
            w: size,
            h: size,
        },
        min_y,
    );
    // The slice: from a little over the highest ground (or the fluid) down, 160 blocks at most.
    let highest = (-half..half).map(|x| g.surface(x, 0)).max().unwrap_or(0);
    let fluid = g.terrain.fluid.as_ref().map_or(i32::MIN, |f| f.level);
    let slice_top = (highest.max(fluid) + 4).min(min_y + height - 1);
    let slice_bottom = (slice_top - 160).max(min_y);
    let rows = (slice_top - slice_bottom + 1) as u32;
    let slice = preview::slice(
        &g,
        preview::Area {
            x: -half,
            z: 0,
            w: size,
            h: rows,
        },
        slice_top,
        min_y,
    );
    Ok(Preview {
        top: png(&top, size, size)?,
        slice: png(&slice, size, (slice_top - slice_bottom + 1) as u32)?,
        slice_top,
        slice_bottom,
    })
}

#[cfg(test)]
mod tests {
    #[test]
    fn previews_a_dimensions_terrain() {
        let text = r#"{ kind: "dimension", id: "hills", dimension_type: { min_y: 0, height: 256 },
            terrain: { seed: 1, base_height: 64, noise: [{ scale: 50, amplitude: 12 }], fill: "@block:minecraft:stone",
                fluid: { block: "@block:minecraft:water", level: 62 } } }"#;
        let p = super::render(text, 32).unwrap();
        assert!(
            p.top.starts_with(super::super::raster::PNG_URL_PREFIX)
                && p.slice.starts_with(super::super::raster::PNG_URL_PREFIX)
        );
        assert_eq!(p.slice_bottom, 0);
        assert!(p.slice_top >= 66);
        let e = super::render(r#"{ kind: "dimension", id: "x" }"#, 32)
            .err()
            .unwrap();
        assert!(e.contains("no `terrain`"), "{e}");
    }
}