wow_dbc/wrath_tables/
item_class.rs

1use crate::{
2    DbcTable, ExtendedLocalizedString,
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 ItemClass {
11    pub rows: Vec<ItemClassRow>,
12}
13
14impl DbcTable for ItemClass {
15    type Row = ItemClassRow;
16
17    const FILENAME: &'static str = "ItemClass.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 != 80 {
28            return Err(crate::DbcError::InvalidHeader(
29                crate::InvalidHeaderError::RecordSize {
30                    expected: 80,
31                    actual: header.record_size,
32                },
33            ));
34        }
35
36        if header.field_count != 20 {
37            return Err(crate::DbcError::InvalidHeader(
38                crate::InvalidHeaderError::FieldCount {
39                    expected: 20,
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            // class_id: int32
56            let class_id = crate::util::read_i32_le(chunk)?;
57
58            // subclass_map_id: int32
59            let subclass_map_id = crate::util::read_i32_le(chunk)?;
60
61            // flags: int32
62            let flags = crate::util::read_i32_le(chunk)?;
63
64            // class_name_lang: string_ref_loc (Extended)
65            let class_name_lang = crate::util::read_extended_localized_string(chunk, &string_block)?;
66
67
68            rows.push(ItemClassRow {
69                class_id,
70                subclass_map_id,
71                flags,
72                class_name_lang,
73            });
74        }
75
76        Ok(ItemClass { rows, })
77    }
78
79    fn write(&self, b: &mut impl Write) -> Result<(), std::io::Error> {
80        let header = DbcHeader {
81            record_count: self.rows.len() as u32,
82            field_count: 20,
83            record_size: 80,
84            string_block_size: self.string_block_size(),
85        };
86
87        b.write_all(&header.write_header())?;
88
89        let mut string_index = 1;
90        for row in &self.rows {
91            // class_id: int32
92            b.write_all(&row.class_id.to_le_bytes())?;
93
94            // subclass_map_id: int32
95            b.write_all(&row.subclass_map_id.to_le_bytes())?;
96
97            // flags: int32
98            b.write_all(&row.flags.to_le_bytes())?;
99
100            // class_name_lang: string_ref_loc (Extended)
101            b.write_all(&row.class_name_lang.string_indices_as_array(&mut string_index))?;
102
103        }
104
105        self.write_string_block(b)?;
106
107        Ok(())
108    }
109
110}
111
112impl ItemClass {
113    fn write_string_block(&self, b: &mut impl Write) -> Result<(), std::io::Error> {
114        b.write_all(&[0])?;
115
116        for row in &self.rows {
117            row.class_name_lang.string_block_as_array(b)?;
118        }
119
120        Ok(())
121    }
122
123    fn string_block_size(&self) -> u32 {
124        let mut sum = 1;
125        for row in &self.rows {
126            sum += row.class_name_lang.string_block_size();
127        }
128
129        sum as u32
130    }
131
132}
133
134#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
135pub struct ItemClassRow {
136    pub class_id: i32,
137    pub subclass_map_id: i32,
138    pub flags: i32,
139    pub class_name_lang: ExtendedLocalizedString,
140}
141