wow_dbc/wrath_tables/
item_class.rs1use 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 let class_id = crate::util::read_i32_le(chunk)?;
57
58 let subclass_map_id = crate::util::read_i32_le(chunk)?;
60
61 let flags = crate::util::read_i32_le(chunk)?;
63
64 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 b.write_all(&row.class_id.to_le_bytes())?;
93
94 b.write_all(&row.subclass_map_id.to_le_bytes())?;
96
97 b.write_all(&row.flags.to_le_bytes())?;
99
100 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