neurodoom 0.6.7

Deterministic no_std Doom engine with semantic and depth perception buffers for AI
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

use neurodoom::map::MapData;
use neurodoom::wad::Wad;

fn load_wad() -> Vec<u8> {
    let path = std::env::var("DOOM_WAD")
        .unwrap_or_else(|_| "doom1.wad".to_string());
    std::fs::read(&path).unwrap_or_else(|e| panic!("failed to read WAD at {path}: {e}"))
}

#[test]
fn load_e1m1() {
    let data = load_wad();
    let wad = Wad::parse(&data).unwrap();
    let map = MapData::load(&wad, "E1M1").unwrap();

    assert_eq!(map.vertexes.len(), 467);
    assert!(map.lines.len() > 400, "expected >400 linedefs, got {}", map.lines.len());
    assert!(map.sectors.len() > 80, "expected >80 sectors, got {}", map.sectors.len());
    assert!(map.segs.len() > 0);
    assert!(map.subsectors.len() > 0);
    assert!(map.nodes.len() > 0);
    assert!(map.things.len() > 0);
}

#[test]
fn bsp_root_valid() {
    let data = load_wad();
    let wad = Wad::parse(&data).unwrap();
    let map = MapData::load(&wad, "E1M1").unwrap();

    let root = map.root_node();
    assert_eq!(root as usize, map.nodes.len() - 1);
}

#[test]
fn blockmap_dimensions() {
    let data = load_wad();
    let wad = Wad::parse(&data).unwrap();
    let map = MapData::load(&wad, "E1M1").unwrap();

    assert!(map.blockmap.width > 0);
    assert!(map.blockmap.height > 0);
    assert_eq!(map.blockmap.offsets.len(), map.blockmap.width * map.blockmap.height);
}

#[test]
fn player_start_exists() {
    let data = load_wad();
    let wad = Wad::parse(&data).unwrap();
    let map = MapData::load(&wad, "E1M1").unwrap();

    // Thing type 1 = Player 1 start
    let p1_start = map.things.iter().find(|t| t.type_num == 1);
    assert!(p1_start.is_some(), "player 1 start not found in E1M1");
}

#[test]
fn lines_have_valid_sides() {
    let data = load_wad();
    let wad = Wad::parse(&data).unwrap();
    let map = MapData::load(&wad, "E1M1").unwrap();

    for (i, line) in map.lines.iter().enumerate() {
        // Every line must have at least a front side
        assert!(
            line.sidenum[0].is_some(),
            "line {i} has no front side"
        );
        // Vertex indices must be valid
        assert!(
            (line.v1 as usize) < map.vertexes.len(),
            "line {i} v1 out of bounds"
        );
        assert!(
            (line.v2 as usize) < map.vertexes.len(),
            "line {i} v2 out of bounds"
        );
    }
}