bl4-ncs 0.8.2

NCS (Nexus Config Store) parser for Borderlands 4
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
113
114
115
116
117
118
119
120
121
122
123

//! FixedWidthIntArray24 - remap array with 24-bit count
//!
//! Used to remap indices in the NCS binary section. Each table has two
//! remap arrays: one for key strings (pair_vec) and one for value strings.

use crate::bit_reader::{bit_width, BitRead};

/// Fixed-width integer array with 24-bit count + 8-bit width header
#[derive(Debug, Clone, Default)]
pub struct FixedWidthIntArray {
    pub count: u32,
    pub value_bit_width: u8,
    pub index_bit_width: u8,
    pub values: Vec<u32>,
}

impl FixedWidthIntArray {
    pub fn is_active(&self) -> bool {
        self.count > 0 && self.value_bit_width > 0 && self.values.len() == self.count as usize
    }

    /// Read from bit stream: 24-bit count, 8-bit width, then count values
    pub fn read(reader: &mut impl BitRead) -> Option<Self> {
        let count = reader.read_bits(24)?;
        let value_bit_width = reader.read_bits(8)? as u8;
        let index_bit_width = if count > 0 { bit_width(count) } else { 0 };

        if count == 0 || value_bit_width == 0 {
            return Some(Self {
                count,
                value_bit_width,
                index_bit_width,
                values: Vec::new(),
            });
        }

        if value_bit_width > 32 {
            let bits_to_skip = count as usize * value_bit_width as usize;
            reader.skip_bits(bits_to_skip);
            return Some(Self {
                count,
                value_bit_width,
                index_bit_width,
                values: Vec::new(),
            });
        }

        if count > 1_000_000 {
            return None;
        }

        let mut values = Vec::with_capacity(count as usize);
        for _ in 0..count {
            values.push(reader.read_bits(value_bit_width)?);
        }

        Some(Self {
            count,
            value_bit_width,
            index_bit_width,
            values,
        })
    }

    /// Map raw index through remap array to get remapped value
    pub fn remap(&self, raw_index: u32) -> Option<u32> {
        if raw_index < self.count {
            Some(self.values[raw_index as usize])
        } else {
            None
        }
    }
}

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

    #[test]
    fn test_fixed_width_array_read() {
        // count=3 (24-bit), width=8 (8-bit), values=[10, 20, 30]
        let data = [
            0x03, 0x00, 0x00, // count = 3
            0x08, // width = 8
            0x0A, 0x14, 0x1E, // values = [10, 20, 30]
        ];
        let mut reader = BitReader::new(&data);
        let arr = FixedWidthIntArray::read(&mut reader).unwrap();

        assert_eq!(arr.count, 3);
        assert_eq!(arr.value_bit_width, 8);
        assert_eq!(arr.values, vec![10, 20, 30]);
        assert!(arr.is_active());
        assert_eq!(arr.index_bit_width, 2); // bit_width(3) = 2
    }

    #[test]
    fn test_remap() {
        let arr = FixedWidthIntArray {
            count: 3,
            value_bit_width: 8,
            index_bit_width: 2,
            values: vec![10, 20, 30],
        };

        assert_eq!(arr.remap(0), Some(10));
        assert_eq!(arr.remap(1), Some(20));
        assert_eq!(arr.remap(2), Some(30));
        assert_eq!(arr.remap(3), None);
    }

    #[test]
    fn test_empty_array() {
        // count=0
        let data = [0x00, 0x00, 0x00, 0x00];
        let mut reader = BitReader::new(&data);
        let arr = FixedWidthIntArray::read(&mut reader).unwrap();

        assert_eq!(arr.count, 0);
        assert!(!arr.is_active());
    }
}