concinnity-world 0.18.65

Authored world source, args schema, validation, and spec builders for Concinnity
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

// Structural validation for VoxelWorld args. Cross-asset palette/material
// lookups are handled by build/pipeline.rs::validate_cross_references; this
// check only catches problems visible from the world's own args.

pub(crate) fn check(name: &str, args: &serde_json::Value) -> Result<(), String> {
    // palette: at least air + one solid block so the generator has geometry.
    let palette = args
        .get("palette")
        .and_then(|v| v.as_array())
        .ok_or_else(|| {
            format!(
                "Asset '{}': VoxelWorld `palette` must be an array of BlockType names",
                name
            )
        })?;
    if palette.len() < 2 {
        return Err(format!(
            "Asset '{}': VoxelWorld `palette` needs at least 2 entries (air + a surface block), got {}",
            name,
            palette.len()
        ));
    }

    // chunk_blocks is optional (defaults apply), but if present must be a
    // 3-element array of positive integers.
    if let Some(cb) = args.get("chunk_blocks") {
        let arr = cb.as_array().ok_or_else(|| {
            format!(
                "Asset '{}': VoxelWorld `chunk_blocks` must be a [dx, dy, dz] array",
                name
            )
        })?;
        if arr.len() != 3 {
            return Err(format!(
                "Asset '{}': VoxelWorld `chunk_blocks` must have 3 elements, got {}",
                name,
                arr.len()
            ));
        }
        for (i, e) in arr.iter().enumerate() {
            let v = e.as_u64().ok_or_else(|| {
                format!(
                    "Asset '{}': VoxelWorld chunk_blocks[{}] must be a non-negative integer",
                    name, i
                )
            })?;
            if v == 0 {
                return Err(format!(
                    "Asset '{}': VoxelWorld chunk_blocks[{}] must be greater than 0",
                    name, i
                ));
            }
        }
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn valid_args_pass() {
        let args = serde_json::json!({
            "palette": ["air", "grass", "stone"],
            "chunk_blocks": [16, 24, 16]
        });
        assert!(check("w", &args).is_ok());
    }

    #[test]
    fn missing_palette_fails() {
        assert!(check("w", &serde_json::json!({})).is_err());
    }

    #[test]
    fn single_entry_palette_fails() {
        let args = serde_json::json!({ "palette": ["air"] });
        assert!(check("w", &args).is_err());
    }

    #[test]
    fn zero_chunk_dimension_fails() {
        let args = serde_json::json!({
            "palette": ["air", "stone"],
            "chunk_blocks": [16, 0, 16]
        });
        assert!(check("w", &args).is_err());
    }

    #[test]
    fn wrong_chunk_blocks_length_fails() {
        let args = serde_json::json!({
            "palette": ["air", "stone"],
            "chunk_blocks": [16, 16]
        });
        assert!(check("w", &args).is_err());
    }
}