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
80
81
82
83
84
85
86
87
88
89
90
91
92

use neurodoom::texture::TextureData;
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_textures() {
    let data = load_wad();
    let wad = Wad::parse(&data).unwrap();
    let texdata = TextureData::load(&wad).unwrap();

    // Should have palettes
    assert_eq!(texdata.palettes.len(), 14);

    // Should have colormaps (32 + invulnerability + unused = 34)
    assert!(texdata.colormaps.len() >= 32);

    // Should have flats
    assert!(texdata.flats.len() > 0, "no flats loaded");
    assert!(texdata.num_flats > 0);

    // Should have wall textures
    assert!(texdata.textures.len() > 0, "no textures loaded");
}

#[test]
fn palette_valid() {
    let data = load_wad();
    let wad = Wad::parse(&data).unwrap();
    let texdata = TextureData::load(&wad).unwrap();

    // Palette 0 should have non-zero entries (not all black)
    let pal = &texdata.palettes[0];
    let nonzero = pal.iter().filter(|&&b| b != 0).count();
    assert!(nonzero > 100, "palette seems mostly black: {nonzero} nonzero bytes");
}

#[test]
fn colormap_brightness() {
    let data = load_wad();
    let wad = Wad::parse(&data).unwrap();
    let texdata = TextureData::load(&wad).unwrap();

    // Colormap 0 (brightest) should be close to identity
    let cmap0 = &texdata.colormaps[0];
    let identity_count = (0..256u16).filter(|&i| cmap0[i as usize] == i as u8).count();
    assert!(identity_count > 200, "colormap 0 should be near-identity, got {identity_count}/256");
}

#[test]
fn texture_has_columns() {
    let data = load_wad();
    let wad = Wad::parse(&data).unwrap();
    let texdata = TextureData::load(&wad).unwrap();

    // First texture should have valid width/height and columns
    let tex = &texdata.textures[0];
    assert!(tex.width > 0);
    assert!(tex.height > 0);
    assert_eq!(tex.data.len(), tex.width as usize * tex.height as usize);
    for c in 0..tex.width as usize {
        assert_eq!(tex.column(c).len(), tex.height as usize);
    }
}

#[test]
fn flat_name_lookup() {
    let data = load_wad();
    let wad = Wad::parse(&data).unwrap();
    let texdata = TextureData::load(&wad).unwrap();

    // FLOOR0_1 should exist in doom1.wad
    let name = *b"FLOOR0_1";
    let idx = texdata.flat_num_for_name(&name);
    assert!(idx >= 0, "FLOOR0_1 flat not found");
}

#[test]
fn texture_name_lookup() {
    let data = load_wad();
    let wad = Wad::parse(&data).unwrap();
    let texdata = TextureData::load(&wad).unwrap();

    // STARTAN3 should exist (common wall texture)
    let name = *b"STARTAN3";
    let idx = texdata.texture_num_for_name(&name);
    assert!(idx > 0, "STARTAN3 texture not found");
}