source2_demo/
display.rs

1use crate::entity::field::*;
2use crate::entity::*;
3use crate::event::*;
4use crate::parser::Context;
5use crate::string_table::*;
6use prettytable::{row, Table};
7use std::fmt::{Display, Formatter};
8
9impl Display for Classes {
10    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
11        let mut table = Table::new();
12        table.add_row(row!["id", "name"]);
13        for class in self.classes_vec.iter() {
14            table.add_row(row![class.id().to_string(), class.name]);
15        }
16        write!(f, "{}", table)
17    }
18}
19
20impl Display for FieldPath {
21    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
22        for i in 0..=self.last {
23            write!(f, "{}", self.path[i])?;
24            if i != self.last {
25                write!(f, "/")?;
26            }
27        }
28        Ok(())
29    }
30}
31
32impl Display for StringTables {
33    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
34        let mut table = Table::new();
35        table.add_row(row!["id", "name", "rows"]);
36        for string_table in self.iter() {
37            table.add_row(row![
38                string_table.index.to_string(),
39                string_table.name,
40                string_table.items.len()
41            ]);
42        }
43        write!(f, "{}", table)
44    }
45}
46
47impl Display for StringTable {
48    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
49        let mut table = Table::new();
50        table.add_row(row!["idx", "key", "value"]);
51        for entry in self.items.iter() {
52            table.add_row(row![
53                entry.index,
54                entry.key,
55                format!(
56                    "{:?}...",
57                    entry
58                        .value
59                        .as_ref()
60                        .map(|x| if x.len() > 10 { &x[..10] } else { &x[..] })
61                )
62            ]);
63        }
64        write!(f, "{}", table)
65    }
66}
67
68impl Display for Context {
69    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
70        let mut table = Table::new();
71        table.add_row(row!["Classes", self.classes.classes_vec.len()]);
72        table.add_row(row![
73            "Entities",
74            self.entities
75                .entities_vec
76                .iter()
77                .filter(|e| e.index != u32::MAX)
78                .collect::<Vec<_>>()
79                .len()
80        ]);
81        table.add_row(row!["String Tables", self.string_tables.tables.len()]);
82        table.add_row(row!["Tick", self.tick]);
83        table.add_row(row!["Net Tick", self.net_tick]);
84        table.add_row(row!["Game Build", format!("{:?}", self.game_build)]);
85        write!(f, "{}", table)
86    }
87}
88
89impl Display for Entities {
90    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
91        let mut table = Table::new();
92        table.add_row(row!["idx", "serial", "handle", "class"]);
93        for e in self.entities_vec.iter() {
94            if e.index() == u32::MAX {
95                continue;
96            }
97            table.add_row(row![
98                e.index().to_string(),
99                e.serial().to_string(),
100                e.handle().to_string(),
101                e.class().name(),
102            ]);
103        }
104        write!(f, "{}", table)
105    }
106}
107
108impl Display for Entity {
109    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
110        let mut table = Table::new();
111
112        table.add_row(row!["#", "Field", "Type", "Value"]);
113
114        for fp in self
115            .class
116            .serializer
117            .get_field_paths(&mut FieldPath::default(), &self.state)
118        {
119            let field_type = self.class.serializer.get_type_for_field_path(&fp);
120            let name = self.class.serializer.get_name_for_field_path(&fp);
121            let value = self.state.get_value(&fp);
122            if let Some(v) = value {
123                table.add_row(row![fp, name, field_type.to_string(), format!("{:?}", v)]);
124            } else {
125                table.add_row(row![fp, name, field_type.to_string(), "None"]);
126            }
127        }
128
129        write!(f, "{}", table)
130    }
131}
132
133impl Display for FieldValue {
134    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
135        match self {
136            FieldValue::Boolean(val) => write!(f, "{}", val),
137            FieldValue::String(val) => write!(f, "\"{}\"", val),
138            FieldValue::Float(val) => write!(f, "{}", val),
139            FieldValue::Vector2D(val) => write!(f, "[{}, {}]", val[0], val[1]),
140            FieldValue::Vector3D(val) => write!(f, "[{}, {}, {}]", val[0], val[1], val[2]),
141            FieldValue::Vector4D(val) => {
142                write!(f, "[{}, {}, {}, {}]", val[0], val[1], val[2], val[3])
143            }
144            FieldValue::Signed8(val) => write!(f, "{}", val),
145            FieldValue::Signed16(val) => write!(f, "{}", val),
146            FieldValue::Signed32(val) => write!(f, "{}", val),
147            FieldValue::Signed64(val) => write!(f, "{}", val),
148            FieldValue::Unsigned8(val) => write!(f, "{}", val),
149            FieldValue::Unsigned16(val) => write!(f, "{}", val),
150            FieldValue::Unsigned32(val) => write!(f, "{}", val),
151            FieldValue::Unsigned64(val) => write!(f, "{}", val),
152        }
153    }
154}
155
156impl Display for GameEvent<'_> {
157    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
158        let mut table = Table::new();
159
160        table.add_row(row!["Key", "Value"]);
161
162        for (key, value) in self.iter() {
163            table.add_row(row![key, format!("{:?}", value)]);
164        }
165
166        write!(f, "{}", table)
167    }
168}
169
170impl Display for GameEventList {
171    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
172        let mut table = Table::new();
173
174        for (id, definition) in self
175            .list
176            .iter()
177            .collect::<std::collections::BTreeMap<_, _>>()
178        {
179            table.add_row(row![id, definition.name]);
180        }
181
182        write!(f, "{}", table)
183    }
184}
185
186impl Display for FieldType {
187    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
188        let mut x = self.base.to_string();
189        if let Some(generic) = &self.generic {
190            x = x + "< " + &generic.to_string() + " >";
191        }
192        if self.pointer {
193            x += "*";
194        }
195        if self.count > 0 {
196            x = x + "[" + &self.count.to_string() + "]";
197        }
198        write!(f, "{}", x)
199    }
200}
201
202impl Display for FieldDecoder {
203    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
204        let output = match &self {
205            FieldDecoder::Boolean => "bool",
206            FieldDecoder::String => "String",
207            FieldDecoder::Signed8 => "i32",
208            FieldDecoder::Signed16 => "i16",
209            FieldDecoder::Signed32 => "i32",
210            FieldDecoder::Unsigned8 => "u8",
211            FieldDecoder::Unsigned16 => "u16",
212            FieldDecoder::Unsigned32 => "u32",
213            FieldDecoder::Vector(decoder) => &format!("[f32; {}]", decoder.dimensions()),
214            FieldDecoder::Unsigned64(_) => "u64",
215            FieldDecoder::Float32(_) => "f32",
216            FieldDecoder::QuantizedFloat(_) => "f32",
217            FieldDecoder::QAngle(_) => "[f32; 3]",
218            FieldDecoder::CCSGameModeRules => "bool",
219        };
220        write!(f, "{output}")
221    }
222}
source2_demo/display.rs

source2_demo/
display.rs
