wow_dbc/vanilla_tables/
item_sub_class_mask.rs

1use crate::{
2    DbcTable, LocalizedString,
3};
4use crate::header::{
5    DbcHeader, HEADER_SIZE, parse_header,
6};
7use std::io::Write;
8
9#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10pub struct ItemSubClassMask {
11    pub rows: Vec<ItemSubClassMaskRow>,
12}
13
14impl DbcTable for ItemSubClassMask {
15    type Row = ItemSubClassMaskRow;
16
17    const FILENAME: &'static str = "ItemSubClassMask.dbc";
18
19    fn rows(&self) -> &[Self::Row] { &self.rows }
20    fn rows_mut(&mut self) -> &mut [Self::Row] { &mut self.rows }
21
22    fn read(b: &mut impl std::io::Read) -> Result<Self, crate::DbcError> {
23        let mut header = [0_u8; HEADER_SIZE];
24        b.read_exact(&mut header)?;
25        let header = parse_header(&header)?;
26
27        if header.record_size != 44 {
28            return Err(crate::DbcError::InvalidHeader(
29                crate::InvalidHeaderError::RecordSize {
30                    expected: 44,
31                    actual: header.record_size,
32                },
33            ));
34        }
35
36        if header.field_count != 11 {
37            return Err(crate::DbcError::InvalidHeader(
38                crate::InvalidHeaderError::FieldCount {
39                    expected: 11,
40                    actual: header.field_count,
41                },
42            ));
43        }
44
45        let mut r = vec![0_u8; (header.record_count * header.record_size) as usize];
46        b.read_exact(&mut r)?;
47        let mut string_block = vec![0_u8; header.string_block_size as usize];
48        b.read_exact(&mut string_block)?;
49
50        let mut rows = Vec::with_capacity(header.record_count as usize);
51
52        for mut chunk in r.chunks(header.record_size as usize) {
53            let chunk = &mut chunk;
54
55            // subclass: uint32
56            let subclass = crate::util::read_u32_le(chunk)?;
57
58            // mask: int32
59            let mask = crate::util::read_i32_le(chunk)?;
60
61            // name: string_ref_loc
62            let name = crate::util::read_localized_string(chunk, &string_block)?;
63
64
65            rows.push(ItemSubClassMaskRow {
66                subclass,
67                mask,
68                name,
69            });
70        }
71
72        Ok(ItemSubClassMask { rows, })
73    }
74
75    fn write(&self, b: &mut impl Write) -> Result<(), std::io::Error> {
76        let header = DbcHeader {
77            record_count: self.rows.len() as u32,
78            field_count: 11,
79            record_size: 44,
80            string_block_size: self.string_block_size(),
81        };
82
83        b.write_all(&header.write_header())?;
84
85        let mut string_index = 1;
86        for row in &self.rows {
87            // subclass: uint32
88            b.write_all(&row.subclass.to_le_bytes())?;
89
90            // mask: int32
91            b.write_all(&row.mask.to_le_bytes())?;
92
93            // name: string_ref_loc
94            b.write_all(&row.name.string_indices_as_array(&mut string_index))?;
95
96        }
97
98        self.write_string_block(b)?;
99
100        Ok(())
101    }
102
103}
104
105impl ItemSubClassMask {
106    fn write_string_block(&self, b: &mut impl Write) -> Result<(), std::io::Error> {
107        b.write_all(&[0])?;
108
109        for row in &self.rows {
110            row.name.string_block_as_array(b)?;
111        }
112
113        Ok(())
114    }
115
116    fn string_block_size(&self) -> u32 {
117        let mut sum = 1;
118        for row in &self.rows {
119            sum += row.name.string_block_size();
120        }
121
122        sum as u32
123    }
124
125}
126
127#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
128pub struct ItemSubClassMaskRow {
129    pub subclass: u32,
130    pub mask: i32,
131    pub name: LocalizedString,
132}
133
wow_dbc/vanilla_tables/item_sub_class_mask.rs

wow_dbc/vanilla_tables/
item_sub_class_mask.rs
