1use super::gamevent::{
2 EventValue, GameEventDefinition, GameEventEntry, GameEventValue, RawGameEvent,
3};
4use crate::demo::data::MaybeUtf8String;
5use crate::demo::Stream;
6use crate::{ParseError, Result};
7use bitbuffer::{BitRead, BitWrite, BitWriteStream, LittleEndian};
8use serde::{Deserialize, Serialize};
9use std::mem::size_of;
10fn read_value<'a, T: EventValue + BitRead<'a, LittleEndian> + Default>(
11 stream: &mut Stream<'a>,
12 entry: Option<&GameEventEntry>,
13 name: &'static str,
14) -> Result<T> {
15 let entry = match entry {
16 Some(entry) => entry,
17 None => {
18 return Ok(T::default());
19 }
20 };
21 if T::value_type() != entry.kind {
22 return Err(ParseError::InvalidGameEvent {
23 expected_type: T::value_type(),
24 name,
25 found_type: entry.kind,
26 });
27 }
28 Ok(T::read(stream)?)
29}
30#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
31#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
32pub struct ServerSpawnEvent {
33 pub hostname: MaybeUtf8String,
34 pub address: MaybeUtf8String,
35 pub ip: u32,
36 pub port: u16,
37 pub game: MaybeUtf8String,
38 pub map_name: MaybeUtf8String,
39 pub max_players: u32,
40 pub os: MaybeUtf8String,
41 pub dedicated: bool,
42 pub password: bool,
43}
44impl ServerSpawnEvent {
45 #[allow(unused_variables)]
46 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
47 Ok(ServerSpawnEvent {
48 hostname: read_value::<MaybeUtf8String>(
49 stream,
50 definition.get_entry(7992289610851289516u64),
51 "hostname",
52 )?,
53 address: read_value::<MaybeUtf8String>(
54 stream,
55 definition.get_entry(1673076945917317811u64),
56 "address",
57 )?,
58 ip: read_value::<u32>(stream, definition.get_entry(628043273916406972u64), "ip")?,
59 port: read_value::<u16>(
60 stream,
61 definition.get_entry(10100688915994460070u64),
62 "port",
63 )?,
64 game: read_value::<MaybeUtf8String>(
65 stream,
66 definition.get_entry(10005491431272162599u64),
67 "game",
68 )?,
69 map_name: read_value::<MaybeUtf8String>(
70 stream,
71 definition.get_entry(18037678950216614794u64),
72 "map_name",
73 )?,
74 max_players: read_value::<u32>(
75 stream,
76 definition.get_entry(6820574247554962453u64),
77 "max_players",
78 )?,
79 os: read_value::<MaybeUtf8String>(
80 stream,
81 definition.get_entry(626093839799967319u64),
82 "os",
83 )?,
84 dedicated: read_value::<bool>(
85 stream,
86 definition.get_entry(17181338330120084322u64),
87 "dedicated",
88 )?,
89 password: read_value::<bool>(
90 stream,
91 definition.get_entry(5411718394350379800u64),
92 "password",
93 )?,
94 })
95 }
96 #[allow(unused_variables)]
97 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
98 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
99 match field.hash {
100 7992289610851289516u64 => Ok(self.hostname.clone().into()),
101 1673076945917317811u64 => Ok(self.address.clone().into()),
102 628043273916406972u64 => Ok(self.ip.clone().into()),
103 10100688915994460070u64 => Ok(self.port.clone().into()),
104 10005491431272162599u64 => Ok(self.game.clone().into()),
105 18037678950216614794u64 => Ok(self.map_name.clone().into()),
106 6820574247554962453u64 => Ok(self.max_players.clone().into()),
107 626093839799967319u64 => Ok(self.os.clone().into()),
108 17181338330120084322u64 => Ok(self.dedicated.clone().into()),
109 5411718394350379800u64 => Ok(self.password.clone().into()),
110 _ => Err(ParseError::MissingGameEventValue {
111 ty: "ServerSpawn",
112 field: "todo".into(),
113 }),
114 }
115 }
116 #[allow(unused_variables)]
117 fn write(
118 &self,
119 stream: &mut BitWriteStream<LittleEndian>,
120 definition: &GameEventDefinition,
121 ) -> Result<()> {
122 for entry in &definition.entries {
123 let value = self
124 .get_field(entry)
125 .unwrap_or_else(|_| entry.kind.default_value());
126 stream.write(&value)?;
127 }
128 Ok(())
129 }
130}
131#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
132#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
133pub struct ServerChangeLevelFailedEvent {
134 pub level_name: MaybeUtf8String,
135}
136impl ServerChangeLevelFailedEvent {
137 #[allow(unused_variables)]
138 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
139 Ok(ServerChangeLevelFailedEvent {
140 level_name: read_value::<MaybeUtf8String>(
141 stream,
142 definition.get_entry(8103714013497669086u64),
143 "level_name",
144 )?,
145 })
146 }
147 #[allow(unused_variables)]
148 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
149 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
150 match field.hash {
151 8103714013497669086u64 => Ok(self.level_name.clone().into()),
152 _ => Err(ParseError::MissingGameEventValue {
153 ty: "ServerChangeLevelFailed",
154 field: "todo".into(),
155 }),
156 }
157 }
158 #[allow(unused_variables)]
159 fn write(
160 &self,
161 stream: &mut BitWriteStream<LittleEndian>,
162 definition: &GameEventDefinition,
163 ) -> Result<()> {
164 for entry in &definition.entries {
165 let value = self
166 .get_field(entry)
167 .unwrap_or_else(|_| entry.kind.default_value());
168 stream.write(&value)?;
169 }
170 Ok(())
171 }
172}
173#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
174#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
175pub struct ServerShutdownEvent {
176 pub reason: MaybeUtf8String,
177}
178impl ServerShutdownEvent {
179 #[allow(unused_variables)]
180 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
181 Ok(ServerShutdownEvent {
182 reason: read_value::<MaybeUtf8String>(
183 stream,
184 definition.get_entry(7343356632300987961u64),
185 "reason",
186 )?,
187 })
188 }
189 #[allow(unused_variables)]
190 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
191 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
192 match field.hash {
193 7343356632300987961u64 => Ok(self.reason.clone().into()),
194 _ => Err(ParseError::MissingGameEventValue {
195 ty: "ServerShutdown",
196 field: "todo".into(),
197 }),
198 }
199 }
200 #[allow(unused_variables)]
201 fn write(
202 &self,
203 stream: &mut BitWriteStream<LittleEndian>,
204 definition: &GameEventDefinition,
205 ) -> Result<()> {
206 for entry in &definition.entries {
207 let value = self
208 .get_field(entry)
209 .unwrap_or_else(|_| entry.kind.default_value());
210 stream.write(&value)?;
211 }
212 Ok(())
213 }
214}
215#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
216#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
217pub struct ServerCvarEvent {
218 pub cvar_name: MaybeUtf8String,
219 pub cvar_value: MaybeUtf8String,
220}
221impl ServerCvarEvent {
222 #[allow(unused_variables)]
223 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
224 Ok(ServerCvarEvent {
225 cvar_name: read_value::<MaybeUtf8String>(
226 stream,
227 definition.get_entry(8822721269188576188u64),
228 "cvar_name",
229 )?,
230 cvar_value: read_value::<MaybeUtf8String>(
231 stream,
232 definition.get_entry(9254320334284503348u64),
233 "cvar_value",
234 )?,
235 })
236 }
237 #[allow(unused_variables)]
238 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
239 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
240 match field.hash {
241 8822721269188576188u64 => Ok(self.cvar_name.clone().into()),
242 9254320334284503348u64 => Ok(self.cvar_value.clone().into()),
243 _ => Err(ParseError::MissingGameEventValue {
244 ty: "ServerCvar",
245 field: "todo".into(),
246 }),
247 }
248 }
249 #[allow(unused_variables)]
250 fn write(
251 &self,
252 stream: &mut BitWriteStream<LittleEndian>,
253 definition: &GameEventDefinition,
254 ) -> Result<()> {
255 for entry in &definition.entries {
256 let value = self
257 .get_field(entry)
258 .unwrap_or_else(|_| entry.kind.default_value());
259 stream.write(&value)?;
260 }
261 Ok(())
262 }
263}
264#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
265#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
266pub struct ServerMessageEvent {
267 pub text: MaybeUtf8String,
268}
269impl ServerMessageEvent {
270 #[allow(unused_variables)]
271 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
272 Ok(ServerMessageEvent {
273 text: read_value::<MaybeUtf8String>(
274 stream,
275 definition.get_entry(18015793717152399486u64),
276 "text",
277 )?,
278 })
279 }
280 #[allow(unused_variables)]
281 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
282 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
283 match field.hash {
284 18015793717152399486u64 => Ok(self.text.clone().into()),
285 _ => Err(ParseError::MissingGameEventValue {
286 ty: "ServerMessage",
287 field: "todo".into(),
288 }),
289 }
290 }
291 #[allow(unused_variables)]
292 fn write(
293 &self,
294 stream: &mut BitWriteStream<LittleEndian>,
295 definition: &GameEventDefinition,
296 ) -> Result<()> {
297 for entry in &definition.entries {
298 let value = self
299 .get_field(entry)
300 .unwrap_or_else(|_| entry.kind.default_value());
301 stream.write(&value)?;
302 }
303 Ok(())
304 }
305}
306#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
307#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
308pub struct ServerAddBanEvent {
309 pub name: MaybeUtf8String,
310 pub user_id: u16,
311 pub network_id: MaybeUtf8String,
312 pub ip: MaybeUtf8String,
313 pub duration: MaybeUtf8String,
314 pub by: MaybeUtf8String,
315 pub kicked: bool,
316}
317impl ServerAddBanEvent {
318 #[allow(unused_variables)]
319 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
320 Ok(ServerAddBanEvent {
321 name: read_value::<MaybeUtf8String>(
322 stream,
323 definition.get_entry(14176396743819860870u64),
324 "name",
325 )?,
326 user_id: read_value::<u16>(
327 stream,
328 definition.get_entry(17826443226371159423u64),
329 "user_id",
330 )?,
331 network_id: read_value::<MaybeUtf8String>(
332 stream,
333 definition.get_entry(2293149186490744864u64),
334 "network_id",
335 )?,
336 ip: read_value::<MaybeUtf8String>(
337 stream,
338 definition.get_entry(628043273916406972u64),
339 "ip",
340 )?,
341 duration: read_value::<MaybeUtf8String>(
342 stream,
343 definition.get_entry(10012068961515151501u64),
344 "duration",
345 )?,
346 by: read_value::<MaybeUtf8String>(
347 stream,
348 definition.get_entry(623268094916032724u64),
349 "by",
350 )?,
351 kicked: read_value::<bool>(
352 stream,
353 definition.get_entry(11906843383782741950u64),
354 "kicked",
355 )?,
356 })
357 }
358 #[allow(unused_variables)]
359 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
360 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
361 match field.hash {
362 14176396743819860870u64 => Ok(self.name.clone().into()),
363 17826443226371159423u64 => Ok(self.user_id.clone().into()),
364 2293149186490744864u64 => Ok(self.network_id.clone().into()),
365 628043273916406972u64 => Ok(self.ip.clone().into()),
366 10012068961515151501u64 => Ok(self.duration.clone().into()),
367 623268094916032724u64 => Ok(self.by.clone().into()),
368 11906843383782741950u64 => Ok(self.kicked.clone().into()),
369 _ => Err(ParseError::MissingGameEventValue {
370 ty: "ServerAddBan",
371 field: "todo".into(),
372 }),
373 }
374 }
375 #[allow(unused_variables)]
376 fn write(
377 &self,
378 stream: &mut BitWriteStream<LittleEndian>,
379 definition: &GameEventDefinition,
380 ) -> Result<()> {
381 for entry in &definition.entries {
382 let value = self
383 .get_field(entry)
384 .unwrap_or_else(|_| entry.kind.default_value());
385 stream.write(&value)?;
386 }
387 Ok(())
388 }
389}
390#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
391#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
392pub struct ServerRemoveBanEvent {
393 pub network_id: MaybeUtf8String,
394 pub ip: MaybeUtf8String,
395 pub by: MaybeUtf8String,
396}
397impl ServerRemoveBanEvent {
398 #[allow(unused_variables)]
399 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
400 Ok(ServerRemoveBanEvent {
401 network_id: read_value::<MaybeUtf8String>(
402 stream,
403 definition.get_entry(2293149186490744864u64),
404 "network_id",
405 )?,
406 ip: read_value::<MaybeUtf8String>(
407 stream,
408 definition.get_entry(628043273916406972u64),
409 "ip",
410 )?,
411 by: read_value::<MaybeUtf8String>(
412 stream,
413 definition.get_entry(623268094916032724u64),
414 "by",
415 )?,
416 })
417 }
418 #[allow(unused_variables)]
419 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
420 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
421 match field.hash {
422 2293149186490744864u64 => Ok(self.network_id.clone().into()),
423 628043273916406972u64 => Ok(self.ip.clone().into()),
424 623268094916032724u64 => Ok(self.by.clone().into()),
425 _ => Err(ParseError::MissingGameEventValue {
426 ty: "ServerRemoveBan",
427 field: "todo".into(),
428 }),
429 }
430 }
431 #[allow(unused_variables)]
432 fn write(
433 &self,
434 stream: &mut BitWriteStream<LittleEndian>,
435 definition: &GameEventDefinition,
436 ) -> Result<()> {
437 for entry in &definition.entries {
438 let value = self
439 .get_field(entry)
440 .unwrap_or_else(|_| entry.kind.default_value());
441 stream.write(&value)?;
442 }
443 Ok(())
444 }
445}
446#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
447#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
448pub struct PlayerConnectEvent {
449 pub name: MaybeUtf8String,
450 pub index: u8,
451 pub user_id: u16,
452 pub network_id: MaybeUtf8String,
453 pub address: MaybeUtf8String,
454 pub bot: u16,
455}
456impl PlayerConnectEvent {
457 #[allow(unused_variables)]
458 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
459 Ok(PlayerConnectEvent {
460 name: read_value::<MaybeUtf8String>(
461 stream,
462 definition.get_entry(14176396743819860870u64),
463 "name",
464 )?,
465 index: read_value::<u8>(
466 stream,
467 definition.get_entry(9497966886403524235u64),
468 "index",
469 )?,
470 user_id: read_value::<u16>(
471 stream,
472 definition.get_entry(17826443226371159423u64),
473 "user_id",
474 )?,
475 network_id: read_value::<MaybeUtf8String>(
476 stream,
477 definition.get_entry(2293149186490744864u64),
478 "network_id",
479 )?,
480 address: read_value::<MaybeUtf8String>(
481 stream,
482 definition.get_entry(1673076945917317811u64),
483 "address",
484 )?,
485 bot: read_value::<u16>(stream, definition.get_entry(21728656485903294u64), "bot")?,
486 })
487 }
488 #[allow(unused_variables)]
489 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
490 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
491 match field.hash {
492 14176396743819860870u64 => Ok(self.name.clone().into()),
493 9497966886403524235u64 => Ok(self.index.clone().into()),
494 17826443226371159423u64 => Ok(self.user_id.clone().into()),
495 2293149186490744864u64 => Ok(self.network_id.clone().into()),
496 1673076945917317811u64 => Ok(self.address.clone().into()),
497 21728656485903294u64 => Ok(self.bot.clone().into()),
498 _ => Err(ParseError::MissingGameEventValue {
499 ty: "PlayerConnect",
500 field: "todo".into(),
501 }),
502 }
503 }
504 #[allow(unused_variables)]
505 fn write(
506 &self,
507 stream: &mut BitWriteStream<LittleEndian>,
508 definition: &GameEventDefinition,
509 ) -> Result<()> {
510 for entry in &definition.entries {
511 let value = self
512 .get_field(entry)
513 .unwrap_or_else(|_| entry.kind.default_value());
514 stream.write(&value)?;
515 }
516 Ok(())
517 }
518}
519#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
520#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
521pub struct PlayerConnectClientEvent {
522 pub name: MaybeUtf8String,
523 pub index: u8,
524 pub user_id: u16,
525 pub network_id: MaybeUtf8String,
526 pub bot: u16,
527}
528impl PlayerConnectClientEvent {
529 #[allow(unused_variables)]
530 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
531 Ok(PlayerConnectClientEvent {
532 name: read_value::<MaybeUtf8String>(
533 stream,
534 definition.get_entry(14176396743819860870u64),
535 "name",
536 )?,
537 index: read_value::<u8>(
538 stream,
539 definition.get_entry(9497966886403524235u64),
540 "index",
541 )?,
542 user_id: read_value::<u16>(
543 stream,
544 definition.get_entry(17826443226371159423u64),
545 "user_id",
546 )?,
547 network_id: read_value::<MaybeUtf8String>(
548 stream,
549 definition.get_entry(2293149186490744864u64),
550 "network_id",
551 )?,
552 bot: read_value::<u16>(stream, definition.get_entry(21728656485903294u64), "bot")?,
553 })
554 }
555 #[allow(unused_variables)]
556 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
557 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
558 match field.hash {
559 14176396743819860870u64 => Ok(self.name.clone().into()),
560 9497966886403524235u64 => Ok(self.index.clone().into()),
561 17826443226371159423u64 => Ok(self.user_id.clone().into()),
562 2293149186490744864u64 => Ok(self.network_id.clone().into()),
563 21728656485903294u64 => Ok(self.bot.clone().into()),
564 _ => Err(ParseError::MissingGameEventValue {
565 ty: "PlayerConnectClient",
566 field: "todo".into(),
567 }),
568 }
569 }
570 #[allow(unused_variables)]
571 fn write(
572 &self,
573 stream: &mut BitWriteStream<LittleEndian>,
574 definition: &GameEventDefinition,
575 ) -> Result<()> {
576 for entry in &definition.entries {
577 let value = self
578 .get_field(entry)
579 .unwrap_or_else(|_| entry.kind.default_value());
580 stream.write(&value)?;
581 }
582 Ok(())
583 }
584}
585#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
586#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
587pub struct PlayerInfoEvent {
588 pub name: MaybeUtf8String,
589 pub index: u8,
590 pub user_id: u16,
591 pub network_id: MaybeUtf8String,
592 pub bot: bool,
593}
594impl PlayerInfoEvent {
595 #[allow(unused_variables)]
596 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
597 Ok(PlayerInfoEvent {
598 name: read_value::<MaybeUtf8String>(
599 stream,
600 definition.get_entry(14176396743819860870u64),
601 "name",
602 )?,
603 index: read_value::<u8>(
604 stream,
605 definition.get_entry(9497966886403524235u64),
606 "index",
607 )?,
608 user_id: read_value::<u16>(
609 stream,
610 definition.get_entry(17826443226371159423u64),
611 "user_id",
612 )?,
613 network_id: read_value::<MaybeUtf8String>(
614 stream,
615 definition.get_entry(2293149186490744864u64),
616 "network_id",
617 )?,
618 bot: read_value::<bool>(stream, definition.get_entry(21728656485903294u64), "bot")?,
619 })
620 }
621 #[allow(unused_variables)]
622 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
623 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
624 match field.hash {
625 14176396743819860870u64 => Ok(self.name.clone().into()),
626 9497966886403524235u64 => Ok(self.index.clone().into()),
627 17826443226371159423u64 => Ok(self.user_id.clone().into()),
628 2293149186490744864u64 => Ok(self.network_id.clone().into()),
629 21728656485903294u64 => Ok(self.bot.clone().into()),
630 _ => Err(ParseError::MissingGameEventValue {
631 ty: "PlayerInfo",
632 field: "todo".into(),
633 }),
634 }
635 }
636 #[allow(unused_variables)]
637 fn write(
638 &self,
639 stream: &mut BitWriteStream<LittleEndian>,
640 definition: &GameEventDefinition,
641 ) -> Result<()> {
642 for entry in &definition.entries {
643 let value = self
644 .get_field(entry)
645 .unwrap_or_else(|_| entry.kind.default_value());
646 stream.write(&value)?;
647 }
648 Ok(())
649 }
650}
651#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
652#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
653pub struct PlayerDisconnectEvent {
654 pub user_id: u16,
655 pub reason: MaybeUtf8String,
656 pub name: MaybeUtf8String,
657 pub network_id: MaybeUtf8String,
658 pub bot: u16,
659}
660impl PlayerDisconnectEvent {
661 #[allow(unused_variables)]
662 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
663 Ok(PlayerDisconnectEvent {
664 user_id: read_value::<u16>(
665 stream,
666 definition.get_entry(17826443226371159423u64),
667 "user_id",
668 )?,
669 reason: read_value::<MaybeUtf8String>(
670 stream,
671 definition.get_entry(7343356632300987961u64),
672 "reason",
673 )?,
674 name: read_value::<MaybeUtf8String>(
675 stream,
676 definition.get_entry(14176396743819860870u64),
677 "name",
678 )?,
679 network_id: read_value::<MaybeUtf8String>(
680 stream,
681 definition.get_entry(2293149186490744864u64),
682 "network_id",
683 )?,
684 bot: read_value::<u16>(stream, definition.get_entry(21728656485903294u64), "bot")?,
685 })
686 }
687 #[allow(unused_variables)]
688 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
689 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
690 match field.hash {
691 17826443226371159423u64 => Ok(self.user_id.clone().into()),
692 7343356632300987961u64 => Ok(self.reason.clone().into()),
693 14176396743819860870u64 => Ok(self.name.clone().into()),
694 2293149186490744864u64 => Ok(self.network_id.clone().into()),
695 21728656485903294u64 => Ok(self.bot.clone().into()),
696 _ => Err(ParseError::MissingGameEventValue {
697 ty: "PlayerDisconnect",
698 field: "todo".into(),
699 }),
700 }
701 }
702 #[allow(unused_variables)]
703 fn write(
704 &self,
705 stream: &mut BitWriteStream<LittleEndian>,
706 definition: &GameEventDefinition,
707 ) -> Result<()> {
708 for entry in &definition.entries {
709 let value = self
710 .get_field(entry)
711 .unwrap_or_else(|_| entry.kind.default_value());
712 stream.write(&value)?;
713 }
714 Ok(())
715 }
716}
717#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
718#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
719pub struct PlayerActivateEvent {
720 pub user_id: u16,
721}
722impl PlayerActivateEvent {
723 #[allow(unused_variables)]
724 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
725 Ok(PlayerActivateEvent {
726 user_id: read_value::<u16>(
727 stream,
728 definition.get_entry(17826443226371159423u64),
729 "user_id",
730 )?,
731 })
732 }
733 #[allow(unused_variables)]
734 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
735 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
736 match field.hash {
737 17826443226371159423u64 => Ok(self.user_id.clone().into()),
738 _ => Err(ParseError::MissingGameEventValue {
739 ty: "PlayerActivate",
740 field: "todo".into(),
741 }),
742 }
743 }
744 #[allow(unused_variables)]
745 fn write(
746 &self,
747 stream: &mut BitWriteStream<LittleEndian>,
748 definition: &GameEventDefinition,
749 ) -> Result<()> {
750 for entry in &definition.entries {
751 let value = self
752 .get_field(entry)
753 .unwrap_or_else(|_| entry.kind.default_value());
754 stream.write(&value)?;
755 }
756 Ok(())
757 }
758}
759#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
760#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
761pub struct PlayerSayEvent {
762 pub user_id: u16,
763 pub text: MaybeUtf8String,
764}
765impl PlayerSayEvent {
766 #[allow(unused_variables)]
767 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
768 Ok(PlayerSayEvent {
769 user_id: read_value::<u16>(
770 stream,
771 definition.get_entry(17826443226371159423u64),
772 "user_id",
773 )?,
774 text: read_value::<MaybeUtf8String>(
775 stream,
776 definition.get_entry(18015793717152399486u64),
777 "text",
778 )?,
779 })
780 }
781 #[allow(unused_variables)]
782 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
783 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
784 match field.hash {
785 17826443226371159423u64 => Ok(self.user_id.clone().into()),
786 18015793717152399486u64 => Ok(self.text.clone().into()),
787 _ => Err(ParseError::MissingGameEventValue {
788 ty: "PlayerSay",
789 field: "todo".into(),
790 }),
791 }
792 }
793 #[allow(unused_variables)]
794 fn write(
795 &self,
796 stream: &mut BitWriteStream<LittleEndian>,
797 definition: &GameEventDefinition,
798 ) -> Result<()> {
799 for entry in &definition.entries {
800 let value = self
801 .get_field(entry)
802 .unwrap_or_else(|_| entry.kind.default_value());
803 stream.write(&value)?;
804 }
805 Ok(())
806 }
807}
808#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
809#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
810pub struct ClientDisconnectEvent {
811 pub message: MaybeUtf8String,
812}
813impl ClientDisconnectEvent {
814 #[allow(unused_variables)]
815 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
816 Ok(ClientDisconnectEvent {
817 message: read_value::<MaybeUtf8String>(
818 stream,
819 definition.get_entry(6080987277291999908u64),
820 "message",
821 )?,
822 })
823 }
824 #[allow(unused_variables)]
825 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
826 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
827 match field.hash {
828 6080987277291999908u64 => Ok(self.message.clone().into()),
829 _ => Err(ParseError::MissingGameEventValue {
830 ty: "ClientDisconnect",
831 field: "todo".into(),
832 }),
833 }
834 }
835 #[allow(unused_variables)]
836 fn write(
837 &self,
838 stream: &mut BitWriteStream<LittleEndian>,
839 definition: &GameEventDefinition,
840 ) -> Result<()> {
841 for entry in &definition.entries {
842 let value = self
843 .get_field(entry)
844 .unwrap_or_else(|_| entry.kind.default_value());
845 stream.write(&value)?;
846 }
847 Ok(())
848 }
849}
850#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
851#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
852pub struct ClientBeginConnectEvent {
853 pub address: MaybeUtf8String,
854 pub ip: u32,
855 pub port: u16,
856 pub source: MaybeUtf8String,
857}
858impl ClientBeginConnectEvent {
859 #[allow(unused_variables)]
860 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
861 Ok(ClientBeginConnectEvent {
862 address: read_value::<MaybeUtf8String>(
863 stream,
864 definition.get_entry(1673076945917317811u64),
865 "address",
866 )?,
867 ip: read_value::<u32>(stream, definition.get_entry(628043273916406972u64), "ip")?,
868 port: read_value::<u16>(
869 stream,
870 definition.get_entry(10100688915994460070u64),
871 "port",
872 )?,
873 source: read_value::<MaybeUtf8String>(
874 stream,
875 definition.get_entry(8564681157369146808u64),
876 "source",
877 )?,
878 })
879 }
880 #[allow(unused_variables)]
881 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
882 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
883 match field.hash {
884 1673076945917317811u64 => Ok(self.address.clone().into()),
885 628043273916406972u64 => Ok(self.ip.clone().into()),
886 10100688915994460070u64 => Ok(self.port.clone().into()),
887 8564681157369146808u64 => Ok(self.source.clone().into()),
888 _ => Err(ParseError::MissingGameEventValue {
889 ty: "ClientBeginConnect",
890 field: "todo".into(),
891 }),
892 }
893 }
894 #[allow(unused_variables)]
895 fn write(
896 &self,
897 stream: &mut BitWriteStream<LittleEndian>,
898 definition: &GameEventDefinition,
899 ) -> Result<()> {
900 for entry in &definition.entries {
901 let value = self
902 .get_field(entry)
903 .unwrap_or_else(|_| entry.kind.default_value());
904 stream.write(&value)?;
905 }
906 Ok(())
907 }
908}
909#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
910#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
911pub struct ClientConnectedEvent {
912 pub address: MaybeUtf8String,
913 pub ip: u32,
914 pub port: u16,
915}
916impl ClientConnectedEvent {
917 #[allow(unused_variables)]
918 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
919 Ok(ClientConnectedEvent {
920 address: read_value::<MaybeUtf8String>(
921 stream,
922 definition.get_entry(1673076945917317811u64),
923 "address",
924 )?,
925 ip: read_value::<u32>(stream, definition.get_entry(628043273916406972u64), "ip")?,
926 port: read_value::<u16>(
927 stream,
928 definition.get_entry(10100688915994460070u64),
929 "port",
930 )?,
931 })
932 }
933 #[allow(unused_variables)]
934 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
935 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
936 match field.hash {
937 1673076945917317811u64 => Ok(self.address.clone().into()),
938 628043273916406972u64 => Ok(self.ip.clone().into()),
939 10100688915994460070u64 => Ok(self.port.clone().into()),
940 _ => Err(ParseError::MissingGameEventValue {
941 ty: "ClientConnected",
942 field: "todo".into(),
943 }),
944 }
945 }
946 #[allow(unused_variables)]
947 fn write(
948 &self,
949 stream: &mut BitWriteStream<LittleEndian>,
950 definition: &GameEventDefinition,
951 ) -> Result<()> {
952 for entry in &definition.entries {
953 let value = self
954 .get_field(entry)
955 .unwrap_or_else(|_| entry.kind.default_value());
956 stream.write(&value)?;
957 }
958 Ok(())
959 }
960}
961#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
962#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
963pub struct ClientFullConnectEvent {
964 pub address: MaybeUtf8String,
965 pub ip: u32,
966 pub port: u16,
967}
968impl ClientFullConnectEvent {
969 #[allow(unused_variables)]
970 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
971 Ok(ClientFullConnectEvent {
972 address: read_value::<MaybeUtf8String>(
973 stream,
974 definition.get_entry(1673076945917317811u64),
975 "address",
976 )?,
977 ip: read_value::<u32>(stream, definition.get_entry(628043273916406972u64), "ip")?,
978 port: read_value::<u16>(
979 stream,
980 definition.get_entry(10100688915994460070u64),
981 "port",
982 )?,
983 })
984 }
985 #[allow(unused_variables)]
986 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
987 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
988 match field.hash {
989 1673076945917317811u64 => Ok(self.address.clone().into()),
990 628043273916406972u64 => Ok(self.ip.clone().into()),
991 10100688915994460070u64 => Ok(self.port.clone().into()),
992 _ => Err(ParseError::MissingGameEventValue {
993 ty: "ClientFullConnect",
994 field: "todo".into(),
995 }),
996 }
997 }
998 #[allow(unused_variables)]
999 fn write(
1000 &self,
1001 stream: &mut BitWriteStream<LittleEndian>,
1002 definition: &GameEventDefinition,
1003 ) -> Result<()> {
1004 for entry in &definition.entries {
1005 let value = self
1006 .get_field(entry)
1007 .unwrap_or_else(|_| entry.kind.default_value());
1008 stream.write(&value)?;
1009 }
1010 Ok(())
1011 }
1012}
1013#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1014#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1015pub struct HostQuitEvent {}
1016impl HostQuitEvent {
1017 #[allow(unused_variables)]
1018 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1019 Ok(HostQuitEvent {})
1020 }
1021 #[allow(unused_variables)]
1022 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1023 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1024 match field.hash {
1025 _ => Err(ParseError::MissingGameEventValue {
1026 ty: "HostQuit",
1027 field: "todo".into(),
1028 }),
1029 }
1030 }
1031 #[allow(unused_variables)]
1032 fn write(
1033 &self,
1034 stream: &mut BitWriteStream<LittleEndian>,
1035 definition: &GameEventDefinition,
1036 ) -> Result<()> {
1037 for entry in &definition.entries {
1038 let value = self
1039 .get_field(entry)
1040 .unwrap_or_else(|_| entry.kind.default_value());
1041 stream.write(&value)?;
1042 }
1043 Ok(())
1044 }
1045}
1046#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1047#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1048pub struct TeamInfoEvent {
1049 pub team_id: u8,
1050 pub team_name: MaybeUtf8String,
1051}
1052impl TeamInfoEvent {
1053 #[allow(unused_variables)]
1054 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1055 Ok(TeamInfoEvent {
1056 team_id: read_value::<u8>(
1057 stream,
1058 definition.get_entry(16102541790268531873u64),
1059 "team_id",
1060 )?,
1061 team_name: read_value::<MaybeUtf8String>(
1062 stream,
1063 definition.get_entry(2516817673391228199u64),
1064 "team_name",
1065 )?,
1066 })
1067 }
1068 #[allow(unused_variables)]
1069 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1070 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1071 match field.hash {
1072 16102541790268531873u64 => Ok(self.team_id.clone().into()),
1073 2516817673391228199u64 => Ok(self.team_name.clone().into()),
1074 _ => Err(ParseError::MissingGameEventValue {
1075 ty: "TeamInfo",
1076 field: "todo".into(),
1077 }),
1078 }
1079 }
1080 #[allow(unused_variables)]
1081 fn write(
1082 &self,
1083 stream: &mut BitWriteStream<LittleEndian>,
1084 definition: &GameEventDefinition,
1085 ) -> Result<()> {
1086 for entry in &definition.entries {
1087 let value = self
1088 .get_field(entry)
1089 .unwrap_or_else(|_| entry.kind.default_value());
1090 stream.write(&value)?;
1091 }
1092 Ok(())
1093 }
1094}
1095#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1096#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1097pub struct TeamScoreEvent {
1098 pub team_id: u8,
1099 pub score: u16,
1100}
1101impl TeamScoreEvent {
1102 #[allow(unused_variables)]
1103 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1104 Ok(TeamScoreEvent {
1105 team_id: read_value::<u8>(
1106 stream,
1107 definition.get_entry(16102541790268531873u64),
1108 "team_id",
1109 )?,
1110 score: read_value::<u16>(
1111 stream,
1112 definition.get_entry(13911166232573650165u64),
1113 "score",
1114 )?,
1115 })
1116 }
1117 #[allow(unused_variables)]
1118 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1119 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1120 match field.hash {
1121 16102541790268531873u64 => Ok(self.team_id.clone().into()),
1122 13911166232573650165u64 => Ok(self.score.clone().into()),
1123 _ => Err(ParseError::MissingGameEventValue {
1124 ty: "TeamScore",
1125 field: "todo".into(),
1126 }),
1127 }
1128 }
1129 #[allow(unused_variables)]
1130 fn write(
1131 &self,
1132 stream: &mut BitWriteStream<LittleEndian>,
1133 definition: &GameEventDefinition,
1134 ) -> Result<()> {
1135 for entry in &definition.entries {
1136 let value = self
1137 .get_field(entry)
1138 .unwrap_or_else(|_| entry.kind.default_value());
1139 stream.write(&value)?;
1140 }
1141 Ok(())
1142 }
1143}
1144#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1145#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1146pub struct TeamPlayBroadcastAudioEvent {
1147 pub team: u8,
1148 pub sound: MaybeUtf8String,
1149 pub additional_flags: u16,
1150 pub player: u16,
1151}
1152impl TeamPlayBroadcastAudioEvent {
1153 #[allow(unused_variables)]
1154 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1155 Ok(TeamPlayBroadcastAudioEvent {
1156 team: read_value::<u8>(
1157 stream,
1158 definition.get_entry(18024489754618217260u64),
1159 "team",
1160 )?,
1161 sound: read_value::<MaybeUtf8String>(
1162 stream,
1163 definition.get_entry(7337464818993397268u64),
1164 "sound",
1165 )?,
1166 additional_flags: read_value::<u16>(
1167 stream,
1168 definition.get_entry(10653216584182196624u64),
1169 "additional_flags",
1170 )?,
1171 player: read_value::<u16>(
1172 stream,
1173 definition.get_entry(5008278420455340480u64),
1174 "player",
1175 )?,
1176 })
1177 }
1178 #[allow(unused_variables)]
1179 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1180 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1181 match field.hash {
1182 18024489754618217260u64 => Ok(self.team.clone().into()),
1183 7337464818993397268u64 => Ok(self.sound.clone().into()),
1184 10653216584182196624u64 => Ok(self.additional_flags.clone().into()),
1185 5008278420455340480u64 => Ok(self.player.clone().into()),
1186 _ => Err(ParseError::MissingGameEventValue {
1187 ty: "TeamPlayBroadcastAudio",
1188 field: "todo".into(),
1189 }),
1190 }
1191 }
1192 #[allow(unused_variables)]
1193 fn write(
1194 &self,
1195 stream: &mut BitWriteStream<LittleEndian>,
1196 definition: &GameEventDefinition,
1197 ) -> Result<()> {
1198 for entry in &definition.entries {
1199 let value = self
1200 .get_field(entry)
1201 .unwrap_or_else(|_| entry.kind.default_value());
1202 stream.write(&value)?;
1203 }
1204 Ok(())
1205 }
1206}
1207#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1208#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1209pub struct PlayerTeamEvent {
1210 pub user_id: u16,
1211 pub team: u8,
1212 pub old_team: u8,
1213 pub disconnect: bool,
1214 pub auto_team: bool,
1215 pub silent: bool,
1216 pub name: MaybeUtf8String,
1217}
1218impl PlayerTeamEvent {
1219 #[allow(unused_variables)]
1220 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1221 Ok(PlayerTeamEvent {
1222 user_id: read_value::<u16>(
1223 stream,
1224 definition.get_entry(17826443226371159423u64),
1225 "user_id",
1226 )?,
1227 team: read_value::<u8>(
1228 stream,
1229 definition.get_entry(18024489754618217260u64),
1230 "team",
1231 )?,
1232 old_team: read_value::<u8>(
1233 stream,
1234 definition.get_entry(11079076405359550719u64),
1235 "old_team",
1236 )?,
1237 disconnect: read_value::<bool>(
1238 stream,
1239 definition.get_entry(6424045679635350635u64),
1240 "disconnect",
1241 )?,
1242 auto_team: read_value::<bool>(
1243 stream,
1244 definition.get_entry(9165371035831628223u64),
1245 "auto_team",
1246 )?,
1247 silent: read_value::<bool>(
1248 stream,
1249 definition.get_entry(6452236368899434340u64),
1250 "silent",
1251 )?,
1252 name: read_value::<MaybeUtf8String>(
1253 stream,
1254 definition.get_entry(14176396743819860870u64),
1255 "name",
1256 )?,
1257 })
1258 }
1259 #[allow(unused_variables)]
1260 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1261 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1262 match field.hash {
1263 17826443226371159423u64 => Ok(self.user_id.clone().into()),
1264 18024489754618217260u64 => Ok(self.team.clone().into()),
1265 11079076405359550719u64 => Ok(self.old_team.clone().into()),
1266 6424045679635350635u64 => Ok(self.disconnect.clone().into()),
1267 9165371035831628223u64 => Ok(self.auto_team.clone().into()),
1268 6452236368899434340u64 => Ok(self.silent.clone().into()),
1269 14176396743819860870u64 => Ok(self.name.clone().into()),
1270 _ => Err(ParseError::MissingGameEventValue {
1271 ty: "PlayerTeam",
1272 field: "todo".into(),
1273 }),
1274 }
1275 }
1276 #[allow(unused_variables)]
1277 fn write(
1278 &self,
1279 stream: &mut BitWriteStream<LittleEndian>,
1280 definition: &GameEventDefinition,
1281 ) -> Result<()> {
1282 for entry in &definition.entries {
1283 let value = self
1284 .get_field(entry)
1285 .unwrap_or_else(|_| entry.kind.default_value());
1286 stream.write(&value)?;
1287 }
1288 Ok(())
1289 }
1290}
1291#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1292#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1293pub struct PlayerClassEvent {
1294 pub user_id: u16,
1295 pub class: MaybeUtf8String,
1296}
1297impl PlayerClassEvent {
1298 #[allow(unused_variables)]
1299 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1300 Ok(PlayerClassEvent {
1301 user_id: read_value::<u16>(
1302 stream,
1303 definition.get_entry(17826443226371159423u64),
1304 "user_id",
1305 )?,
1306 class: read_value::<MaybeUtf8String>(
1307 stream,
1308 definition.get_entry(15066323702654938015u64),
1309 "class",
1310 )?,
1311 })
1312 }
1313 #[allow(unused_variables)]
1314 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1315 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1316 match field.hash {
1317 17826443226371159423u64 => Ok(self.user_id.clone().into()),
1318 15066323702654938015u64 => Ok(self.class.clone().into()),
1319 _ => Err(ParseError::MissingGameEventValue {
1320 ty: "PlayerClass",
1321 field: "todo".into(),
1322 }),
1323 }
1324 }
1325 #[allow(unused_variables)]
1326 fn write(
1327 &self,
1328 stream: &mut BitWriteStream<LittleEndian>,
1329 definition: &GameEventDefinition,
1330 ) -> Result<()> {
1331 for entry in &definition.entries {
1332 let value = self
1333 .get_field(entry)
1334 .unwrap_or_else(|_| entry.kind.default_value());
1335 stream.write(&value)?;
1336 }
1337 Ok(())
1338 }
1339}
1340#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1341#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1342pub struct PlayerDeathEvent {
1343 pub user_id: u16,
1344 pub victim_ent_index: u32,
1345 pub inflictor_ent_index: u32,
1346 pub attacker: u16,
1347 pub weapon: MaybeUtf8String,
1348 pub weapon_id: u16,
1349 pub damage_bits: u32,
1350 pub custom_kill: u16,
1351 pub assister: u16,
1352 pub weapon_log_class_name: MaybeUtf8String,
1353 pub stun_flags: u16,
1354 pub death_flags: u16,
1355 pub silent_kill: bool,
1356 pub player_penetrate_count: u16,
1357 pub assister_fallback: MaybeUtf8String,
1358 pub kill_streak_total: u16,
1359 pub kill_streak_wep: u16,
1360 pub kill_streak_assist: u16,
1361 pub kill_streak_victim: u16,
1362 pub ducks_streaked: u16,
1363 pub duck_streak_total: u16,
1364 pub duck_streak_assist: u16,
1365 pub duck_streak_victim: u16,
1366 pub rocket_jump: bool,
1367 pub weapon_def_index: u32,
1368 pub crit_type: u16,
1369}
1370impl PlayerDeathEvent {
1371 #[allow(unused_variables)]
1372 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1373 Ok(PlayerDeathEvent {
1374 user_id: read_value::<u16>(
1375 stream,
1376 definition.get_entry(17826443226371159423u64),
1377 "user_id",
1378 )?,
1379 victim_ent_index: read_value::<u32>(
1380 stream,
1381 definition.get_entry(7608903543976233025u64),
1382 "victim_ent_index",
1383 )?,
1384 inflictor_ent_index: read_value::<u32>(
1385 stream,
1386 definition.get_entry(7862267791693534473u64),
1387 "inflictor_ent_index",
1388 )?,
1389 attacker: read_value::<u16>(
1390 stream,
1391 definition.get_entry(7198542740550218478u64),
1392 "attacker",
1393 )?,
1394 weapon: read_value::<MaybeUtf8String>(
1395 stream,
1396 definition.get_entry(11580461223051554305u64),
1397 "weapon",
1398 )?,
1399 weapon_id: read_value::<u16>(
1400 stream,
1401 definition.get_entry(5542695206485500884u64),
1402 "weapon_id",
1403 )?,
1404 damage_bits: read_value::<u32>(
1405 stream,
1406 definition.get_entry(2104626753992558984u64),
1407 "damage_bits",
1408 )?,
1409 custom_kill: read_value::<u16>(
1410 stream,
1411 definition.get_entry(9002408094759571186u64),
1412 "custom_kill",
1413 )?,
1414 assister: read_value::<u16>(
1415 stream,
1416 definition.get_entry(17978308754419261977u64),
1417 "assister",
1418 )?,
1419 weapon_log_class_name: read_value::<MaybeUtf8String>(
1420 stream,
1421 definition.get_entry(8214628514117900939u64),
1422 "weapon_log_class_name",
1423 )?,
1424 stun_flags: read_value::<u16>(
1425 stream,
1426 definition.get_entry(16746745151415897845u64),
1427 "stun_flags",
1428 )?,
1429 death_flags: read_value::<u16>(
1430 stream,
1431 definition.get_entry(210841622282264177u64),
1432 "death_flags",
1433 )?,
1434 silent_kill: read_value::<bool>(
1435 stream,
1436 definition.get_entry(5449831253309542421u64),
1437 "silent_kill",
1438 )?,
1439 player_penetrate_count: read_value::<u16>(
1440 stream,
1441 definition.get_entry(6165847213797285919u64),
1442 "player_penetrate_count",
1443 )?,
1444 assister_fallback: read_value::<MaybeUtf8String>(
1445 stream,
1446 definition.get_entry(2624120833319605424u64),
1447 "assister_fallback",
1448 )?,
1449 kill_streak_total: read_value::<u16>(
1450 stream,
1451 definition.get_entry(10219443329572148957u64),
1452 "kill_streak_total",
1453 )?,
1454 kill_streak_wep: read_value::<u16>(
1455 stream,
1456 definition.get_entry(14151704064294986651u64),
1457 "kill_streak_wep",
1458 )?,
1459 kill_streak_assist: read_value::<u16>(
1460 stream,
1461 definition.get_entry(3408761288007698574u64),
1462 "kill_streak_assist",
1463 )?,
1464 kill_streak_victim: read_value::<u16>(
1465 stream,
1466 definition.get_entry(14613767699666342005u64),
1467 "kill_streak_victim",
1468 )?,
1469 ducks_streaked: read_value::<u16>(
1470 stream,
1471 definition.get_entry(8814124002674372577u64),
1472 "ducks_streaked",
1473 )?,
1474 duck_streak_total: read_value::<u16>(
1475 stream,
1476 definition.get_entry(2758270581670703974u64),
1477 "duck_streak_total",
1478 )?,
1479 duck_streak_assist: read_value::<u16>(
1480 stream,
1481 definition.get_entry(10967369523768500963u64),
1482 "duck_streak_assist",
1483 )?,
1484 duck_streak_victim: read_value::<u16>(
1485 stream,
1486 definition.get_entry(620103205137188524u64),
1487 "duck_streak_victim",
1488 )?,
1489 rocket_jump: read_value::<bool>(
1490 stream,
1491 definition.get_entry(16207427969859362406u64),
1492 "rocket_jump",
1493 )?,
1494 weapon_def_index: read_value::<u32>(
1495 stream,
1496 definition.get_entry(4132306594868589054u64),
1497 "weapon_def_index",
1498 )?,
1499 crit_type: read_value::<u16>(
1500 stream,
1501 definition.get_entry(7263029362109349446u64),
1502 "crit_type",
1503 )?,
1504 })
1505 }
1506 #[allow(unused_variables)]
1507 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1508 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1509 match field.hash {
1510 17826443226371159423u64 => Ok(self.user_id.clone().into()),
1511 7608903543976233025u64 => Ok(self.victim_ent_index.clone().into()),
1512 7862267791693534473u64 => Ok(self.inflictor_ent_index.clone().into()),
1513 7198542740550218478u64 => Ok(self.attacker.clone().into()),
1514 11580461223051554305u64 => Ok(self.weapon.clone().into()),
1515 5542695206485500884u64 => Ok(self.weapon_id.clone().into()),
1516 2104626753992558984u64 => Ok(self.damage_bits.clone().into()),
1517 9002408094759571186u64 => Ok(self.custom_kill.clone().into()),
1518 17978308754419261977u64 => Ok(self.assister.clone().into()),
1519 8214628514117900939u64 => Ok(self.weapon_log_class_name.clone().into()),
1520 16746745151415897845u64 => Ok(self.stun_flags.clone().into()),
1521 210841622282264177u64 => Ok(self.death_flags.clone().into()),
1522 5449831253309542421u64 => Ok(self.silent_kill.clone().into()),
1523 6165847213797285919u64 => Ok(self.player_penetrate_count.clone().into()),
1524 2624120833319605424u64 => Ok(self.assister_fallback.clone().into()),
1525 10219443329572148957u64 => Ok(self.kill_streak_total.clone().into()),
1526 14151704064294986651u64 => Ok(self.kill_streak_wep.clone().into()),
1527 3408761288007698574u64 => Ok(self.kill_streak_assist.clone().into()),
1528 14613767699666342005u64 => Ok(self.kill_streak_victim.clone().into()),
1529 8814124002674372577u64 => Ok(self.ducks_streaked.clone().into()),
1530 2758270581670703974u64 => Ok(self.duck_streak_total.clone().into()),
1531 10967369523768500963u64 => Ok(self.duck_streak_assist.clone().into()),
1532 620103205137188524u64 => Ok(self.duck_streak_victim.clone().into()),
1533 16207427969859362406u64 => Ok(self.rocket_jump.clone().into()),
1534 4132306594868589054u64 => Ok(self.weapon_def_index.clone().into()),
1535 7263029362109349446u64 => Ok(self.crit_type.clone().into()),
1536 _ => Err(ParseError::MissingGameEventValue {
1537 ty: "PlayerDeath",
1538 field: "todo".into(),
1539 }),
1540 }
1541 }
1542 #[allow(unused_variables)]
1543 fn write(
1544 &self,
1545 stream: &mut BitWriteStream<LittleEndian>,
1546 definition: &GameEventDefinition,
1547 ) -> Result<()> {
1548 for entry in &definition.entries {
1549 let value = self
1550 .get_field(entry)
1551 .unwrap_or_else(|_| entry.kind.default_value());
1552 stream.write(&value)?;
1553 }
1554 Ok(())
1555 }
1556}
1557#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1558#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1559pub struct PlayerHurtEvent {
1560 pub user_id: u16,
1561 pub health: u16,
1562 pub attacker: u16,
1563 pub damage_amount: u16,
1564 pub custom: u16,
1565 pub show_disguised_crit: bool,
1566 pub crit: bool,
1567 pub mini_crit: bool,
1568 pub all_see_crit: bool,
1569 pub weapon_id: u16,
1570 pub bonus_effect: u8,
1571}
1572impl PlayerHurtEvent {
1573 #[allow(unused_variables)]
1574 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1575 Ok(PlayerHurtEvent {
1576 user_id: read_value::<u16>(
1577 stream,
1578 definition.get_entry(17826443226371159423u64),
1579 "user_id",
1580 )?,
1581 health: read_value::<u16>(
1582 stream,
1583 definition.get_entry(9181103189905877455u64),
1584 "health",
1585 )?,
1586 attacker: read_value::<u16>(
1587 stream,
1588 definition.get_entry(7198542740550218478u64),
1589 "attacker",
1590 )?,
1591 damage_amount: read_value::<u16>(
1592 stream,
1593 definition.get_entry(7439038394412279612u64),
1594 "damage_amount",
1595 )?,
1596 custom: read_value::<u16>(
1597 stream,
1598 definition.get_entry(604290716149806926u64),
1599 "custom",
1600 )?,
1601 show_disguised_crit: read_value::<bool>(
1602 stream,
1603 definition.get_entry(14301803044080296297u64),
1604 "show_disguised_crit",
1605 )?,
1606 crit: read_value::<bool>(stream, definition.get_entry(1324453635955533101u64), "crit")?,
1607 mini_crit: read_value::<bool>(
1608 stream,
1609 definition.get_entry(18286698110279670006u64),
1610 "mini_crit",
1611 )?,
1612 all_see_crit: read_value::<bool>(
1613 stream,
1614 definition.get_entry(3290419718563846047u64),
1615 "all_see_crit",
1616 )?,
1617 weapon_id: read_value::<u16>(
1618 stream,
1619 definition.get_entry(5542695206485500884u64),
1620 "weapon_id",
1621 )?,
1622 bonus_effect: read_value::<u8>(
1623 stream,
1624 definition.get_entry(4613275483771643085u64),
1625 "bonus_effect",
1626 )?,
1627 })
1628 }
1629 #[allow(unused_variables)]
1630 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1631 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1632 match field.hash {
1633 17826443226371159423u64 => Ok(self.user_id.clone().into()),
1634 9181103189905877455u64 => Ok(self.health.clone().into()),
1635 7198542740550218478u64 => Ok(self.attacker.clone().into()),
1636 7439038394412279612u64 => Ok(self.damage_amount.clone().into()),
1637 604290716149806926u64 => Ok(self.custom.clone().into()),
1638 14301803044080296297u64 => Ok(self.show_disguised_crit.clone().into()),
1639 1324453635955533101u64 => Ok(self.crit.clone().into()),
1640 18286698110279670006u64 => Ok(self.mini_crit.clone().into()),
1641 3290419718563846047u64 => Ok(self.all_see_crit.clone().into()),
1642 5542695206485500884u64 => Ok(self.weapon_id.clone().into()),
1643 4613275483771643085u64 => Ok(self.bonus_effect.clone().into()),
1644 _ => Err(ParseError::MissingGameEventValue {
1645 ty: "PlayerHurt",
1646 field: "todo".into(),
1647 }),
1648 }
1649 }
1650 #[allow(unused_variables)]
1651 fn write(
1652 &self,
1653 stream: &mut BitWriteStream<LittleEndian>,
1654 definition: &GameEventDefinition,
1655 ) -> Result<()> {
1656 for entry in &definition.entries {
1657 let value = self
1658 .get_field(entry)
1659 .unwrap_or_else(|_| entry.kind.default_value());
1660 stream.write(&value)?;
1661 }
1662 Ok(())
1663 }
1664}
1665#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1666#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1667pub struct PlayerChatEvent {
1668 pub team_only: bool,
1669 pub user_id: u16,
1670 pub text: MaybeUtf8String,
1671}
1672impl PlayerChatEvent {
1673 #[allow(unused_variables)]
1674 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1675 Ok(PlayerChatEvent {
1676 team_only: read_value::<bool>(
1677 stream,
1678 definition.get_entry(8997360128490965478u64),
1679 "team_only",
1680 )?,
1681 user_id: read_value::<u16>(
1682 stream,
1683 definition.get_entry(17826443226371159423u64),
1684 "user_id",
1685 )?,
1686 text: read_value::<MaybeUtf8String>(
1687 stream,
1688 definition.get_entry(18015793717152399486u64),
1689 "text",
1690 )?,
1691 })
1692 }
1693 #[allow(unused_variables)]
1694 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1695 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1696 match field.hash {
1697 8997360128490965478u64 => Ok(self.team_only.clone().into()),
1698 17826443226371159423u64 => Ok(self.user_id.clone().into()),
1699 18015793717152399486u64 => Ok(self.text.clone().into()),
1700 _ => Err(ParseError::MissingGameEventValue {
1701 ty: "PlayerChat",
1702 field: "todo".into(),
1703 }),
1704 }
1705 }
1706 #[allow(unused_variables)]
1707 fn write(
1708 &self,
1709 stream: &mut BitWriteStream<LittleEndian>,
1710 definition: &GameEventDefinition,
1711 ) -> Result<()> {
1712 for entry in &definition.entries {
1713 let value = self
1714 .get_field(entry)
1715 .unwrap_or_else(|_| entry.kind.default_value());
1716 stream.write(&value)?;
1717 }
1718 Ok(())
1719 }
1720}
1721#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1722#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1723pub struct PlayerScoreEvent {
1724 pub user_id: u16,
1725 pub kills: u16,
1726 pub deaths: u16,
1727 pub score: u16,
1728}
1729impl PlayerScoreEvent {
1730 #[allow(unused_variables)]
1731 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1732 Ok(PlayerScoreEvent {
1733 user_id: read_value::<u16>(
1734 stream,
1735 definition.get_entry(17826443226371159423u64),
1736 "user_id",
1737 )?,
1738 kills: read_value::<u16>(
1739 stream,
1740 definition.get_entry(8934927864608526494u64),
1741 "kills",
1742 )?,
1743 deaths: read_value::<u16>(
1744 stream,
1745 definition.get_entry(15487195249286514682u64),
1746 "deaths",
1747 )?,
1748 score: read_value::<u16>(
1749 stream,
1750 definition.get_entry(13911166232573650165u64),
1751 "score",
1752 )?,
1753 })
1754 }
1755 #[allow(unused_variables)]
1756 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1757 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1758 match field.hash {
1759 17826443226371159423u64 => Ok(self.user_id.clone().into()),
1760 8934927864608526494u64 => Ok(self.kills.clone().into()),
1761 15487195249286514682u64 => Ok(self.deaths.clone().into()),
1762 13911166232573650165u64 => Ok(self.score.clone().into()),
1763 _ => Err(ParseError::MissingGameEventValue {
1764 ty: "PlayerScore",
1765 field: "todo".into(),
1766 }),
1767 }
1768 }
1769 #[allow(unused_variables)]
1770 fn write(
1771 &self,
1772 stream: &mut BitWriteStream<LittleEndian>,
1773 definition: &GameEventDefinition,
1774 ) -> Result<()> {
1775 for entry in &definition.entries {
1776 let value = self
1777 .get_field(entry)
1778 .unwrap_or_else(|_| entry.kind.default_value());
1779 stream.write(&value)?;
1780 }
1781 Ok(())
1782 }
1783}
1784#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1785#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1786pub struct PlayerSpawnEvent {
1787 pub user_id: u16,
1788 pub team: u16,
1789 pub class: u16,
1790}
1791impl PlayerSpawnEvent {
1792 #[allow(unused_variables)]
1793 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1794 Ok(PlayerSpawnEvent {
1795 user_id: read_value::<u16>(
1796 stream,
1797 definition.get_entry(17826443226371159423u64),
1798 "user_id",
1799 )?,
1800 team: read_value::<u16>(
1801 stream,
1802 definition.get_entry(18024489754618217260u64),
1803 "team",
1804 )?,
1805 class: read_value::<u16>(
1806 stream,
1807 definition.get_entry(15066323702654938015u64),
1808 "class",
1809 )?,
1810 })
1811 }
1812 #[allow(unused_variables)]
1813 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1814 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1815 match field.hash {
1816 17826443226371159423u64 => Ok(self.user_id.clone().into()),
1817 18024489754618217260u64 => Ok(self.team.clone().into()),
1818 15066323702654938015u64 => Ok(self.class.clone().into()),
1819 _ => Err(ParseError::MissingGameEventValue {
1820 ty: "PlayerSpawn",
1821 field: "todo".into(),
1822 }),
1823 }
1824 }
1825 #[allow(unused_variables)]
1826 fn write(
1827 &self,
1828 stream: &mut BitWriteStream<LittleEndian>,
1829 definition: &GameEventDefinition,
1830 ) -> Result<()> {
1831 for entry in &definition.entries {
1832 let value = self
1833 .get_field(entry)
1834 .unwrap_or_else(|_| entry.kind.default_value());
1835 stream.write(&value)?;
1836 }
1837 Ok(())
1838 }
1839}
1840#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1841#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1842pub struct PlayerShootEvent {
1843 pub user_id: u16,
1844 pub weapon: u8,
1845 pub mode: u8,
1846}
1847impl PlayerShootEvent {
1848 #[allow(unused_variables)]
1849 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1850 Ok(PlayerShootEvent {
1851 user_id: read_value::<u16>(
1852 stream,
1853 definition.get_entry(17826443226371159423u64),
1854 "user_id",
1855 )?,
1856 weapon: read_value::<u8>(
1857 stream,
1858 definition.get_entry(11580461223051554305u64),
1859 "weapon",
1860 )?,
1861 mode: read_value::<u8>(stream, definition.get_entry(954177780379921842u64), "mode")?,
1862 })
1863 }
1864 #[allow(unused_variables)]
1865 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1866 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1867 match field.hash {
1868 17826443226371159423u64 => Ok(self.user_id.clone().into()),
1869 11580461223051554305u64 => Ok(self.weapon.clone().into()),
1870 954177780379921842u64 => Ok(self.mode.clone().into()),
1871 _ => Err(ParseError::MissingGameEventValue {
1872 ty: "PlayerShoot",
1873 field: "todo".into(),
1874 }),
1875 }
1876 }
1877 #[allow(unused_variables)]
1878 fn write(
1879 &self,
1880 stream: &mut BitWriteStream<LittleEndian>,
1881 definition: &GameEventDefinition,
1882 ) -> Result<()> {
1883 for entry in &definition.entries {
1884 let value = self
1885 .get_field(entry)
1886 .unwrap_or_else(|_| entry.kind.default_value());
1887 stream.write(&value)?;
1888 }
1889 Ok(())
1890 }
1891}
1892#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1893#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1894pub struct PlayerUseEvent {
1895 pub user_id: u16,
1896 pub entity: u16,
1897}
1898impl PlayerUseEvent {
1899 #[allow(unused_variables)]
1900 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1901 Ok(PlayerUseEvent {
1902 user_id: read_value::<u16>(
1903 stream,
1904 definition.get_entry(17826443226371159423u64),
1905 "user_id",
1906 )?,
1907 entity: read_value::<u16>(
1908 stream,
1909 definition.get_entry(10409922166629367034u64),
1910 "entity",
1911 )?,
1912 })
1913 }
1914 #[allow(unused_variables)]
1915 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1916 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1917 match field.hash {
1918 17826443226371159423u64 => Ok(self.user_id.clone().into()),
1919 10409922166629367034u64 => Ok(self.entity.clone().into()),
1920 _ => Err(ParseError::MissingGameEventValue {
1921 ty: "PlayerUse",
1922 field: "todo".into(),
1923 }),
1924 }
1925 }
1926 #[allow(unused_variables)]
1927 fn write(
1928 &self,
1929 stream: &mut BitWriteStream<LittleEndian>,
1930 definition: &GameEventDefinition,
1931 ) -> Result<()> {
1932 for entry in &definition.entries {
1933 let value = self
1934 .get_field(entry)
1935 .unwrap_or_else(|_| entry.kind.default_value());
1936 stream.write(&value)?;
1937 }
1938 Ok(())
1939 }
1940}
1941#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1942#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1943pub struct PlayerChangeNameEvent {
1944 pub user_id: u16,
1945 pub old_name: MaybeUtf8String,
1946 pub new_name: MaybeUtf8String,
1947}
1948impl PlayerChangeNameEvent {
1949 #[allow(unused_variables)]
1950 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
1951 Ok(PlayerChangeNameEvent {
1952 user_id: read_value::<u16>(
1953 stream,
1954 definition.get_entry(17826443226371159423u64),
1955 "user_id",
1956 )?,
1957 old_name: read_value::<MaybeUtf8String>(
1958 stream,
1959 definition.get_entry(11919108480345551253u64),
1960 "old_name",
1961 )?,
1962 new_name: read_value::<MaybeUtf8String>(
1963 stream,
1964 definition.get_entry(8904377156710117674u64),
1965 "new_name",
1966 )?,
1967 })
1968 }
1969 #[allow(unused_variables)]
1970 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
1971 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
1972 match field.hash {
1973 17826443226371159423u64 => Ok(self.user_id.clone().into()),
1974 11919108480345551253u64 => Ok(self.old_name.clone().into()),
1975 8904377156710117674u64 => Ok(self.new_name.clone().into()),
1976 _ => Err(ParseError::MissingGameEventValue {
1977 ty: "PlayerChangeName",
1978 field: "todo".into(),
1979 }),
1980 }
1981 }
1982 #[allow(unused_variables)]
1983 fn write(
1984 &self,
1985 stream: &mut BitWriteStream<LittleEndian>,
1986 definition: &GameEventDefinition,
1987 ) -> Result<()> {
1988 for entry in &definition.entries {
1989 let value = self
1990 .get_field(entry)
1991 .unwrap_or_else(|_| entry.kind.default_value());
1992 stream.write(&value)?;
1993 }
1994 Ok(())
1995 }
1996}
1997#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
1998#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
1999pub struct PlayerHintMessageEvent {
2000 pub hint_message: MaybeUtf8String,
2001}
2002impl PlayerHintMessageEvent {
2003 #[allow(unused_variables)]
2004 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2005 Ok(PlayerHintMessageEvent {
2006 hint_message: read_value::<MaybeUtf8String>(
2007 stream,
2008 definition.get_entry(13996716249204415567u64),
2009 "hint_message",
2010 )?,
2011 })
2012 }
2013 #[allow(unused_variables)]
2014 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2015 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2016 match field.hash {
2017 13996716249204415567u64 => Ok(self.hint_message.clone().into()),
2018 _ => Err(ParseError::MissingGameEventValue {
2019 ty: "PlayerHintMessage",
2020 field: "todo".into(),
2021 }),
2022 }
2023 }
2024 #[allow(unused_variables)]
2025 fn write(
2026 &self,
2027 stream: &mut BitWriteStream<LittleEndian>,
2028 definition: &GameEventDefinition,
2029 ) -> Result<()> {
2030 for entry in &definition.entries {
2031 let value = self
2032 .get_field(entry)
2033 .unwrap_or_else(|_| entry.kind.default_value());
2034 stream.write(&value)?;
2035 }
2036 Ok(())
2037 }
2038}
2039#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2040#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2041pub struct BasePlayerTeleportedEvent {
2042 pub ent_index: u16,
2043}
2044impl BasePlayerTeleportedEvent {
2045 #[allow(unused_variables)]
2046 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2047 Ok(BasePlayerTeleportedEvent {
2048 ent_index: read_value::<u16>(
2049 stream,
2050 definition.get_entry(17554918082946193550u64),
2051 "ent_index",
2052 )?,
2053 })
2054 }
2055 #[allow(unused_variables)]
2056 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2057 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2058 match field.hash {
2059 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
2060 _ => Err(ParseError::MissingGameEventValue {
2061 ty: "BasePlayerTeleported",
2062 field: "todo".into(),
2063 }),
2064 }
2065 }
2066 #[allow(unused_variables)]
2067 fn write(
2068 &self,
2069 stream: &mut BitWriteStream<LittleEndian>,
2070 definition: &GameEventDefinition,
2071 ) -> Result<()> {
2072 for entry in &definition.entries {
2073 let value = self
2074 .get_field(entry)
2075 .unwrap_or_else(|_| entry.kind.default_value());
2076 stream.write(&value)?;
2077 }
2078 Ok(())
2079 }
2080}
2081#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2082#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2083pub struct GameInitEvent {}
2084impl GameInitEvent {
2085 #[allow(unused_variables)]
2086 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2087 Ok(GameInitEvent {})
2088 }
2089 #[allow(unused_variables)]
2090 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2091 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2092 match field.hash {
2093 _ => Err(ParseError::MissingGameEventValue {
2094 ty: "GameInit",
2095 field: "todo".into(),
2096 }),
2097 }
2098 }
2099 #[allow(unused_variables)]
2100 fn write(
2101 &self,
2102 stream: &mut BitWriteStream<LittleEndian>,
2103 definition: &GameEventDefinition,
2104 ) -> Result<()> {
2105 for entry in &definition.entries {
2106 let value = self
2107 .get_field(entry)
2108 .unwrap_or_else(|_| entry.kind.default_value());
2109 stream.write(&value)?;
2110 }
2111 Ok(())
2112 }
2113}
2114#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2115#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2116pub struct GameNewMapEvent {
2117 pub map_name: MaybeUtf8String,
2118}
2119impl GameNewMapEvent {
2120 #[allow(unused_variables)]
2121 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2122 Ok(GameNewMapEvent {
2123 map_name: read_value::<MaybeUtf8String>(
2124 stream,
2125 definition.get_entry(18037678950216614794u64),
2126 "map_name",
2127 )?,
2128 })
2129 }
2130 #[allow(unused_variables)]
2131 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2132 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2133 match field.hash {
2134 18037678950216614794u64 => Ok(self.map_name.clone().into()),
2135 _ => Err(ParseError::MissingGameEventValue {
2136 ty: "GameNewMap",
2137 field: "todo".into(),
2138 }),
2139 }
2140 }
2141 #[allow(unused_variables)]
2142 fn write(
2143 &self,
2144 stream: &mut BitWriteStream<LittleEndian>,
2145 definition: &GameEventDefinition,
2146 ) -> Result<()> {
2147 for entry in &definition.entries {
2148 let value = self
2149 .get_field(entry)
2150 .unwrap_or_else(|_| entry.kind.default_value());
2151 stream.write(&value)?;
2152 }
2153 Ok(())
2154 }
2155}
2156#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2157#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2158pub struct GameStartEvent {
2159 pub rounds_limit: u32,
2160 pub time_limit: u32,
2161 pub frag_limit: u32,
2162 pub objective: MaybeUtf8String,
2163}
2164impl GameStartEvent {
2165 #[allow(unused_variables)]
2166 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2167 Ok(GameStartEvent {
2168 rounds_limit: read_value::<u32>(
2169 stream,
2170 definition.get_entry(6594118856211890507u64),
2171 "rounds_limit",
2172 )?,
2173 time_limit: read_value::<u32>(
2174 stream,
2175 definition.get_entry(8925605756456439511u64),
2176 "time_limit",
2177 )?,
2178 frag_limit: read_value::<u32>(
2179 stream,
2180 definition.get_entry(9937264313491586980u64),
2181 "frag_limit",
2182 )?,
2183 objective: read_value::<MaybeUtf8String>(
2184 stream,
2185 definition.get_entry(8095747183904291896u64),
2186 "objective",
2187 )?,
2188 })
2189 }
2190 #[allow(unused_variables)]
2191 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2192 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2193 match field.hash {
2194 6594118856211890507u64 => Ok(self.rounds_limit.clone().into()),
2195 8925605756456439511u64 => Ok(self.time_limit.clone().into()),
2196 9937264313491586980u64 => Ok(self.frag_limit.clone().into()),
2197 8095747183904291896u64 => Ok(self.objective.clone().into()),
2198 _ => Err(ParseError::MissingGameEventValue {
2199 ty: "GameStart",
2200 field: "todo".into(),
2201 }),
2202 }
2203 }
2204 #[allow(unused_variables)]
2205 fn write(
2206 &self,
2207 stream: &mut BitWriteStream<LittleEndian>,
2208 definition: &GameEventDefinition,
2209 ) -> Result<()> {
2210 for entry in &definition.entries {
2211 let value = self
2212 .get_field(entry)
2213 .unwrap_or_else(|_| entry.kind.default_value());
2214 stream.write(&value)?;
2215 }
2216 Ok(())
2217 }
2218}
2219#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2220#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2221pub struct GameEndEvent {
2222 pub winner: u8,
2223}
2224impl GameEndEvent {
2225 #[allow(unused_variables)]
2226 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2227 Ok(GameEndEvent {
2228 winner: read_value::<u8>(
2229 stream,
2230 definition.get_entry(4337804175666422150u64),
2231 "winner",
2232 )?,
2233 })
2234 }
2235 #[allow(unused_variables)]
2236 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2237 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2238 match field.hash {
2239 4337804175666422150u64 => Ok(self.winner.clone().into()),
2240 _ => Err(ParseError::MissingGameEventValue {
2241 ty: "GameEnd",
2242 field: "todo".into(),
2243 }),
2244 }
2245 }
2246 #[allow(unused_variables)]
2247 fn write(
2248 &self,
2249 stream: &mut BitWriteStream<LittleEndian>,
2250 definition: &GameEventDefinition,
2251 ) -> Result<()> {
2252 for entry in &definition.entries {
2253 let value = self
2254 .get_field(entry)
2255 .unwrap_or_else(|_| entry.kind.default_value());
2256 stream.write(&value)?;
2257 }
2258 Ok(())
2259 }
2260}
2261#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2262#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2263pub struct RoundStartEvent {
2264 pub time_limit: u32,
2265 pub frag_limit: u32,
2266 pub objective: MaybeUtf8String,
2267}
2268impl RoundStartEvent {
2269 #[allow(unused_variables)]
2270 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2271 Ok(RoundStartEvent {
2272 time_limit: read_value::<u32>(
2273 stream,
2274 definition.get_entry(8925605756456439511u64),
2275 "time_limit",
2276 )?,
2277 frag_limit: read_value::<u32>(
2278 stream,
2279 definition.get_entry(9937264313491586980u64),
2280 "frag_limit",
2281 )?,
2282 objective: read_value::<MaybeUtf8String>(
2283 stream,
2284 definition.get_entry(8095747183904291896u64),
2285 "objective",
2286 )?,
2287 })
2288 }
2289 #[allow(unused_variables)]
2290 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2291 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2292 match field.hash {
2293 8925605756456439511u64 => Ok(self.time_limit.clone().into()),
2294 9937264313491586980u64 => Ok(self.frag_limit.clone().into()),
2295 8095747183904291896u64 => Ok(self.objective.clone().into()),
2296 _ => Err(ParseError::MissingGameEventValue {
2297 ty: "RoundStart",
2298 field: "todo".into(),
2299 }),
2300 }
2301 }
2302 #[allow(unused_variables)]
2303 fn write(
2304 &self,
2305 stream: &mut BitWriteStream<LittleEndian>,
2306 definition: &GameEventDefinition,
2307 ) -> Result<()> {
2308 for entry in &definition.entries {
2309 let value = self
2310 .get_field(entry)
2311 .unwrap_or_else(|_| entry.kind.default_value());
2312 stream.write(&value)?;
2313 }
2314 Ok(())
2315 }
2316}
2317#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2318#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2319pub struct RoundEndEvent {
2320 pub winner: u8,
2321 pub reason: u8,
2322 pub message: MaybeUtf8String,
2323}
2324impl RoundEndEvent {
2325 #[allow(unused_variables)]
2326 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2327 Ok(RoundEndEvent {
2328 winner: read_value::<u8>(
2329 stream,
2330 definition.get_entry(4337804175666422150u64),
2331 "winner",
2332 )?,
2333 reason: read_value::<u8>(
2334 stream,
2335 definition.get_entry(7343356632300987961u64),
2336 "reason",
2337 )?,
2338 message: read_value::<MaybeUtf8String>(
2339 stream,
2340 definition.get_entry(6080987277291999908u64),
2341 "message",
2342 )?,
2343 })
2344 }
2345 #[allow(unused_variables)]
2346 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2347 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2348 match field.hash {
2349 4337804175666422150u64 => Ok(self.winner.clone().into()),
2350 7343356632300987961u64 => Ok(self.reason.clone().into()),
2351 6080987277291999908u64 => Ok(self.message.clone().into()),
2352 _ => Err(ParseError::MissingGameEventValue {
2353 ty: "RoundEnd",
2354 field: "todo".into(),
2355 }),
2356 }
2357 }
2358 #[allow(unused_variables)]
2359 fn write(
2360 &self,
2361 stream: &mut BitWriteStream<LittleEndian>,
2362 definition: &GameEventDefinition,
2363 ) -> Result<()> {
2364 for entry in &definition.entries {
2365 let value = self
2366 .get_field(entry)
2367 .unwrap_or_else(|_| entry.kind.default_value());
2368 stream.write(&value)?;
2369 }
2370 Ok(())
2371 }
2372}
2373#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2374#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2375pub struct GameMessageEvent {
2376 pub target: u8,
2377 pub text: MaybeUtf8String,
2378}
2379impl GameMessageEvent {
2380 #[allow(unused_variables)]
2381 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2382 Ok(GameMessageEvent {
2383 target: read_value::<u8>(
2384 stream,
2385 definition.get_entry(1653916590517707752u64),
2386 "target",
2387 )?,
2388 text: read_value::<MaybeUtf8String>(
2389 stream,
2390 definition.get_entry(18015793717152399486u64),
2391 "text",
2392 )?,
2393 })
2394 }
2395 #[allow(unused_variables)]
2396 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2397 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2398 match field.hash {
2399 1653916590517707752u64 => Ok(self.target.clone().into()),
2400 18015793717152399486u64 => Ok(self.text.clone().into()),
2401 _ => Err(ParseError::MissingGameEventValue {
2402 ty: "GameMessage",
2403 field: "todo".into(),
2404 }),
2405 }
2406 }
2407 #[allow(unused_variables)]
2408 fn write(
2409 &self,
2410 stream: &mut BitWriteStream<LittleEndian>,
2411 definition: &GameEventDefinition,
2412 ) -> Result<()> {
2413 for entry in &definition.entries {
2414 let value = self
2415 .get_field(entry)
2416 .unwrap_or_else(|_| entry.kind.default_value());
2417 stream.write(&value)?;
2418 }
2419 Ok(())
2420 }
2421}
2422#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2423#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2424pub struct BreakBreakableEvent {
2425 pub ent_index: u32,
2426 pub user_id: u16,
2427 pub material: u8,
2428}
2429impl BreakBreakableEvent {
2430 #[allow(unused_variables)]
2431 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2432 Ok(BreakBreakableEvent {
2433 ent_index: read_value::<u32>(
2434 stream,
2435 definition.get_entry(17554918082946193550u64),
2436 "ent_index",
2437 )?,
2438 user_id: read_value::<u16>(
2439 stream,
2440 definition.get_entry(17826443226371159423u64),
2441 "user_id",
2442 )?,
2443 material: read_value::<u8>(
2444 stream,
2445 definition.get_entry(175488002581160416u64),
2446 "material",
2447 )?,
2448 })
2449 }
2450 #[allow(unused_variables)]
2451 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2452 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2453 match field.hash {
2454 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
2455 17826443226371159423u64 => Ok(self.user_id.clone().into()),
2456 175488002581160416u64 => Ok(self.material.clone().into()),
2457 _ => Err(ParseError::MissingGameEventValue {
2458 ty: "BreakBreakable",
2459 field: "todo".into(),
2460 }),
2461 }
2462 }
2463 #[allow(unused_variables)]
2464 fn write(
2465 &self,
2466 stream: &mut BitWriteStream<LittleEndian>,
2467 definition: &GameEventDefinition,
2468 ) -> Result<()> {
2469 for entry in &definition.entries {
2470 let value = self
2471 .get_field(entry)
2472 .unwrap_or_else(|_| entry.kind.default_value());
2473 stream.write(&value)?;
2474 }
2475 Ok(())
2476 }
2477}
2478#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2479#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2480pub struct BreakPropEvent {
2481 pub ent_index: u32,
2482 pub user_id: u16,
2483}
2484impl BreakPropEvent {
2485 #[allow(unused_variables)]
2486 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2487 Ok(BreakPropEvent {
2488 ent_index: read_value::<u32>(
2489 stream,
2490 definition.get_entry(17554918082946193550u64),
2491 "ent_index",
2492 )?,
2493 user_id: read_value::<u16>(
2494 stream,
2495 definition.get_entry(17826443226371159423u64),
2496 "user_id",
2497 )?,
2498 })
2499 }
2500 #[allow(unused_variables)]
2501 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2502 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2503 match field.hash {
2504 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
2505 17826443226371159423u64 => Ok(self.user_id.clone().into()),
2506 _ => Err(ParseError::MissingGameEventValue {
2507 ty: "BreakProp",
2508 field: "todo".into(),
2509 }),
2510 }
2511 }
2512 #[allow(unused_variables)]
2513 fn write(
2514 &self,
2515 stream: &mut BitWriteStream<LittleEndian>,
2516 definition: &GameEventDefinition,
2517 ) -> Result<()> {
2518 for entry in &definition.entries {
2519 let value = self
2520 .get_field(entry)
2521 .unwrap_or_else(|_| entry.kind.default_value());
2522 stream.write(&value)?;
2523 }
2524 Ok(())
2525 }
2526}
2527#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2528#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2529pub struct EntityKilledEvent {
2530 pub ent_index_killed: u32,
2531 pub ent_index_attacker: u32,
2532 pub ent_index_inflictor: u32,
2533 pub damage_bits: u32,
2534}
2535impl EntityKilledEvent {
2536 #[allow(unused_variables)]
2537 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2538 Ok(EntityKilledEvent {
2539 ent_index_killed: read_value::<u32>(
2540 stream,
2541 definition.get_entry(9772342216534838146u64),
2542 "ent_index_killed",
2543 )?,
2544 ent_index_attacker: read_value::<u32>(
2545 stream,
2546 definition.get_entry(15130955426090253880u64),
2547 "ent_index_attacker",
2548 )?,
2549 ent_index_inflictor: read_value::<u32>(
2550 stream,
2551 definition.get_entry(12707416538007474931u64),
2552 "ent_index_inflictor",
2553 )?,
2554 damage_bits: read_value::<u32>(
2555 stream,
2556 definition.get_entry(2104626753992558984u64),
2557 "damage_bits",
2558 )?,
2559 })
2560 }
2561 #[allow(unused_variables)]
2562 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2563 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2564 match field.hash {
2565 9772342216534838146u64 => Ok(self.ent_index_killed.clone().into()),
2566 15130955426090253880u64 => Ok(self.ent_index_attacker.clone().into()),
2567 12707416538007474931u64 => Ok(self.ent_index_inflictor.clone().into()),
2568 2104626753992558984u64 => Ok(self.damage_bits.clone().into()),
2569 _ => Err(ParseError::MissingGameEventValue {
2570 ty: "EntityKilled",
2571 field: "todo".into(),
2572 }),
2573 }
2574 }
2575 #[allow(unused_variables)]
2576 fn write(
2577 &self,
2578 stream: &mut BitWriteStream<LittleEndian>,
2579 definition: &GameEventDefinition,
2580 ) -> Result<()> {
2581 for entry in &definition.entries {
2582 let value = self
2583 .get_field(entry)
2584 .unwrap_or_else(|_| entry.kind.default_value());
2585 stream.write(&value)?;
2586 }
2587 Ok(())
2588 }
2589}
2590#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2591#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2592pub struct BonusUpdatedEvent {
2593 pub num_advanced: u16,
2594 pub num_bronze: u16,
2595 pub num_silver: u16,
2596 pub num_gold: u16,
2597}
2598impl BonusUpdatedEvent {
2599 #[allow(unused_variables)]
2600 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2601 Ok(BonusUpdatedEvent {
2602 num_advanced: read_value::<u16>(
2603 stream,
2604 definition.get_entry(18281866615588036317u64),
2605 "num_advanced",
2606 )?,
2607 num_bronze: read_value::<u16>(
2608 stream,
2609 definition.get_entry(17784477894966475211u64),
2610 "num_bronze",
2611 )?,
2612 num_silver: read_value::<u16>(
2613 stream,
2614 definition.get_entry(654857209225446882u64),
2615 "num_silver",
2616 )?,
2617 num_gold: read_value::<u16>(
2618 stream,
2619 definition.get_entry(4800941608394754913u64),
2620 "num_gold",
2621 )?,
2622 })
2623 }
2624 #[allow(unused_variables)]
2625 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2626 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2627 match field.hash {
2628 18281866615588036317u64 => Ok(self.num_advanced.clone().into()),
2629 17784477894966475211u64 => Ok(self.num_bronze.clone().into()),
2630 654857209225446882u64 => Ok(self.num_silver.clone().into()),
2631 4800941608394754913u64 => Ok(self.num_gold.clone().into()),
2632 _ => Err(ParseError::MissingGameEventValue {
2633 ty: "BonusUpdated",
2634 field: "todo".into(),
2635 }),
2636 }
2637 }
2638 #[allow(unused_variables)]
2639 fn write(
2640 &self,
2641 stream: &mut BitWriteStream<LittleEndian>,
2642 definition: &GameEventDefinition,
2643 ) -> Result<()> {
2644 for entry in &definition.entries {
2645 let value = self
2646 .get_field(entry)
2647 .unwrap_or_else(|_| entry.kind.default_value());
2648 stream.write(&value)?;
2649 }
2650 Ok(())
2651 }
2652}
2653#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2654#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2655pub struct AchievementEventEvent {
2656 pub achievement_name: MaybeUtf8String,
2657 pub cur_val: u16,
2658 pub max_val: u16,
2659}
2660impl AchievementEventEvent {
2661 #[allow(unused_variables)]
2662 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2663 Ok(AchievementEventEvent {
2664 achievement_name: read_value::<MaybeUtf8String>(
2665 stream,
2666 definition.get_entry(15691172238087995014u64),
2667 "achievement_name",
2668 )?,
2669 cur_val: read_value::<u16>(
2670 stream,
2671 definition.get_entry(5486189633889604213u64),
2672 "cur_val",
2673 )?,
2674 max_val: read_value::<u16>(
2675 stream,
2676 definition.get_entry(15860362688261047681u64),
2677 "max_val",
2678 )?,
2679 })
2680 }
2681 #[allow(unused_variables)]
2682 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2683 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2684 match field.hash {
2685 15691172238087995014u64 => Ok(self.achievement_name.clone().into()),
2686 5486189633889604213u64 => Ok(self.cur_val.clone().into()),
2687 15860362688261047681u64 => Ok(self.max_val.clone().into()),
2688 _ => Err(ParseError::MissingGameEventValue {
2689 ty: "AchievementEvent",
2690 field: "todo".into(),
2691 }),
2692 }
2693 }
2694 #[allow(unused_variables)]
2695 fn write(
2696 &self,
2697 stream: &mut BitWriteStream<LittleEndian>,
2698 definition: &GameEventDefinition,
2699 ) -> Result<()> {
2700 for entry in &definition.entries {
2701 let value = self
2702 .get_field(entry)
2703 .unwrap_or_else(|_| entry.kind.default_value());
2704 stream.write(&value)?;
2705 }
2706 Ok(())
2707 }
2708}
2709#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2710#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2711pub struct AchievementIncrementEvent {
2712 pub achievement_id: u32,
2713 pub cur_val: u16,
2714 pub max_val: u16,
2715}
2716impl AchievementIncrementEvent {
2717 #[allow(unused_variables)]
2718 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2719 Ok(AchievementIncrementEvent {
2720 achievement_id: read_value::<u32>(
2721 stream,
2722 definition.get_entry(17475110908491474368u64),
2723 "achievement_id",
2724 )?,
2725 cur_val: read_value::<u16>(
2726 stream,
2727 definition.get_entry(5486189633889604213u64),
2728 "cur_val",
2729 )?,
2730 max_val: read_value::<u16>(
2731 stream,
2732 definition.get_entry(15860362688261047681u64),
2733 "max_val",
2734 )?,
2735 })
2736 }
2737 #[allow(unused_variables)]
2738 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2739 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2740 match field.hash {
2741 17475110908491474368u64 => Ok(self.achievement_id.clone().into()),
2742 5486189633889604213u64 => Ok(self.cur_val.clone().into()),
2743 15860362688261047681u64 => Ok(self.max_val.clone().into()),
2744 _ => Err(ParseError::MissingGameEventValue {
2745 ty: "AchievementIncrement",
2746 field: "todo".into(),
2747 }),
2748 }
2749 }
2750 #[allow(unused_variables)]
2751 fn write(
2752 &self,
2753 stream: &mut BitWriteStream<LittleEndian>,
2754 definition: &GameEventDefinition,
2755 ) -> Result<()> {
2756 for entry in &definition.entries {
2757 let value = self
2758 .get_field(entry)
2759 .unwrap_or_else(|_| entry.kind.default_value());
2760 stream.write(&value)?;
2761 }
2762 Ok(())
2763 }
2764}
2765#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2766#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2767pub struct PhysgunPickupEvent {
2768 pub ent_index: u32,
2769}
2770impl PhysgunPickupEvent {
2771 #[allow(unused_variables)]
2772 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2773 Ok(PhysgunPickupEvent {
2774 ent_index: read_value::<u32>(
2775 stream,
2776 definition.get_entry(17554918082946193550u64),
2777 "ent_index",
2778 )?,
2779 })
2780 }
2781 #[allow(unused_variables)]
2782 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2783 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2784 match field.hash {
2785 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
2786 _ => Err(ParseError::MissingGameEventValue {
2787 ty: "PhysgunPickup",
2788 field: "todo".into(),
2789 }),
2790 }
2791 }
2792 #[allow(unused_variables)]
2793 fn write(
2794 &self,
2795 stream: &mut BitWriteStream<LittleEndian>,
2796 definition: &GameEventDefinition,
2797 ) -> Result<()> {
2798 for entry in &definition.entries {
2799 let value = self
2800 .get_field(entry)
2801 .unwrap_or_else(|_| entry.kind.default_value());
2802 stream.write(&value)?;
2803 }
2804 Ok(())
2805 }
2806}
2807#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2808#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2809pub struct FlareIgniteNpcEvent {
2810 pub ent_index: u32,
2811}
2812impl FlareIgniteNpcEvent {
2813 #[allow(unused_variables)]
2814 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2815 Ok(FlareIgniteNpcEvent {
2816 ent_index: read_value::<u32>(
2817 stream,
2818 definition.get_entry(17554918082946193550u64),
2819 "ent_index",
2820 )?,
2821 })
2822 }
2823 #[allow(unused_variables)]
2824 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2825 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2826 match field.hash {
2827 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
2828 _ => Err(ParseError::MissingGameEventValue {
2829 ty: "FlareIgniteNpc",
2830 field: "todo".into(),
2831 }),
2832 }
2833 }
2834 #[allow(unused_variables)]
2835 fn write(
2836 &self,
2837 stream: &mut BitWriteStream<LittleEndian>,
2838 definition: &GameEventDefinition,
2839 ) -> Result<()> {
2840 for entry in &definition.entries {
2841 let value = self
2842 .get_field(entry)
2843 .unwrap_or_else(|_| entry.kind.default_value());
2844 stream.write(&value)?;
2845 }
2846 Ok(())
2847 }
2848}
2849#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2850#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2851pub struct HelicopterGrenadePuntMissEvent {}
2852impl HelicopterGrenadePuntMissEvent {
2853 #[allow(unused_variables)]
2854 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2855 Ok(HelicopterGrenadePuntMissEvent {})
2856 }
2857 #[allow(unused_variables)]
2858 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2859 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2860 match field.hash {
2861 _ => Err(ParseError::MissingGameEventValue {
2862 ty: "HelicopterGrenadePuntMiss",
2863 field: "todo".into(),
2864 }),
2865 }
2866 }
2867 #[allow(unused_variables)]
2868 fn write(
2869 &self,
2870 stream: &mut BitWriteStream<LittleEndian>,
2871 definition: &GameEventDefinition,
2872 ) -> Result<()> {
2873 for entry in &definition.entries {
2874 let value = self
2875 .get_field(entry)
2876 .unwrap_or_else(|_| entry.kind.default_value());
2877 stream.write(&value)?;
2878 }
2879 Ok(())
2880 }
2881}
2882#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2883#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2884pub struct UserDataDownloadedEvent {}
2885impl UserDataDownloadedEvent {
2886 #[allow(unused_variables)]
2887 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2888 Ok(UserDataDownloadedEvent {})
2889 }
2890 #[allow(unused_variables)]
2891 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2892 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2893 match field.hash {
2894 _ => Err(ParseError::MissingGameEventValue {
2895 ty: "UserDataDownloaded",
2896 field: "todo".into(),
2897 }),
2898 }
2899 }
2900 #[allow(unused_variables)]
2901 fn write(
2902 &self,
2903 stream: &mut BitWriteStream<LittleEndian>,
2904 definition: &GameEventDefinition,
2905 ) -> Result<()> {
2906 for entry in &definition.entries {
2907 let value = self
2908 .get_field(entry)
2909 .unwrap_or_else(|_| entry.kind.default_value());
2910 stream.write(&value)?;
2911 }
2912 Ok(())
2913 }
2914}
2915#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2916#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2917pub struct RagdollDissolvedEvent {
2918 pub ent_index: u32,
2919}
2920impl RagdollDissolvedEvent {
2921 #[allow(unused_variables)]
2922 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2923 Ok(RagdollDissolvedEvent {
2924 ent_index: read_value::<u32>(
2925 stream,
2926 definition.get_entry(17554918082946193550u64),
2927 "ent_index",
2928 )?,
2929 })
2930 }
2931 #[allow(unused_variables)]
2932 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2933 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2934 match field.hash {
2935 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
2936 _ => Err(ParseError::MissingGameEventValue {
2937 ty: "RagdollDissolved",
2938 field: "todo".into(),
2939 }),
2940 }
2941 }
2942 #[allow(unused_variables)]
2943 fn write(
2944 &self,
2945 stream: &mut BitWriteStream<LittleEndian>,
2946 definition: &GameEventDefinition,
2947 ) -> Result<()> {
2948 for entry in &definition.entries {
2949 let value = self
2950 .get_field(entry)
2951 .unwrap_or_else(|_| entry.kind.default_value());
2952 stream.write(&value)?;
2953 }
2954 Ok(())
2955 }
2956}
2957#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
2958#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
2959pub struct HLTVChangedModeEvent {
2960 pub old_mode: u16,
2961 pub new_mode: u16,
2962 pub obs_target: u16,
2963}
2964impl HLTVChangedModeEvent {
2965 #[allow(unused_variables)]
2966 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
2967 Ok(HLTVChangedModeEvent {
2968 old_mode: read_value::<u16>(
2969 stream,
2970 definition.get_entry(13993189934714533949u64),
2971 "old_mode",
2972 )?,
2973 new_mode: read_value::<u16>(
2974 stream,
2975 definition.get_entry(874641438558876942u64),
2976 "new_mode",
2977 )?,
2978 obs_target: read_value::<u16>(
2979 stream,
2980 definition.get_entry(14360750886734159999u64),
2981 "obs_target",
2982 )?,
2983 })
2984 }
2985 #[allow(unused_variables)]
2986 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
2987 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
2988 match field.hash {
2989 13993189934714533949u64 => Ok(self.old_mode.clone().into()),
2990 874641438558876942u64 => Ok(self.new_mode.clone().into()),
2991 14360750886734159999u64 => Ok(self.obs_target.clone().into()),
2992 _ => Err(ParseError::MissingGameEventValue {
2993 ty: "HLTVChangedMode",
2994 field: "todo".into(),
2995 }),
2996 }
2997 }
2998 #[allow(unused_variables)]
2999 fn write(
3000 &self,
3001 stream: &mut BitWriteStream<LittleEndian>,
3002 definition: &GameEventDefinition,
3003 ) -> Result<()> {
3004 for entry in &definition.entries {
3005 let value = self
3006 .get_field(entry)
3007 .unwrap_or_else(|_| entry.kind.default_value());
3008 stream.write(&value)?;
3009 }
3010 Ok(())
3011 }
3012}
3013#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3014#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3015pub struct HLTVChangedTargetEvent {
3016 pub mode: u16,
3017 pub old_target: u16,
3018 pub obs_target: u16,
3019}
3020impl HLTVChangedTargetEvent {
3021 #[allow(unused_variables)]
3022 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3023 Ok(HLTVChangedTargetEvent {
3024 mode: read_value::<u16>(stream, definition.get_entry(954177780379921842u64), "mode")?,
3025 old_target: read_value::<u16>(
3026 stream,
3027 definition.get_entry(16423341895021030510u64),
3028 "old_target",
3029 )?,
3030 obs_target: read_value::<u16>(
3031 stream,
3032 definition.get_entry(14360750886734159999u64),
3033 "obs_target",
3034 )?,
3035 })
3036 }
3037 #[allow(unused_variables)]
3038 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3039 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3040 match field.hash {
3041 954177780379921842u64 => Ok(self.mode.clone().into()),
3042 16423341895021030510u64 => Ok(self.old_target.clone().into()),
3043 14360750886734159999u64 => Ok(self.obs_target.clone().into()),
3044 _ => Err(ParseError::MissingGameEventValue {
3045 ty: "HLTVChangedTarget",
3046 field: "todo".into(),
3047 }),
3048 }
3049 }
3050 #[allow(unused_variables)]
3051 fn write(
3052 &self,
3053 stream: &mut BitWriteStream<LittleEndian>,
3054 definition: &GameEventDefinition,
3055 ) -> Result<()> {
3056 for entry in &definition.entries {
3057 let value = self
3058 .get_field(entry)
3059 .unwrap_or_else(|_| entry.kind.default_value());
3060 stream.write(&value)?;
3061 }
3062 Ok(())
3063 }
3064}
3065#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3066#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3067pub struct VoteEndedEvent {}
3068impl VoteEndedEvent {
3069 #[allow(unused_variables)]
3070 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3071 Ok(VoteEndedEvent {})
3072 }
3073 #[allow(unused_variables)]
3074 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3075 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3076 match field.hash {
3077 _ => Err(ParseError::MissingGameEventValue {
3078 ty: "VoteEnded",
3079 field: "todo".into(),
3080 }),
3081 }
3082 }
3083 #[allow(unused_variables)]
3084 fn write(
3085 &self,
3086 stream: &mut BitWriteStream<LittleEndian>,
3087 definition: &GameEventDefinition,
3088 ) -> Result<()> {
3089 for entry in &definition.entries {
3090 let value = self
3091 .get_field(entry)
3092 .unwrap_or_else(|_| entry.kind.default_value());
3093 stream.write(&value)?;
3094 }
3095 Ok(())
3096 }
3097}
3098#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3099#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3100pub struct VoteStartedEvent {
3101 pub issue: MaybeUtf8String,
3102 pub param_1: MaybeUtf8String,
3103 pub team: u8,
3104 pub initiator: u32,
3105 pub voteidx: u32,
3106}
3107impl VoteStartedEvent {
3108 #[allow(unused_variables)]
3109 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3110 Ok(VoteStartedEvent {
3111 issue: read_value::<MaybeUtf8String>(
3112 stream,
3113 definition.get_entry(2041490703516169504u64),
3114 "issue",
3115 )?,
3116 param_1: read_value::<MaybeUtf8String>(
3117 stream,
3118 definition.get_entry(4990490691588242105u64),
3119 "param_1",
3120 )?,
3121 team: read_value::<u8>(
3122 stream,
3123 definition.get_entry(18024489754618217260u64),
3124 "team",
3125 )?,
3126 initiator: read_value::<u32>(
3127 stream,
3128 definition.get_entry(7196121162372295066u64),
3129 "initiator",
3130 )?,
3131 voteidx: read_value::<u32>(
3132 stream,
3133 definition.get_entry(5777630607239142584u64),
3134 "voteidx",
3135 )?,
3136 })
3137 }
3138 #[allow(unused_variables)]
3139 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3140 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3141 match field.hash {
3142 2041490703516169504u64 => Ok(self.issue.clone().into()),
3143 4990490691588242105u64 => Ok(self.param_1.clone().into()),
3144 18024489754618217260u64 => Ok(self.team.clone().into()),
3145 7196121162372295066u64 => Ok(self.initiator.clone().into()),
3146 5777630607239142584u64 => Ok(self.voteidx.clone().into()),
3147 _ => Err(ParseError::MissingGameEventValue {
3148 ty: "VoteStarted",
3149 field: "todo".into(),
3150 }),
3151 }
3152 }
3153 #[allow(unused_variables)]
3154 fn write(
3155 &self,
3156 stream: &mut BitWriteStream<LittleEndian>,
3157 definition: &GameEventDefinition,
3158 ) -> Result<()> {
3159 for entry in &definition.entries {
3160 let value = self
3161 .get_field(entry)
3162 .unwrap_or_else(|_| entry.kind.default_value());
3163 stream.write(&value)?;
3164 }
3165 Ok(())
3166 }
3167}
3168#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3169#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3170pub struct VoteChangedEvent {
3171 pub vote_option_1: u8,
3172 pub vote_option_2: u8,
3173 pub vote_option_3: u8,
3174 pub vote_option_4: u8,
3175 pub vote_option_5: u8,
3176 pub potential_votes: u8,
3177 pub voteidx: u32,
3178}
3179impl VoteChangedEvent {
3180 #[allow(unused_variables)]
3181 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3182 Ok(VoteChangedEvent {
3183 vote_option_1: read_value::<u8>(
3184 stream,
3185 definition.get_entry(8259566198638570134u64),
3186 "vote_option_1",
3187 )?,
3188 vote_option_2: read_value::<u8>(
3189 stream,
3190 definition.get_entry(8259565099126941923u64),
3191 "vote_option_2",
3192 )?,
3193 vote_option_3: read_value::<u8>(
3194 stream,
3195 definition.get_entry(8259563999615313712u64),
3196 "vote_option_3",
3197 )?,
3198 vote_option_4: read_value::<u8>(
3199 stream,
3200 definition.get_entry(8259571696196711189u64),
3201 "vote_option_4",
3202 )?,
3203 vote_option_5: read_value::<u8>(
3204 stream,
3205 definition.get_entry(8259570596685082978u64),
3206 "vote_option_5",
3207 )?,
3208 potential_votes: read_value::<u8>(
3209 stream,
3210 definition.get_entry(18034020270891649474u64),
3211 "potential_votes",
3212 )?,
3213 voteidx: read_value::<u32>(
3214 stream,
3215 definition.get_entry(5777630607239142584u64),
3216 "voteidx",
3217 )?,
3218 })
3219 }
3220 #[allow(unused_variables)]
3221 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3222 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3223 match field.hash {
3224 8259566198638570134u64 => Ok(self.vote_option_1.clone().into()),
3225 8259565099126941923u64 => Ok(self.vote_option_2.clone().into()),
3226 8259563999615313712u64 => Ok(self.vote_option_3.clone().into()),
3227 8259571696196711189u64 => Ok(self.vote_option_4.clone().into()),
3228 8259570596685082978u64 => Ok(self.vote_option_5.clone().into()),
3229 18034020270891649474u64 => Ok(self.potential_votes.clone().into()),
3230 5777630607239142584u64 => Ok(self.voteidx.clone().into()),
3231 _ => Err(ParseError::MissingGameEventValue {
3232 ty: "VoteChanged",
3233 field: "todo".into(),
3234 }),
3235 }
3236 }
3237 #[allow(unused_variables)]
3238 fn write(
3239 &self,
3240 stream: &mut BitWriteStream<LittleEndian>,
3241 definition: &GameEventDefinition,
3242 ) -> Result<()> {
3243 for entry in &definition.entries {
3244 let value = self
3245 .get_field(entry)
3246 .unwrap_or_else(|_| entry.kind.default_value());
3247 stream.write(&value)?;
3248 }
3249 Ok(())
3250 }
3251}
3252#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3253#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3254pub struct VotePassedEvent {
3255 pub details: MaybeUtf8String,
3256 pub param_1: MaybeUtf8String,
3257 pub team: u8,
3258 pub voteidx: u32,
3259}
3260impl VotePassedEvent {
3261 #[allow(unused_variables)]
3262 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3263 Ok(VotePassedEvent {
3264 details: read_value::<MaybeUtf8String>(
3265 stream,
3266 definition.get_entry(13353550034922503269u64),
3267 "details",
3268 )?,
3269 param_1: read_value::<MaybeUtf8String>(
3270 stream,
3271 definition.get_entry(4990490691588242105u64),
3272 "param_1",
3273 )?,
3274 team: read_value::<u8>(
3275 stream,
3276 definition.get_entry(18024489754618217260u64),
3277 "team",
3278 )?,
3279 voteidx: read_value::<u32>(
3280 stream,
3281 definition.get_entry(5777630607239142584u64),
3282 "voteidx",
3283 )?,
3284 })
3285 }
3286 #[allow(unused_variables)]
3287 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3288 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3289 match field.hash {
3290 13353550034922503269u64 => Ok(self.details.clone().into()),
3291 4990490691588242105u64 => Ok(self.param_1.clone().into()),
3292 18024489754618217260u64 => Ok(self.team.clone().into()),
3293 5777630607239142584u64 => Ok(self.voteidx.clone().into()),
3294 _ => Err(ParseError::MissingGameEventValue {
3295 ty: "VotePassed",
3296 field: "todo".into(),
3297 }),
3298 }
3299 }
3300 #[allow(unused_variables)]
3301 fn write(
3302 &self,
3303 stream: &mut BitWriteStream<LittleEndian>,
3304 definition: &GameEventDefinition,
3305 ) -> Result<()> {
3306 for entry in &definition.entries {
3307 let value = self
3308 .get_field(entry)
3309 .unwrap_or_else(|_| entry.kind.default_value());
3310 stream.write(&value)?;
3311 }
3312 Ok(())
3313 }
3314}
3315#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3316#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3317pub struct VoteFailedEvent {
3318 pub team: u8,
3319 pub voteidx: u32,
3320}
3321impl VoteFailedEvent {
3322 #[allow(unused_variables)]
3323 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3324 Ok(VoteFailedEvent {
3325 team: read_value::<u8>(
3326 stream,
3327 definition.get_entry(18024489754618217260u64),
3328 "team",
3329 )?,
3330 voteidx: read_value::<u32>(
3331 stream,
3332 definition.get_entry(5777630607239142584u64),
3333 "voteidx",
3334 )?,
3335 })
3336 }
3337 #[allow(unused_variables)]
3338 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3339 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3340 match field.hash {
3341 18024489754618217260u64 => Ok(self.team.clone().into()),
3342 5777630607239142584u64 => Ok(self.voteidx.clone().into()),
3343 _ => Err(ParseError::MissingGameEventValue {
3344 ty: "VoteFailed",
3345 field: "todo".into(),
3346 }),
3347 }
3348 }
3349 #[allow(unused_variables)]
3350 fn write(
3351 &self,
3352 stream: &mut BitWriteStream<LittleEndian>,
3353 definition: &GameEventDefinition,
3354 ) -> Result<()> {
3355 for entry in &definition.entries {
3356 let value = self
3357 .get_field(entry)
3358 .unwrap_or_else(|_| entry.kind.default_value());
3359 stream.write(&value)?;
3360 }
3361 Ok(())
3362 }
3363}
3364#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3365#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3366pub struct VoteCastEvent {
3367 pub vote_option: u8,
3368 pub team: u16,
3369 pub entity_id: u32,
3370 pub voteidx: u32,
3371}
3372impl VoteCastEvent {
3373 #[allow(unused_variables)]
3374 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3375 Ok(VoteCastEvent {
3376 vote_option: read_value::<u8>(
3377 stream,
3378 definition.get_entry(17670279370117350435u64),
3379 "vote_option",
3380 )?,
3381 team: read_value::<u16>(
3382 stream,
3383 definition.get_entry(18024489754618217260u64),
3384 "team",
3385 )?,
3386 entity_id: read_value::<u32>(
3387 stream,
3388 definition.get_entry(2085882069322833143u64),
3389 "entity_id",
3390 )?,
3391 voteidx: read_value::<u32>(
3392 stream,
3393 definition.get_entry(5777630607239142584u64),
3394 "voteidx",
3395 )?,
3396 })
3397 }
3398 #[allow(unused_variables)]
3399 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3400 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3401 match field.hash {
3402 17670279370117350435u64 => Ok(self.vote_option.clone().into()),
3403 18024489754618217260u64 => Ok(self.team.clone().into()),
3404 2085882069322833143u64 => Ok(self.entity_id.clone().into()),
3405 5777630607239142584u64 => Ok(self.voteidx.clone().into()),
3406 _ => Err(ParseError::MissingGameEventValue {
3407 ty: "VoteCast",
3408 field: "todo".into(),
3409 }),
3410 }
3411 }
3412 #[allow(unused_variables)]
3413 fn write(
3414 &self,
3415 stream: &mut BitWriteStream<LittleEndian>,
3416 definition: &GameEventDefinition,
3417 ) -> Result<()> {
3418 for entry in &definition.entries {
3419 let value = self
3420 .get_field(entry)
3421 .unwrap_or_else(|_| entry.kind.default_value());
3422 stream.write(&value)?;
3423 }
3424 Ok(())
3425 }
3426}
3427#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3428#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3429pub struct VoteOptionsEvent {
3430 pub count: u8,
3431 pub option_1: MaybeUtf8String,
3432 pub option_2: MaybeUtf8String,
3433 pub option_3: MaybeUtf8String,
3434 pub option_4: MaybeUtf8String,
3435 pub option_5: MaybeUtf8String,
3436 pub voteidx: u32,
3437}
3438impl VoteOptionsEvent {
3439 #[allow(unused_variables)]
3440 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3441 Ok(VoteOptionsEvent {
3442 count: read_value::<u8>(
3443 stream,
3444 definition.get_entry(12818901015042040436u64),
3445 "count",
3446 )?,
3447 option_1: read_value::<MaybeUtf8String>(
3448 stream,
3449 definition.get_entry(14575392658851491999u64),
3450 "option_1",
3451 )?,
3452 option_2: read_value::<MaybeUtf8String>(
3453 stream,
3454 definition.get_entry(14575393758363120210u64),
3455 "option_2",
3456 )?,
3457 option_3: read_value::<MaybeUtf8String>(
3458 stream,
3459 definition.get_entry(14575394857874748421u64),
3460 "option_3",
3461 )?,
3462 option_4: read_value::<MaybeUtf8String>(
3463 stream,
3464 definition.get_entry(14575387161293350944u64),
3465 "option_4",
3466 )?,
3467 option_5: read_value::<MaybeUtf8String>(
3468 stream,
3469 definition.get_entry(14575388260804979155u64),
3470 "option_5",
3471 )?,
3472 voteidx: read_value::<u32>(
3473 stream,
3474 definition.get_entry(5777630607239142584u64),
3475 "voteidx",
3476 )?,
3477 })
3478 }
3479 #[allow(unused_variables)]
3480 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3481 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3482 match field.hash {
3483 12818901015042040436u64 => Ok(self.count.clone().into()),
3484 14575392658851491999u64 => Ok(self.option_1.clone().into()),
3485 14575393758363120210u64 => Ok(self.option_2.clone().into()),
3486 14575394857874748421u64 => Ok(self.option_3.clone().into()),
3487 14575387161293350944u64 => Ok(self.option_4.clone().into()),
3488 14575388260804979155u64 => Ok(self.option_5.clone().into()),
3489 5777630607239142584u64 => Ok(self.voteidx.clone().into()),
3490 _ => Err(ParseError::MissingGameEventValue {
3491 ty: "VoteOptions",
3492 field: "todo".into(),
3493 }),
3494 }
3495 }
3496 #[allow(unused_variables)]
3497 fn write(
3498 &self,
3499 stream: &mut BitWriteStream<LittleEndian>,
3500 definition: &GameEventDefinition,
3501 ) -> Result<()> {
3502 for entry in &definition.entries {
3503 let value = self
3504 .get_field(entry)
3505 .unwrap_or_else(|_| entry.kind.default_value());
3506 stream.write(&value)?;
3507 }
3508 Ok(())
3509 }
3510}
3511#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3512#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3513pub struct ReplaySavedEvent {}
3514impl ReplaySavedEvent {
3515 #[allow(unused_variables)]
3516 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3517 Ok(ReplaySavedEvent {})
3518 }
3519 #[allow(unused_variables)]
3520 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3521 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3522 match field.hash {
3523 _ => Err(ParseError::MissingGameEventValue {
3524 ty: "ReplaySaved",
3525 field: "todo".into(),
3526 }),
3527 }
3528 }
3529 #[allow(unused_variables)]
3530 fn write(
3531 &self,
3532 stream: &mut BitWriteStream<LittleEndian>,
3533 definition: &GameEventDefinition,
3534 ) -> Result<()> {
3535 for entry in &definition.entries {
3536 let value = self
3537 .get_field(entry)
3538 .unwrap_or_else(|_| entry.kind.default_value());
3539 stream.write(&value)?;
3540 }
3541 Ok(())
3542 }
3543}
3544#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3545#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3546pub struct EnteredPerformanceModeEvent {}
3547impl EnteredPerformanceModeEvent {
3548 #[allow(unused_variables)]
3549 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3550 Ok(EnteredPerformanceModeEvent {})
3551 }
3552 #[allow(unused_variables)]
3553 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3554 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3555 match field.hash {
3556 _ => Err(ParseError::MissingGameEventValue {
3557 ty: "EnteredPerformanceMode",
3558 field: "todo".into(),
3559 }),
3560 }
3561 }
3562 #[allow(unused_variables)]
3563 fn write(
3564 &self,
3565 stream: &mut BitWriteStream<LittleEndian>,
3566 definition: &GameEventDefinition,
3567 ) -> Result<()> {
3568 for entry in &definition.entries {
3569 let value = self
3570 .get_field(entry)
3571 .unwrap_or_else(|_| entry.kind.default_value());
3572 stream.write(&value)?;
3573 }
3574 Ok(())
3575 }
3576}
3577#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3578#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3579pub struct BrowseReplaysEvent {}
3580impl BrowseReplaysEvent {
3581 #[allow(unused_variables)]
3582 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3583 Ok(BrowseReplaysEvent {})
3584 }
3585 #[allow(unused_variables)]
3586 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3587 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3588 match field.hash {
3589 _ => Err(ParseError::MissingGameEventValue {
3590 ty: "BrowseReplays",
3591 field: "todo".into(),
3592 }),
3593 }
3594 }
3595 #[allow(unused_variables)]
3596 fn write(
3597 &self,
3598 stream: &mut BitWriteStream<LittleEndian>,
3599 definition: &GameEventDefinition,
3600 ) -> Result<()> {
3601 for entry in &definition.entries {
3602 let value = self
3603 .get_field(entry)
3604 .unwrap_or_else(|_| entry.kind.default_value());
3605 stream.write(&value)?;
3606 }
3607 Ok(())
3608 }
3609}
3610#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3611#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3612pub struct ReplayYoutubeStatsEvent {
3613 pub views: u32,
3614 pub likes: u32,
3615 pub favorited: u32,
3616}
3617impl ReplayYoutubeStatsEvent {
3618 #[allow(unused_variables)]
3619 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3620 Ok(ReplayYoutubeStatsEvent {
3621 views: read_value::<u32>(
3622 stream,
3623 definition.get_entry(14625097093024684817u64),
3624 "views",
3625 )?,
3626 likes: read_value::<u32>(
3627 stream,
3628 definition.get_entry(9804554822404214111u64),
3629 "likes",
3630 )?,
3631 favorited: read_value::<u32>(
3632 stream,
3633 definition.get_entry(2653817720246189003u64),
3634 "favorited",
3635 )?,
3636 })
3637 }
3638 #[allow(unused_variables)]
3639 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3640 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3641 match field.hash {
3642 14625097093024684817u64 => Ok(self.views.clone().into()),
3643 9804554822404214111u64 => Ok(self.likes.clone().into()),
3644 2653817720246189003u64 => Ok(self.favorited.clone().into()),
3645 _ => Err(ParseError::MissingGameEventValue {
3646 ty: "ReplayYoutubeStats",
3647 field: "todo".into(),
3648 }),
3649 }
3650 }
3651 #[allow(unused_variables)]
3652 fn write(
3653 &self,
3654 stream: &mut BitWriteStream<LittleEndian>,
3655 definition: &GameEventDefinition,
3656 ) -> Result<()> {
3657 for entry in &definition.entries {
3658 let value = self
3659 .get_field(entry)
3660 .unwrap_or_else(|_| entry.kind.default_value());
3661 stream.write(&value)?;
3662 }
3663 Ok(())
3664 }
3665}
3666#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3667#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3668pub struct InventoryUpdatedEvent {}
3669impl InventoryUpdatedEvent {
3670 #[allow(unused_variables)]
3671 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3672 Ok(InventoryUpdatedEvent {})
3673 }
3674 #[allow(unused_variables)]
3675 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3676 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3677 match field.hash {
3678 _ => Err(ParseError::MissingGameEventValue {
3679 ty: "InventoryUpdated",
3680 field: "todo".into(),
3681 }),
3682 }
3683 }
3684 #[allow(unused_variables)]
3685 fn write(
3686 &self,
3687 stream: &mut BitWriteStream<LittleEndian>,
3688 definition: &GameEventDefinition,
3689 ) -> Result<()> {
3690 for entry in &definition.entries {
3691 let value = self
3692 .get_field(entry)
3693 .unwrap_or_else(|_| entry.kind.default_value());
3694 stream.write(&value)?;
3695 }
3696 Ok(())
3697 }
3698}
3699#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3700#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3701pub struct CartUpdatedEvent {}
3702impl CartUpdatedEvent {
3703 #[allow(unused_variables)]
3704 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3705 Ok(CartUpdatedEvent {})
3706 }
3707 #[allow(unused_variables)]
3708 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3709 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3710 match field.hash {
3711 _ => Err(ParseError::MissingGameEventValue {
3712 ty: "CartUpdated",
3713 field: "todo".into(),
3714 }),
3715 }
3716 }
3717 #[allow(unused_variables)]
3718 fn write(
3719 &self,
3720 stream: &mut BitWriteStream<LittleEndian>,
3721 definition: &GameEventDefinition,
3722 ) -> Result<()> {
3723 for entry in &definition.entries {
3724 let value = self
3725 .get_field(entry)
3726 .unwrap_or_else(|_| entry.kind.default_value());
3727 stream.write(&value)?;
3728 }
3729 Ok(())
3730 }
3731}
3732#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3733#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3734pub struct StorePriceSheetUpdatedEvent {}
3735impl StorePriceSheetUpdatedEvent {
3736 #[allow(unused_variables)]
3737 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3738 Ok(StorePriceSheetUpdatedEvent {})
3739 }
3740 #[allow(unused_variables)]
3741 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3742 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3743 match field.hash {
3744 _ => Err(ParseError::MissingGameEventValue {
3745 ty: "StorePriceSheetUpdated",
3746 field: "todo".into(),
3747 }),
3748 }
3749 }
3750 #[allow(unused_variables)]
3751 fn write(
3752 &self,
3753 stream: &mut BitWriteStream<LittleEndian>,
3754 definition: &GameEventDefinition,
3755 ) -> Result<()> {
3756 for entry in &definition.entries {
3757 let value = self
3758 .get_field(entry)
3759 .unwrap_or_else(|_| entry.kind.default_value());
3760 stream.write(&value)?;
3761 }
3762 Ok(())
3763 }
3764}
3765#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3766#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3767pub struct EconInventoryConnectedEvent {}
3768impl EconInventoryConnectedEvent {
3769 #[allow(unused_variables)]
3770 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3771 Ok(EconInventoryConnectedEvent {})
3772 }
3773 #[allow(unused_variables)]
3774 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3775 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3776 match field.hash {
3777 _ => Err(ParseError::MissingGameEventValue {
3778 ty: "EconInventoryConnected",
3779 field: "todo".into(),
3780 }),
3781 }
3782 }
3783 #[allow(unused_variables)]
3784 fn write(
3785 &self,
3786 stream: &mut BitWriteStream<LittleEndian>,
3787 definition: &GameEventDefinition,
3788 ) -> Result<()> {
3789 for entry in &definition.entries {
3790 let value = self
3791 .get_field(entry)
3792 .unwrap_or_else(|_| entry.kind.default_value());
3793 stream.write(&value)?;
3794 }
3795 Ok(())
3796 }
3797}
3798#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3799#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3800pub struct ItemSchemaInitializedEvent {}
3801impl ItemSchemaInitializedEvent {
3802 #[allow(unused_variables)]
3803 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3804 Ok(ItemSchemaInitializedEvent {})
3805 }
3806 #[allow(unused_variables)]
3807 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3808 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3809 match field.hash {
3810 _ => Err(ParseError::MissingGameEventValue {
3811 ty: "ItemSchemaInitialized",
3812 field: "todo".into(),
3813 }),
3814 }
3815 }
3816 #[allow(unused_variables)]
3817 fn write(
3818 &self,
3819 stream: &mut BitWriteStream<LittleEndian>,
3820 definition: &GameEventDefinition,
3821 ) -> Result<()> {
3822 for entry in &definition.entries {
3823 let value = self
3824 .get_field(entry)
3825 .unwrap_or_else(|_| entry.kind.default_value());
3826 stream.write(&value)?;
3827 }
3828 Ok(())
3829 }
3830}
3831#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3832#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3833pub struct GcNewSessionEvent {}
3834impl GcNewSessionEvent {
3835 #[allow(unused_variables)]
3836 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3837 Ok(GcNewSessionEvent {})
3838 }
3839 #[allow(unused_variables)]
3840 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3841 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3842 match field.hash {
3843 _ => Err(ParseError::MissingGameEventValue {
3844 ty: "GcNewSession",
3845 field: "todo".into(),
3846 }),
3847 }
3848 }
3849 #[allow(unused_variables)]
3850 fn write(
3851 &self,
3852 stream: &mut BitWriteStream<LittleEndian>,
3853 definition: &GameEventDefinition,
3854 ) -> Result<()> {
3855 for entry in &definition.entries {
3856 let value = self
3857 .get_field(entry)
3858 .unwrap_or_else(|_| entry.kind.default_value());
3859 stream.write(&value)?;
3860 }
3861 Ok(())
3862 }
3863}
3864#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3865#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3866pub struct GcLostSessionEvent {}
3867impl GcLostSessionEvent {
3868 #[allow(unused_variables)]
3869 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3870 Ok(GcLostSessionEvent {})
3871 }
3872 #[allow(unused_variables)]
3873 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3874 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3875 match field.hash {
3876 _ => Err(ParseError::MissingGameEventValue {
3877 ty: "GcLostSession",
3878 field: "todo".into(),
3879 }),
3880 }
3881 }
3882 #[allow(unused_variables)]
3883 fn write(
3884 &self,
3885 stream: &mut BitWriteStream<LittleEndian>,
3886 definition: &GameEventDefinition,
3887 ) -> Result<()> {
3888 for entry in &definition.entries {
3889 let value = self
3890 .get_field(entry)
3891 .unwrap_or_else(|_| entry.kind.default_value());
3892 stream.write(&value)?;
3893 }
3894 Ok(())
3895 }
3896}
3897#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3898#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3899pub struct IntroFinishEvent {
3900 pub player: u16,
3901}
3902impl IntroFinishEvent {
3903 #[allow(unused_variables)]
3904 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3905 Ok(IntroFinishEvent {
3906 player: read_value::<u16>(
3907 stream,
3908 definition.get_entry(5008278420455340480u64),
3909 "player",
3910 )?,
3911 })
3912 }
3913 #[allow(unused_variables)]
3914 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3915 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3916 match field.hash {
3917 5008278420455340480u64 => Ok(self.player.clone().into()),
3918 _ => Err(ParseError::MissingGameEventValue {
3919 ty: "IntroFinish",
3920 field: "todo".into(),
3921 }),
3922 }
3923 }
3924 #[allow(unused_variables)]
3925 fn write(
3926 &self,
3927 stream: &mut BitWriteStream<LittleEndian>,
3928 definition: &GameEventDefinition,
3929 ) -> Result<()> {
3930 for entry in &definition.entries {
3931 let value = self
3932 .get_field(entry)
3933 .unwrap_or_else(|_| entry.kind.default_value());
3934 stream.write(&value)?;
3935 }
3936 Ok(())
3937 }
3938}
3939#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3940#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3941pub struct IntroNextCameraEvent {
3942 pub player: u16,
3943}
3944impl IntroNextCameraEvent {
3945 #[allow(unused_variables)]
3946 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3947 Ok(IntroNextCameraEvent {
3948 player: read_value::<u16>(
3949 stream,
3950 definition.get_entry(5008278420455340480u64),
3951 "player",
3952 )?,
3953 })
3954 }
3955 #[allow(unused_variables)]
3956 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
3957 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
3958 match field.hash {
3959 5008278420455340480u64 => Ok(self.player.clone().into()),
3960 _ => Err(ParseError::MissingGameEventValue {
3961 ty: "IntroNextCamera",
3962 field: "todo".into(),
3963 }),
3964 }
3965 }
3966 #[allow(unused_variables)]
3967 fn write(
3968 &self,
3969 stream: &mut BitWriteStream<LittleEndian>,
3970 definition: &GameEventDefinition,
3971 ) -> Result<()> {
3972 for entry in &definition.entries {
3973 let value = self
3974 .get_field(entry)
3975 .unwrap_or_else(|_| entry.kind.default_value());
3976 stream.write(&value)?;
3977 }
3978 Ok(())
3979 }
3980}
3981#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
3982#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
3983pub struct PlayerChangeClassEvent {
3984 pub user_id: u16,
3985 pub class: u16,
3986}
3987impl PlayerChangeClassEvent {
3988 #[allow(unused_variables)]
3989 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
3990 Ok(PlayerChangeClassEvent {
3991 user_id: read_value::<u16>(
3992 stream,
3993 definition.get_entry(17826443226371159423u64),
3994 "user_id",
3995 )?,
3996 class: read_value::<u16>(
3997 stream,
3998 definition.get_entry(15066323702654938015u64),
3999 "class",
4000 )?,
4001 })
4002 }
4003 #[allow(unused_variables)]
4004 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4005 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4006 match field.hash {
4007 17826443226371159423u64 => Ok(self.user_id.clone().into()),
4008 15066323702654938015u64 => Ok(self.class.clone().into()),
4009 _ => Err(ParseError::MissingGameEventValue {
4010 ty: "PlayerChangeClass",
4011 field: "todo".into(),
4012 }),
4013 }
4014 }
4015 #[allow(unused_variables)]
4016 fn write(
4017 &self,
4018 stream: &mut BitWriteStream<LittleEndian>,
4019 definition: &GameEventDefinition,
4020 ) -> Result<()> {
4021 for entry in &definition.entries {
4022 let value = self
4023 .get_field(entry)
4024 .unwrap_or_else(|_| entry.kind.default_value());
4025 stream.write(&value)?;
4026 }
4027 Ok(())
4028 }
4029}
4030#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4031#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4032pub struct TfMapTimeRemainingEvent {
4033 pub seconds: u32,
4034}
4035impl TfMapTimeRemainingEvent {
4036 #[allow(unused_variables)]
4037 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4038 Ok(TfMapTimeRemainingEvent {
4039 seconds: read_value::<u32>(
4040 stream,
4041 definition.get_entry(11456985514702388746u64),
4042 "seconds",
4043 )?,
4044 })
4045 }
4046 #[allow(unused_variables)]
4047 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4048 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4049 match field.hash {
4050 11456985514702388746u64 => Ok(self.seconds.clone().into()),
4051 _ => Err(ParseError::MissingGameEventValue {
4052 ty: "TfMapTimeRemaining",
4053 field: "todo".into(),
4054 }),
4055 }
4056 }
4057 #[allow(unused_variables)]
4058 fn write(
4059 &self,
4060 stream: &mut BitWriteStream<LittleEndian>,
4061 definition: &GameEventDefinition,
4062 ) -> Result<()> {
4063 for entry in &definition.entries {
4064 let value = self
4065 .get_field(entry)
4066 .unwrap_or_else(|_| entry.kind.default_value());
4067 stream.write(&value)?;
4068 }
4069 Ok(())
4070 }
4071}
4072#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4073#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4074pub struct TfGameOverEvent {
4075 pub reason: MaybeUtf8String,
4076}
4077impl TfGameOverEvent {
4078 #[allow(unused_variables)]
4079 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4080 Ok(TfGameOverEvent {
4081 reason: read_value::<MaybeUtf8String>(
4082 stream,
4083 definition.get_entry(7343356632300987961u64),
4084 "reason",
4085 )?,
4086 })
4087 }
4088 #[allow(unused_variables)]
4089 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4090 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4091 match field.hash {
4092 7343356632300987961u64 => Ok(self.reason.clone().into()),
4093 _ => Err(ParseError::MissingGameEventValue {
4094 ty: "TfGameOver",
4095 field: "todo".into(),
4096 }),
4097 }
4098 }
4099 #[allow(unused_variables)]
4100 fn write(
4101 &self,
4102 stream: &mut BitWriteStream<LittleEndian>,
4103 definition: &GameEventDefinition,
4104 ) -> Result<()> {
4105 for entry in &definition.entries {
4106 let value = self
4107 .get_field(entry)
4108 .unwrap_or_else(|_| entry.kind.default_value());
4109 stream.write(&value)?;
4110 }
4111 Ok(())
4112 }
4113}
4114#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4115#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4116pub struct CtfFlagCapturedEvent {
4117 pub capping_team: u16,
4118 pub capping_team_score: u16,
4119}
4120impl CtfFlagCapturedEvent {
4121 #[allow(unused_variables)]
4122 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4123 Ok(CtfFlagCapturedEvent {
4124 capping_team: read_value::<u16>(
4125 stream,
4126 definition.get_entry(14568126206963925545u64),
4127 "capping_team",
4128 )?,
4129 capping_team_score: read_value::<u16>(
4130 stream,
4131 definition.get_entry(4559517251391003144u64),
4132 "capping_team_score",
4133 )?,
4134 })
4135 }
4136 #[allow(unused_variables)]
4137 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4138 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4139 match field.hash {
4140 14568126206963925545u64 => Ok(self.capping_team.clone().into()),
4141 4559517251391003144u64 => Ok(self.capping_team_score.clone().into()),
4142 _ => Err(ParseError::MissingGameEventValue {
4143 ty: "CtfFlagCaptured",
4144 field: "todo".into(),
4145 }),
4146 }
4147 }
4148 #[allow(unused_variables)]
4149 fn write(
4150 &self,
4151 stream: &mut BitWriteStream<LittleEndian>,
4152 definition: &GameEventDefinition,
4153 ) -> Result<()> {
4154 for entry in &definition.entries {
4155 let value = self
4156 .get_field(entry)
4157 .unwrap_or_else(|_| entry.kind.default_value());
4158 stream.write(&value)?;
4159 }
4160 Ok(())
4161 }
4162}
4163#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4164#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4165pub struct ControlPointInitializedEvent {}
4166impl ControlPointInitializedEvent {
4167 #[allow(unused_variables)]
4168 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4169 Ok(ControlPointInitializedEvent {})
4170 }
4171 #[allow(unused_variables)]
4172 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4173 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4174 match field.hash {
4175 _ => Err(ParseError::MissingGameEventValue {
4176 ty: "ControlPointInitialized",
4177 field: "todo".into(),
4178 }),
4179 }
4180 }
4181 #[allow(unused_variables)]
4182 fn write(
4183 &self,
4184 stream: &mut BitWriteStream<LittleEndian>,
4185 definition: &GameEventDefinition,
4186 ) -> Result<()> {
4187 for entry in &definition.entries {
4188 let value = self
4189 .get_field(entry)
4190 .unwrap_or_else(|_| entry.kind.default_value());
4191 stream.write(&value)?;
4192 }
4193 Ok(())
4194 }
4195}
4196#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4197#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4198pub struct ControlPointUpdateImagesEvent {
4199 pub index: u16,
4200}
4201impl ControlPointUpdateImagesEvent {
4202 #[allow(unused_variables)]
4203 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4204 Ok(ControlPointUpdateImagesEvent {
4205 index: read_value::<u16>(
4206 stream,
4207 definition.get_entry(9497966886403524235u64),
4208 "index",
4209 )?,
4210 })
4211 }
4212 #[allow(unused_variables)]
4213 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4214 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4215 match field.hash {
4216 9497966886403524235u64 => Ok(self.index.clone().into()),
4217 _ => Err(ParseError::MissingGameEventValue {
4218 ty: "ControlPointUpdateImages",
4219 field: "todo".into(),
4220 }),
4221 }
4222 }
4223 #[allow(unused_variables)]
4224 fn write(
4225 &self,
4226 stream: &mut BitWriteStream<LittleEndian>,
4227 definition: &GameEventDefinition,
4228 ) -> Result<()> {
4229 for entry in &definition.entries {
4230 let value = self
4231 .get_field(entry)
4232 .unwrap_or_else(|_| entry.kind.default_value());
4233 stream.write(&value)?;
4234 }
4235 Ok(())
4236 }
4237}
4238#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4239#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4240pub struct ControlPointUpdateLayoutEvent {
4241 pub index: u16,
4242}
4243impl ControlPointUpdateLayoutEvent {
4244 #[allow(unused_variables)]
4245 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4246 Ok(ControlPointUpdateLayoutEvent {
4247 index: read_value::<u16>(
4248 stream,
4249 definition.get_entry(9497966886403524235u64),
4250 "index",
4251 )?,
4252 })
4253 }
4254 #[allow(unused_variables)]
4255 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4256 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4257 match field.hash {
4258 9497966886403524235u64 => Ok(self.index.clone().into()),
4259 _ => Err(ParseError::MissingGameEventValue {
4260 ty: "ControlPointUpdateLayout",
4261 field: "todo".into(),
4262 }),
4263 }
4264 }
4265 #[allow(unused_variables)]
4266 fn write(
4267 &self,
4268 stream: &mut BitWriteStream<LittleEndian>,
4269 definition: &GameEventDefinition,
4270 ) -> Result<()> {
4271 for entry in &definition.entries {
4272 let value = self
4273 .get_field(entry)
4274 .unwrap_or_else(|_| entry.kind.default_value());
4275 stream.write(&value)?;
4276 }
4277 Ok(())
4278 }
4279}
4280#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4281#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4282pub struct ControlPointUpdateCappingEvent {
4283 pub index: u16,
4284}
4285impl ControlPointUpdateCappingEvent {
4286 #[allow(unused_variables)]
4287 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4288 Ok(ControlPointUpdateCappingEvent {
4289 index: read_value::<u16>(
4290 stream,
4291 definition.get_entry(9497966886403524235u64),
4292 "index",
4293 )?,
4294 })
4295 }
4296 #[allow(unused_variables)]
4297 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4298 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4299 match field.hash {
4300 9497966886403524235u64 => Ok(self.index.clone().into()),
4301 _ => Err(ParseError::MissingGameEventValue {
4302 ty: "ControlPointUpdateCapping",
4303 field: "todo".into(),
4304 }),
4305 }
4306 }
4307 #[allow(unused_variables)]
4308 fn write(
4309 &self,
4310 stream: &mut BitWriteStream<LittleEndian>,
4311 definition: &GameEventDefinition,
4312 ) -> Result<()> {
4313 for entry in &definition.entries {
4314 let value = self
4315 .get_field(entry)
4316 .unwrap_or_else(|_| entry.kind.default_value());
4317 stream.write(&value)?;
4318 }
4319 Ok(())
4320 }
4321}
4322#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4323#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4324pub struct ControlPointUpdateOwnerEvent {
4325 pub index: u16,
4326}
4327impl ControlPointUpdateOwnerEvent {
4328 #[allow(unused_variables)]
4329 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4330 Ok(ControlPointUpdateOwnerEvent {
4331 index: read_value::<u16>(
4332 stream,
4333 definition.get_entry(9497966886403524235u64),
4334 "index",
4335 )?,
4336 })
4337 }
4338 #[allow(unused_variables)]
4339 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4340 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4341 match field.hash {
4342 9497966886403524235u64 => Ok(self.index.clone().into()),
4343 _ => Err(ParseError::MissingGameEventValue {
4344 ty: "ControlPointUpdateOwner",
4345 field: "todo".into(),
4346 }),
4347 }
4348 }
4349 #[allow(unused_variables)]
4350 fn write(
4351 &self,
4352 stream: &mut BitWriteStream<LittleEndian>,
4353 definition: &GameEventDefinition,
4354 ) -> Result<()> {
4355 for entry in &definition.entries {
4356 let value = self
4357 .get_field(entry)
4358 .unwrap_or_else(|_| entry.kind.default_value());
4359 stream.write(&value)?;
4360 }
4361 Ok(())
4362 }
4363}
4364#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4365#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4366pub struct ControlPointStartTouchEvent {
4367 pub player: u16,
4368 pub area: u16,
4369}
4370impl ControlPointStartTouchEvent {
4371 #[allow(unused_variables)]
4372 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4373 Ok(ControlPointStartTouchEvent {
4374 player: read_value::<u16>(
4375 stream,
4376 definition.get_entry(5008278420455340480u64),
4377 "player",
4378 )?,
4379 area: read_value::<u16>(stream, definition.get_entry(9894459526856489156u64), "area")?,
4380 })
4381 }
4382 #[allow(unused_variables)]
4383 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4384 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4385 match field.hash {
4386 5008278420455340480u64 => Ok(self.player.clone().into()),
4387 9894459526856489156u64 => Ok(self.area.clone().into()),
4388 _ => Err(ParseError::MissingGameEventValue {
4389 ty: "ControlPointStartTouch",
4390 field: "todo".into(),
4391 }),
4392 }
4393 }
4394 #[allow(unused_variables)]
4395 fn write(
4396 &self,
4397 stream: &mut BitWriteStream<LittleEndian>,
4398 definition: &GameEventDefinition,
4399 ) -> Result<()> {
4400 for entry in &definition.entries {
4401 let value = self
4402 .get_field(entry)
4403 .unwrap_or_else(|_| entry.kind.default_value());
4404 stream.write(&value)?;
4405 }
4406 Ok(())
4407 }
4408}
4409#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4410#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4411pub struct ControlPointEndTouchEvent {
4412 pub player: u16,
4413 pub area: u16,
4414}
4415impl ControlPointEndTouchEvent {
4416 #[allow(unused_variables)]
4417 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4418 Ok(ControlPointEndTouchEvent {
4419 player: read_value::<u16>(
4420 stream,
4421 definition.get_entry(5008278420455340480u64),
4422 "player",
4423 )?,
4424 area: read_value::<u16>(stream, definition.get_entry(9894459526856489156u64), "area")?,
4425 })
4426 }
4427 #[allow(unused_variables)]
4428 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4429 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4430 match field.hash {
4431 5008278420455340480u64 => Ok(self.player.clone().into()),
4432 9894459526856489156u64 => Ok(self.area.clone().into()),
4433 _ => Err(ParseError::MissingGameEventValue {
4434 ty: "ControlPointEndTouch",
4435 field: "todo".into(),
4436 }),
4437 }
4438 }
4439 #[allow(unused_variables)]
4440 fn write(
4441 &self,
4442 stream: &mut BitWriteStream<LittleEndian>,
4443 definition: &GameEventDefinition,
4444 ) -> Result<()> {
4445 for entry in &definition.entries {
4446 let value = self
4447 .get_field(entry)
4448 .unwrap_or_else(|_| entry.kind.default_value());
4449 stream.write(&value)?;
4450 }
4451 Ok(())
4452 }
4453}
4454#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4455#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4456pub struct ControlPointPulseElementEvent {
4457 pub player: u16,
4458}
4459impl ControlPointPulseElementEvent {
4460 #[allow(unused_variables)]
4461 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4462 Ok(ControlPointPulseElementEvent {
4463 player: read_value::<u16>(
4464 stream,
4465 definition.get_entry(5008278420455340480u64),
4466 "player",
4467 )?,
4468 })
4469 }
4470 #[allow(unused_variables)]
4471 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4472 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4473 match field.hash {
4474 5008278420455340480u64 => Ok(self.player.clone().into()),
4475 _ => Err(ParseError::MissingGameEventValue {
4476 ty: "ControlPointPulseElement",
4477 field: "todo".into(),
4478 }),
4479 }
4480 }
4481 #[allow(unused_variables)]
4482 fn write(
4483 &self,
4484 stream: &mut BitWriteStream<LittleEndian>,
4485 definition: &GameEventDefinition,
4486 ) -> Result<()> {
4487 for entry in &definition.entries {
4488 let value = self
4489 .get_field(entry)
4490 .unwrap_or_else(|_| entry.kind.default_value());
4491 stream.write(&value)?;
4492 }
4493 Ok(())
4494 }
4495}
4496#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4497#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4498pub struct ControlPointFakeCaptureEvent {
4499 pub player: u16,
4500 pub int_data: u16,
4501}
4502impl ControlPointFakeCaptureEvent {
4503 #[allow(unused_variables)]
4504 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4505 Ok(ControlPointFakeCaptureEvent {
4506 player: read_value::<u16>(
4507 stream,
4508 definition.get_entry(5008278420455340480u64),
4509 "player",
4510 )?,
4511 int_data: read_value::<u16>(
4512 stream,
4513 definition.get_entry(17655270944800390939u64),
4514 "int_data",
4515 )?,
4516 })
4517 }
4518 #[allow(unused_variables)]
4519 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4520 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4521 match field.hash {
4522 5008278420455340480u64 => Ok(self.player.clone().into()),
4523 17655270944800390939u64 => Ok(self.int_data.clone().into()),
4524 _ => Err(ParseError::MissingGameEventValue {
4525 ty: "ControlPointFakeCapture",
4526 field: "todo".into(),
4527 }),
4528 }
4529 }
4530 #[allow(unused_variables)]
4531 fn write(
4532 &self,
4533 stream: &mut BitWriteStream<LittleEndian>,
4534 definition: &GameEventDefinition,
4535 ) -> Result<()> {
4536 for entry in &definition.entries {
4537 let value = self
4538 .get_field(entry)
4539 .unwrap_or_else(|_| entry.kind.default_value());
4540 stream.write(&value)?;
4541 }
4542 Ok(())
4543 }
4544}
4545#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4546#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4547pub struct ControlPointFakeCaptureMultiplierEvent {
4548 pub player: u16,
4549 pub int_data: u16,
4550}
4551impl ControlPointFakeCaptureMultiplierEvent {
4552 #[allow(unused_variables)]
4553 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4554 Ok(ControlPointFakeCaptureMultiplierEvent {
4555 player: read_value::<u16>(
4556 stream,
4557 definition.get_entry(5008278420455340480u64),
4558 "player",
4559 )?,
4560 int_data: read_value::<u16>(
4561 stream,
4562 definition.get_entry(17655270944800390939u64),
4563 "int_data",
4564 )?,
4565 })
4566 }
4567 #[allow(unused_variables)]
4568 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4569 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4570 match field.hash {
4571 5008278420455340480u64 => Ok(self.player.clone().into()),
4572 17655270944800390939u64 => Ok(self.int_data.clone().into()),
4573 _ => Err(ParseError::MissingGameEventValue {
4574 ty: "ControlPointFakeCaptureMultiplier",
4575 field: "todo".into(),
4576 }),
4577 }
4578 }
4579 #[allow(unused_variables)]
4580 fn write(
4581 &self,
4582 stream: &mut BitWriteStream<LittleEndian>,
4583 definition: &GameEventDefinition,
4584 ) -> Result<()> {
4585 for entry in &definition.entries {
4586 let value = self
4587 .get_field(entry)
4588 .unwrap_or_else(|_| entry.kind.default_value());
4589 stream.write(&value)?;
4590 }
4591 Ok(())
4592 }
4593}
4594#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4595#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4596pub struct TeamPlayRoundSelectedEvent {
4597 pub round: MaybeUtf8String,
4598}
4599impl TeamPlayRoundSelectedEvent {
4600 #[allow(unused_variables)]
4601 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4602 Ok(TeamPlayRoundSelectedEvent {
4603 round: read_value::<MaybeUtf8String>(
4604 stream,
4605 definition.get_entry(3536478298987656219u64),
4606 "round",
4607 )?,
4608 })
4609 }
4610 #[allow(unused_variables)]
4611 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4612 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4613 match field.hash {
4614 3536478298987656219u64 => Ok(self.round.clone().into()),
4615 _ => Err(ParseError::MissingGameEventValue {
4616 ty: "TeamPlayRoundSelected",
4617 field: "todo".into(),
4618 }),
4619 }
4620 }
4621 #[allow(unused_variables)]
4622 fn write(
4623 &self,
4624 stream: &mut BitWriteStream<LittleEndian>,
4625 definition: &GameEventDefinition,
4626 ) -> Result<()> {
4627 for entry in &definition.entries {
4628 let value = self
4629 .get_field(entry)
4630 .unwrap_or_else(|_| entry.kind.default_value());
4631 stream.write(&value)?;
4632 }
4633 Ok(())
4634 }
4635}
4636#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4637#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4638pub struct TeamPlayRoundStartEvent {
4639 pub full_reset: bool,
4640}
4641impl TeamPlayRoundStartEvent {
4642 #[allow(unused_variables)]
4643 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4644 Ok(TeamPlayRoundStartEvent {
4645 full_reset: read_value::<bool>(
4646 stream,
4647 definition.get_entry(5520647792095461940u64),
4648 "full_reset",
4649 )?,
4650 })
4651 }
4652 #[allow(unused_variables)]
4653 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4654 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4655 match field.hash {
4656 5520647792095461940u64 => Ok(self.full_reset.clone().into()),
4657 _ => Err(ParseError::MissingGameEventValue {
4658 ty: "TeamPlayRoundStart",
4659 field: "todo".into(),
4660 }),
4661 }
4662 }
4663 #[allow(unused_variables)]
4664 fn write(
4665 &self,
4666 stream: &mut BitWriteStream<LittleEndian>,
4667 definition: &GameEventDefinition,
4668 ) -> Result<()> {
4669 for entry in &definition.entries {
4670 let value = self
4671 .get_field(entry)
4672 .unwrap_or_else(|_| entry.kind.default_value());
4673 stream.write(&value)?;
4674 }
4675 Ok(())
4676 }
4677}
4678#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4679#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4680pub struct TeamPlayRoundActiveEvent {}
4681impl TeamPlayRoundActiveEvent {
4682 #[allow(unused_variables)]
4683 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4684 Ok(TeamPlayRoundActiveEvent {})
4685 }
4686 #[allow(unused_variables)]
4687 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4688 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4689 match field.hash {
4690 _ => Err(ParseError::MissingGameEventValue {
4691 ty: "TeamPlayRoundActive",
4692 field: "todo".into(),
4693 }),
4694 }
4695 }
4696 #[allow(unused_variables)]
4697 fn write(
4698 &self,
4699 stream: &mut BitWriteStream<LittleEndian>,
4700 definition: &GameEventDefinition,
4701 ) -> Result<()> {
4702 for entry in &definition.entries {
4703 let value = self
4704 .get_field(entry)
4705 .unwrap_or_else(|_| entry.kind.default_value());
4706 stream.write(&value)?;
4707 }
4708 Ok(())
4709 }
4710}
4711#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4712#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4713pub struct TeamPlayWaitingBeginsEvent {}
4714impl TeamPlayWaitingBeginsEvent {
4715 #[allow(unused_variables)]
4716 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4717 Ok(TeamPlayWaitingBeginsEvent {})
4718 }
4719 #[allow(unused_variables)]
4720 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4721 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4722 match field.hash {
4723 _ => Err(ParseError::MissingGameEventValue {
4724 ty: "TeamPlayWaitingBegins",
4725 field: "todo".into(),
4726 }),
4727 }
4728 }
4729 #[allow(unused_variables)]
4730 fn write(
4731 &self,
4732 stream: &mut BitWriteStream<LittleEndian>,
4733 definition: &GameEventDefinition,
4734 ) -> Result<()> {
4735 for entry in &definition.entries {
4736 let value = self
4737 .get_field(entry)
4738 .unwrap_or_else(|_| entry.kind.default_value());
4739 stream.write(&value)?;
4740 }
4741 Ok(())
4742 }
4743}
4744#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4745#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4746pub struct TeamPlayWaitingEndsEvent {}
4747impl TeamPlayWaitingEndsEvent {
4748 #[allow(unused_variables)]
4749 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4750 Ok(TeamPlayWaitingEndsEvent {})
4751 }
4752 #[allow(unused_variables)]
4753 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4754 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4755 match field.hash {
4756 _ => Err(ParseError::MissingGameEventValue {
4757 ty: "TeamPlayWaitingEnds",
4758 field: "todo".into(),
4759 }),
4760 }
4761 }
4762 #[allow(unused_variables)]
4763 fn write(
4764 &self,
4765 stream: &mut BitWriteStream<LittleEndian>,
4766 definition: &GameEventDefinition,
4767 ) -> Result<()> {
4768 for entry in &definition.entries {
4769 let value = self
4770 .get_field(entry)
4771 .unwrap_or_else(|_| entry.kind.default_value());
4772 stream.write(&value)?;
4773 }
4774 Ok(())
4775 }
4776}
4777#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4778#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4779pub struct TeamPlayWaitingAboutToEndEvent {}
4780impl TeamPlayWaitingAboutToEndEvent {
4781 #[allow(unused_variables)]
4782 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4783 Ok(TeamPlayWaitingAboutToEndEvent {})
4784 }
4785 #[allow(unused_variables)]
4786 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4787 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4788 match field.hash {
4789 _ => Err(ParseError::MissingGameEventValue {
4790 ty: "TeamPlayWaitingAboutToEnd",
4791 field: "todo".into(),
4792 }),
4793 }
4794 }
4795 #[allow(unused_variables)]
4796 fn write(
4797 &self,
4798 stream: &mut BitWriteStream<LittleEndian>,
4799 definition: &GameEventDefinition,
4800 ) -> Result<()> {
4801 for entry in &definition.entries {
4802 let value = self
4803 .get_field(entry)
4804 .unwrap_or_else(|_| entry.kind.default_value());
4805 stream.write(&value)?;
4806 }
4807 Ok(())
4808 }
4809}
4810#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4811#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4812pub struct TeamPlayRestartRoundEvent {}
4813impl TeamPlayRestartRoundEvent {
4814 #[allow(unused_variables)]
4815 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4816 Ok(TeamPlayRestartRoundEvent {})
4817 }
4818 #[allow(unused_variables)]
4819 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4820 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4821 match field.hash {
4822 _ => Err(ParseError::MissingGameEventValue {
4823 ty: "TeamPlayRestartRound",
4824 field: "todo".into(),
4825 }),
4826 }
4827 }
4828 #[allow(unused_variables)]
4829 fn write(
4830 &self,
4831 stream: &mut BitWriteStream<LittleEndian>,
4832 definition: &GameEventDefinition,
4833 ) -> Result<()> {
4834 for entry in &definition.entries {
4835 let value = self
4836 .get_field(entry)
4837 .unwrap_or_else(|_| entry.kind.default_value());
4838 stream.write(&value)?;
4839 }
4840 Ok(())
4841 }
4842}
4843#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4844#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4845pub struct TeamPlayReadyRestartEvent {}
4846impl TeamPlayReadyRestartEvent {
4847 #[allow(unused_variables)]
4848 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4849 Ok(TeamPlayReadyRestartEvent {})
4850 }
4851 #[allow(unused_variables)]
4852 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4853 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4854 match field.hash {
4855 _ => Err(ParseError::MissingGameEventValue {
4856 ty: "TeamPlayReadyRestart",
4857 field: "todo".into(),
4858 }),
4859 }
4860 }
4861 #[allow(unused_variables)]
4862 fn write(
4863 &self,
4864 stream: &mut BitWriteStream<LittleEndian>,
4865 definition: &GameEventDefinition,
4866 ) -> Result<()> {
4867 for entry in &definition.entries {
4868 let value = self
4869 .get_field(entry)
4870 .unwrap_or_else(|_| entry.kind.default_value());
4871 stream.write(&value)?;
4872 }
4873 Ok(())
4874 }
4875}
4876#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4877#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4878pub struct TeamPlayRoundRestartSecondsEvent {
4879 pub seconds: u16,
4880}
4881impl TeamPlayRoundRestartSecondsEvent {
4882 #[allow(unused_variables)]
4883 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4884 Ok(TeamPlayRoundRestartSecondsEvent {
4885 seconds: read_value::<u16>(
4886 stream,
4887 definition.get_entry(11456985514702388746u64),
4888 "seconds",
4889 )?,
4890 })
4891 }
4892 #[allow(unused_variables)]
4893 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4894 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4895 match field.hash {
4896 11456985514702388746u64 => Ok(self.seconds.clone().into()),
4897 _ => Err(ParseError::MissingGameEventValue {
4898 ty: "TeamPlayRoundRestartSeconds",
4899 field: "todo".into(),
4900 }),
4901 }
4902 }
4903 #[allow(unused_variables)]
4904 fn write(
4905 &self,
4906 stream: &mut BitWriteStream<LittleEndian>,
4907 definition: &GameEventDefinition,
4908 ) -> Result<()> {
4909 for entry in &definition.entries {
4910 let value = self
4911 .get_field(entry)
4912 .unwrap_or_else(|_| entry.kind.default_value());
4913 stream.write(&value)?;
4914 }
4915 Ok(())
4916 }
4917}
4918#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4919#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4920pub struct TeamPlayTeamReadyEvent {
4921 pub team: u8,
4922}
4923impl TeamPlayTeamReadyEvent {
4924 #[allow(unused_variables)]
4925 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4926 Ok(TeamPlayTeamReadyEvent {
4927 team: read_value::<u8>(
4928 stream,
4929 definition.get_entry(18024489754618217260u64),
4930 "team",
4931 )?,
4932 })
4933 }
4934 #[allow(unused_variables)]
4935 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
4936 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
4937 match field.hash {
4938 18024489754618217260u64 => Ok(self.team.clone().into()),
4939 _ => Err(ParseError::MissingGameEventValue {
4940 ty: "TeamPlayTeamReady",
4941 field: "todo".into(),
4942 }),
4943 }
4944 }
4945 #[allow(unused_variables)]
4946 fn write(
4947 &self,
4948 stream: &mut BitWriteStream<LittleEndian>,
4949 definition: &GameEventDefinition,
4950 ) -> Result<()> {
4951 for entry in &definition.entries {
4952 let value = self
4953 .get_field(entry)
4954 .unwrap_or_else(|_| entry.kind.default_value());
4955 stream.write(&value)?;
4956 }
4957 Ok(())
4958 }
4959}
4960#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
4961#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
4962pub struct TeamPlayRoundWinEvent {
4963 pub team: u8,
4964 pub win_reason: u8,
4965 pub flag_cap_limit: u16,
4966 pub full_round: u16,
4967 pub round_time: f32,
4968 pub losing_team_num_caps: u16,
4969 pub was_sudden_death: u8,
4970}
4971impl TeamPlayRoundWinEvent {
4972 #[allow(unused_variables)]
4973 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
4974 Ok(TeamPlayRoundWinEvent {
4975 team: read_value::<u8>(
4976 stream,
4977 definition.get_entry(18024489754618217260u64),
4978 "team",
4979 )?,
4980 win_reason: read_value::<u8>(
4981 stream,
4982 definition.get_entry(3803421146477351589u64),
4983 "win_reason",
4984 )?,
4985 flag_cap_limit: read_value::<u16>(
4986 stream,
4987 definition.get_entry(8774624256288798788u64),
4988 "flag_cap_limit",
4989 )?,
4990 full_round: read_value::<u16>(
4991 stream,
4992 definition.get_entry(11360866888973275703u64),
4993 "full_round",
4994 )?,
4995 round_time: read_value::<f32>(
4996 stream,
4997 definition.get_entry(17889722153966279533u64),
4998 "round_time",
4999 )?,
5000 losing_team_num_caps: read_value::<u16>(
5001 stream,
5002 definition.get_entry(1136537408317314454u64),
5003 "losing_team_num_caps",
5004 )?,
5005 was_sudden_death: read_value::<u8>(
5006 stream,
5007 definition.get_entry(16618607837222165313u64),
5008 "was_sudden_death",
5009 )?,
5010 })
5011 }
5012 #[allow(unused_variables)]
5013 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5014 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5015 match field.hash {
5016 18024489754618217260u64 => Ok(self.team.clone().into()),
5017 3803421146477351589u64 => Ok(self.win_reason.clone().into()),
5018 8774624256288798788u64 => Ok(self.flag_cap_limit.clone().into()),
5019 11360866888973275703u64 => Ok(self.full_round.clone().into()),
5020 17889722153966279533u64 => Ok(self.round_time.clone().into()),
5021 1136537408317314454u64 => Ok(self.losing_team_num_caps.clone().into()),
5022 16618607837222165313u64 => Ok(self.was_sudden_death.clone().into()),
5023 _ => Err(ParseError::MissingGameEventValue {
5024 ty: "TeamPlayRoundWin",
5025 field: "todo".into(),
5026 }),
5027 }
5028 }
5029 #[allow(unused_variables)]
5030 fn write(
5031 &self,
5032 stream: &mut BitWriteStream<LittleEndian>,
5033 definition: &GameEventDefinition,
5034 ) -> Result<()> {
5035 for entry in &definition.entries {
5036 let value = self
5037 .get_field(entry)
5038 .unwrap_or_else(|_| entry.kind.default_value());
5039 stream.write(&value)?;
5040 }
5041 Ok(())
5042 }
5043}
5044#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5045#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5046pub struct TeamPlayUpdateTimerEvent {}
5047impl TeamPlayUpdateTimerEvent {
5048 #[allow(unused_variables)]
5049 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5050 Ok(TeamPlayUpdateTimerEvent {})
5051 }
5052 #[allow(unused_variables)]
5053 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5054 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5055 match field.hash {
5056 _ => Err(ParseError::MissingGameEventValue {
5057 ty: "TeamPlayUpdateTimer",
5058 field: "todo".into(),
5059 }),
5060 }
5061 }
5062 #[allow(unused_variables)]
5063 fn write(
5064 &self,
5065 stream: &mut BitWriteStream<LittleEndian>,
5066 definition: &GameEventDefinition,
5067 ) -> Result<()> {
5068 for entry in &definition.entries {
5069 let value = self
5070 .get_field(entry)
5071 .unwrap_or_else(|_| entry.kind.default_value());
5072 stream.write(&value)?;
5073 }
5074 Ok(())
5075 }
5076}
5077#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5078#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5079pub struct TeamPlayRoundStalemateEvent {
5080 pub reason: u8,
5081}
5082impl TeamPlayRoundStalemateEvent {
5083 #[allow(unused_variables)]
5084 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5085 Ok(TeamPlayRoundStalemateEvent {
5086 reason: read_value::<u8>(
5087 stream,
5088 definition.get_entry(7343356632300987961u64),
5089 "reason",
5090 )?,
5091 })
5092 }
5093 #[allow(unused_variables)]
5094 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5095 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5096 match field.hash {
5097 7343356632300987961u64 => Ok(self.reason.clone().into()),
5098 _ => Err(ParseError::MissingGameEventValue {
5099 ty: "TeamPlayRoundStalemate",
5100 field: "todo".into(),
5101 }),
5102 }
5103 }
5104 #[allow(unused_variables)]
5105 fn write(
5106 &self,
5107 stream: &mut BitWriteStream<LittleEndian>,
5108 definition: &GameEventDefinition,
5109 ) -> Result<()> {
5110 for entry in &definition.entries {
5111 let value = self
5112 .get_field(entry)
5113 .unwrap_or_else(|_| entry.kind.default_value());
5114 stream.write(&value)?;
5115 }
5116 Ok(())
5117 }
5118}
5119#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5120#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5121pub struct TeamPlayOvertimeBeginEvent {}
5122impl TeamPlayOvertimeBeginEvent {
5123 #[allow(unused_variables)]
5124 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5125 Ok(TeamPlayOvertimeBeginEvent {})
5126 }
5127 #[allow(unused_variables)]
5128 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5129 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5130 match field.hash {
5131 _ => Err(ParseError::MissingGameEventValue {
5132 ty: "TeamPlayOvertimeBegin",
5133 field: "todo".into(),
5134 }),
5135 }
5136 }
5137 #[allow(unused_variables)]
5138 fn write(
5139 &self,
5140 stream: &mut BitWriteStream<LittleEndian>,
5141 definition: &GameEventDefinition,
5142 ) -> Result<()> {
5143 for entry in &definition.entries {
5144 let value = self
5145 .get_field(entry)
5146 .unwrap_or_else(|_| entry.kind.default_value());
5147 stream.write(&value)?;
5148 }
5149 Ok(())
5150 }
5151}
5152#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5153#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5154pub struct TeamPlayOvertimeEndEvent {}
5155impl TeamPlayOvertimeEndEvent {
5156 #[allow(unused_variables)]
5157 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5158 Ok(TeamPlayOvertimeEndEvent {})
5159 }
5160 #[allow(unused_variables)]
5161 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5162 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5163 match field.hash {
5164 _ => Err(ParseError::MissingGameEventValue {
5165 ty: "TeamPlayOvertimeEnd",
5166 field: "todo".into(),
5167 }),
5168 }
5169 }
5170 #[allow(unused_variables)]
5171 fn write(
5172 &self,
5173 stream: &mut BitWriteStream<LittleEndian>,
5174 definition: &GameEventDefinition,
5175 ) -> Result<()> {
5176 for entry in &definition.entries {
5177 let value = self
5178 .get_field(entry)
5179 .unwrap_or_else(|_| entry.kind.default_value());
5180 stream.write(&value)?;
5181 }
5182 Ok(())
5183 }
5184}
5185#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5186#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5187pub struct TeamPlaySuddenDeathBeginEvent {}
5188impl TeamPlaySuddenDeathBeginEvent {
5189 #[allow(unused_variables)]
5190 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5191 Ok(TeamPlaySuddenDeathBeginEvent {})
5192 }
5193 #[allow(unused_variables)]
5194 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5195 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5196 match field.hash {
5197 _ => Err(ParseError::MissingGameEventValue {
5198 ty: "TeamPlaySuddenDeathBegin",
5199 field: "todo".into(),
5200 }),
5201 }
5202 }
5203 #[allow(unused_variables)]
5204 fn write(
5205 &self,
5206 stream: &mut BitWriteStream<LittleEndian>,
5207 definition: &GameEventDefinition,
5208 ) -> Result<()> {
5209 for entry in &definition.entries {
5210 let value = self
5211 .get_field(entry)
5212 .unwrap_or_else(|_| entry.kind.default_value());
5213 stream.write(&value)?;
5214 }
5215 Ok(())
5216 }
5217}
5218#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5219#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5220pub struct TeamPlaySuddenDeathEndEvent {}
5221impl TeamPlaySuddenDeathEndEvent {
5222 #[allow(unused_variables)]
5223 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5224 Ok(TeamPlaySuddenDeathEndEvent {})
5225 }
5226 #[allow(unused_variables)]
5227 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5228 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5229 match field.hash {
5230 _ => Err(ParseError::MissingGameEventValue {
5231 ty: "TeamPlaySuddenDeathEnd",
5232 field: "todo".into(),
5233 }),
5234 }
5235 }
5236 #[allow(unused_variables)]
5237 fn write(
5238 &self,
5239 stream: &mut BitWriteStream<LittleEndian>,
5240 definition: &GameEventDefinition,
5241 ) -> Result<()> {
5242 for entry in &definition.entries {
5243 let value = self
5244 .get_field(entry)
5245 .unwrap_or_else(|_| entry.kind.default_value());
5246 stream.write(&value)?;
5247 }
5248 Ok(())
5249 }
5250}
5251#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5252#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5253pub struct TeamPlayGameOverEvent {
5254 pub reason: MaybeUtf8String,
5255}
5256impl TeamPlayGameOverEvent {
5257 #[allow(unused_variables)]
5258 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5259 Ok(TeamPlayGameOverEvent {
5260 reason: read_value::<MaybeUtf8String>(
5261 stream,
5262 definition.get_entry(7343356632300987961u64),
5263 "reason",
5264 )?,
5265 })
5266 }
5267 #[allow(unused_variables)]
5268 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5269 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5270 match field.hash {
5271 7343356632300987961u64 => Ok(self.reason.clone().into()),
5272 _ => Err(ParseError::MissingGameEventValue {
5273 ty: "TeamPlayGameOver",
5274 field: "todo".into(),
5275 }),
5276 }
5277 }
5278 #[allow(unused_variables)]
5279 fn write(
5280 &self,
5281 stream: &mut BitWriteStream<LittleEndian>,
5282 definition: &GameEventDefinition,
5283 ) -> Result<()> {
5284 for entry in &definition.entries {
5285 let value = self
5286 .get_field(entry)
5287 .unwrap_or_else(|_| entry.kind.default_value());
5288 stream.write(&value)?;
5289 }
5290 Ok(())
5291 }
5292}
5293#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5294#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5295pub struct TeamPlayMapTimeRemainingEvent {
5296 pub seconds: u16,
5297}
5298impl TeamPlayMapTimeRemainingEvent {
5299 #[allow(unused_variables)]
5300 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5301 Ok(TeamPlayMapTimeRemainingEvent {
5302 seconds: read_value::<u16>(
5303 stream,
5304 definition.get_entry(11456985514702388746u64),
5305 "seconds",
5306 )?,
5307 })
5308 }
5309 #[allow(unused_variables)]
5310 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5311 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5312 match field.hash {
5313 11456985514702388746u64 => Ok(self.seconds.clone().into()),
5314 _ => Err(ParseError::MissingGameEventValue {
5315 ty: "TeamPlayMapTimeRemaining",
5316 field: "todo".into(),
5317 }),
5318 }
5319 }
5320 #[allow(unused_variables)]
5321 fn write(
5322 &self,
5323 stream: &mut BitWriteStream<LittleEndian>,
5324 definition: &GameEventDefinition,
5325 ) -> Result<()> {
5326 for entry in &definition.entries {
5327 let value = self
5328 .get_field(entry)
5329 .unwrap_or_else(|_| entry.kind.default_value());
5330 stream.write(&value)?;
5331 }
5332 Ok(())
5333 }
5334}
5335#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5336#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5337pub struct TeamPlayTimerFlashEvent {
5338 pub time_remaining: u16,
5339}
5340impl TeamPlayTimerFlashEvent {
5341 #[allow(unused_variables)]
5342 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5343 Ok(TeamPlayTimerFlashEvent {
5344 time_remaining: read_value::<u16>(
5345 stream,
5346 definition.get_entry(4322130481848759231u64),
5347 "time_remaining",
5348 )?,
5349 })
5350 }
5351 #[allow(unused_variables)]
5352 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5353 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5354 match field.hash {
5355 4322130481848759231u64 => Ok(self.time_remaining.clone().into()),
5356 _ => Err(ParseError::MissingGameEventValue {
5357 ty: "TeamPlayTimerFlash",
5358 field: "todo".into(),
5359 }),
5360 }
5361 }
5362 #[allow(unused_variables)]
5363 fn write(
5364 &self,
5365 stream: &mut BitWriteStream<LittleEndian>,
5366 definition: &GameEventDefinition,
5367 ) -> Result<()> {
5368 for entry in &definition.entries {
5369 let value = self
5370 .get_field(entry)
5371 .unwrap_or_else(|_| entry.kind.default_value());
5372 stream.write(&value)?;
5373 }
5374 Ok(())
5375 }
5376}
5377#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5378#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5379pub struct TeamPlayTimerTimeAddedEvent {
5380 pub timer: u16,
5381 pub seconds_added: u16,
5382}
5383impl TeamPlayTimerTimeAddedEvent {
5384 #[allow(unused_variables)]
5385 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5386 Ok(TeamPlayTimerTimeAddedEvent {
5387 timer: read_value::<u16>(
5388 stream,
5389 definition.get_entry(2968869876298967810u64),
5390 "timer",
5391 )?,
5392 seconds_added: read_value::<u16>(
5393 stream,
5394 definition.get_entry(5796598285704248091u64),
5395 "seconds_added",
5396 )?,
5397 })
5398 }
5399 #[allow(unused_variables)]
5400 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5401 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5402 match field.hash {
5403 2968869876298967810u64 => Ok(self.timer.clone().into()),
5404 5796598285704248091u64 => Ok(self.seconds_added.clone().into()),
5405 _ => Err(ParseError::MissingGameEventValue {
5406 ty: "TeamPlayTimerTimeAdded",
5407 field: "todo".into(),
5408 }),
5409 }
5410 }
5411 #[allow(unused_variables)]
5412 fn write(
5413 &self,
5414 stream: &mut BitWriteStream<LittleEndian>,
5415 definition: &GameEventDefinition,
5416 ) -> Result<()> {
5417 for entry in &definition.entries {
5418 let value = self
5419 .get_field(entry)
5420 .unwrap_or_else(|_| entry.kind.default_value());
5421 stream.write(&value)?;
5422 }
5423 Ok(())
5424 }
5425}
5426#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5427#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5428pub struct TeamPlayPointStartCaptureEvent {
5429 pub cp: u8,
5430 pub cp_name: MaybeUtf8String,
5431 pub team: u8,
5432 pub cap_team: u8,
5433 pub cappers: MaybeUtf8String,
5434 pub cap_time: f32,
5435}
5436impl TeamPlayPointStartCaptureEvent {
5437 #[allow(unused_variables)]
5438 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5439 Ok(TeamPlayPointStartCaptureEvent {
5440 cp: read_value::<u8>(stream, definition.get_entry(622127901357767142u64), "cp")?,
5441 cp_name: read_value::<MaybeUtf8String>(
5442 stream,
5443 definition.get_entry(5054899044858273797u64),
5444 "cp_name",
5445 )?,
5446 team: read_value::<u8>(
5447 stream,
5448 definition.get_entry(18024489754618217260u64),
5449 "team",
5450 )?,
5451 cap_team: read_value::<u8>(
5452 stream,
5453 definition.get_entry(9316766665943420626u64),
5454 "cap_team",
5455 )?,
5456 cappers: read_value::<MaybeUtf8String>(
5457 stream,
5458 definition.get_entry(11245576010855792123u64),
5459 "cappers",
5460 )?,
5461 cap_time: read_value::<f32>(
5462 stream,
5463 definition.get_entry(6747273962184890386u64),
5464 "cap_time",
5465 )?,
5466 })
5467 }
5468 #[allow(unused_variables)]
5469 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5470 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5471 match field.hash {
5472 622127901357767142u64 => Ok(self.cp.clone().into()),
5473 5054899044858273797u64 => Ok(self.cp_name.clone().into()),
5474 18024489754618217260u64 => Ok(self.team.clone().into()),
5475 9316766665943420626u64 => Ok(self.cap_team.clone().into()),
5476 11245576010855792123u64 => Ok(self.cappers.clone().into()),
5477 6747273962184890386u64 => Ok(self.cap_time.clone().into()),
5478 _ => Err(ParseError::MissingGameEventValue {
5479 ty: "TeamPlayPointStartCapture",
5480 field: "todo".into(),
5481 }),
5482 }
5483 }
5484 #[allow(unused_variables)]
5485 fn write(
5486 &self,
5487 stream: &mut BitWriteStream<LittleEndian>,
5488 definition: &GameEventDefinition,
5489 ) -> Result<()> {
5490 for entry in &definition.entries {
5491 let value = self
5492 .get_field(entry)
5493 .unwrap_or_else(|_| entry.kind.default_value());
5494 stream.write(&value)?;
5495 }
5496 Ok(())
5497 }
5498}
5499#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5500#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5501pub struct TeamPlayPointCapturedEvent {
5502 pub cp: u8,
5503 pub cp_name: MaybeUtf8String,
5504 pub team: u8,
5505 pub cappers: MaybeUtf8String,
5506}
5507impl TeamPlayPointCapturedEvent {
5508 #[allow(unused_variables)]
5509 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5510 Ok(TeamPlayPointCapturedEvent {
5511 cp: read_value::<u8>(stream, definition.get_entry(622127901357767142u64), "cp")?,
5512 cp_name: read_value::<MaybeUtf8String>(
5513 stream,
5514 definition.get_entry(5054899044858273797u64),
5515 "cp_name",
5516 )?,
5517 team: read_value::<u8>(
5518 stream,
5519 definition.get_entry(18024489754618217260u64),
5520 "team",
5521 )?,
5522 cappers: read_value::<MaybeUtf8String>(
5523 stream,
5524 definition.get_entry(11245576010855792123u64),
5525 "cappers",
5526 )?,
5527 })
5528 }
5529 #[allow(unused_variables)]
5530 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5531 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5532 match field.hash {
5533 622127901357767142u64 => Ok(self.cp.clone().into()),
5534 5054899044858273797u64 => Ok(self.cp_name.clone().into()),
5535 18024489754618217260u64 => Ok(self.team.clone().into()),
5536 11245576010855792123u64 => Ok(self.cappers.clone().into()),
5537 _ => Err(ParseError::MissingGameEventValue {
5538 ty: "TeamPlayPointCaptured",
5539 field: "todo".into(),
5540 }),
5541 }
5542 }
5543 #[allow(unused_variables)]
5544 fn write(
5545 &self,
5546 stream: &mut BitWriteStream<LittleEndian>,
5547 definition: &GameEventDefinition,
5548 ) -> Result<()> {
5549 for entry in &definition.entries {
5550 let value = self
5551 .get_field(entry)
5552 .unwrap_or_else(|_| entry.kind.default_value());
5553 stream.write(&value)?;
5554 }
5555 Ok(())
5556 }
5557}
5558#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5559#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5560pub struct TeamPlayPointLockedEvent {
5561 pub cp: u8,
5562 pub cp_name: MaybeUtf8String,
5563 pub team: u8,
5564}
5565impl TeamPlayPointLockedEvent {
5566 #[allow(unused_variables)]
5567 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5568 Ok(TeamPlayPointLockedEvent {
5569 cp: read_value::<u8>(stream, definition.get_entry(622127901357767142u64), "cp")?,
5570 cp_name: read_value::<MaybeUtf8String>(
5571 stream,
5572 definition.get_entry(5054899044858273797u64),
5573 "cp_name",
5574 )?,
5575 team: read_value::<u8>(
5576 stream,
5577 definition.get_entry(18024489754618217260u64),
5578 "team",
5579 )?,
5580 })
5581 }
5582 #[allow(unused_variables)]
5583 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5584 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5585 match field.hash {
5586 622127901357767142u64 => Ok(self.cp.clone().into()),
5587 5054899044858273797u64 => Ok(self.cp_name.clone().into()),
5588 18024489754618217260u64 => Ok(self.team.clone().into()),
5589 _ => Err(ParseError::MissingGameEventValue {
5590 ty: "TeamPlayPointLocked",
5591 field: "todo".into(),
5592 }),
5593 }
5594 }
5595 #[allow(unused_variables)]
5596 fn write(
5597 &self,
5598 stream: &mut BitWriteStream<LittleEndian>,
5599 definition: &GameEventDefinition,
5600 ) -> Result<()> {
5601 for entry in &definition.entries {
5602 let value = self
5603 .get_field(entry)
5604 .unwrap_or_else(|_| entry.kind.default_value());
5605 stream.write(&value)?;
5606 }
5607 Ok(())
5608 }
5609}
5610#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5611#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5612pub struct TeamPlayPointUnlockedEvent {
5613 pub cp: u8,
5614 pub cp_name: MaybeUtf8String,
5615 pub team: u8,
5616}
5617impl TeamPlayPointUnlockedEvent {
5618 #[allow(unused_variables)]
5619 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5620 Ok(TeamPlayPointUnlockedEvent {
5621 cp: read_value::<u8>(stream, definition.get_entry(622127901357767142u64), "cp")?,
5622 cp_name: read_value::<MaybeUtf8String>(
5623 stream,
5624 definition.get_entry(5054899044858273797u64),
5625 "cp_name",
5626 )?,
5627 team: read_value::<u8>(
5628 stream,
5629 definition.get_entry(18024489754618217260u64),
5630 "team",
5631 )?,
5632 })
5633 }
5634 #[allow(unused_variables)]
5635 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5636 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5637 match field.hash {
5638 622127901357767142u64 => Ok(self.cp.clone().into()),
5639 5054899044858273797u64 => Ok(self.cp_name.clone().into()),
5640 18024489754618217260u64 => Ok(self.team.clone().into()),
5641 _ => Err(ParseError::MissingGameEventValue {
5642 ty: "TeamPlayPointUnlocked",
5643 field: "todo".into(),
5644 }),
5645 }
5646 }
5647 #[allow(unused_variables)]
5648 fn write(
5649 &self,
5650 stream: &mut BitWriteStream<LittleEndian>,
5651 definition: &GameEventDefinition,
5652 ) -> Result<()> {
5653 for entry in &definition.entries {
5654 let value = self
5655 .get_field(entry)
5656 .unwrap_or_else(|_| entry.kind.default_value());
5657 stream.write(&value)?;
5658 }
5659 Ok(())
5660 }
5661}
5662#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5663#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5664pub struct TeamPlayCaptureBrokenEvent {
5665 pub cp: u8,
5666 pub cp_name: MaybeUtf8String,
5667 pub time_remaining: f32,
5668}
5669impl TeamPlayCaptureBrokenEvent {
5670 #[allow(unused_variables)]
5671 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5672 Ok(TeamPlayCaptureBrokenEvent {
5673 cp: read_value::<u8>(stream, definition.get_entry(622127901357767142u64), "cp")?,
5674 cp_name: read_value::<MaybeUtf8String>(
5675 stream,
5676 definition.get_entry(5054899044858273797u64),
5677 "cp_name",
5678 )?,
5679 time_remaining: read_value::<f32>(
5680 stream,
5681 definition.get_entry(4322130481848759231u64),
5682 "time_remaining",
5683 )?,
5684 })
5685 }
5686 #[allow(unused_variables)]
5687 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5688 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5689 match field.hash {
5690 622127901357767142u64 => Ok(self.cp.clone().into()),
5691 5054899044858273797u64 => Ok(self.cp_name.clone().into()),
5692 4322130481848759231u64 => Ok(self.time_remaining.clone().into()),
5693 _ => Err(ParseError::MissingGameEventValue {
5694 ty: "TeamPlayCaptureBroken",
5695 field: "todo".into(),
5696 }),
5697 }
5698 }
5699 #[allow(unused_variables)]
5700 fn write(
5701 &self,
5702 stream: &mut BitWriteStream<LittleEndian>,
5703 definition: &GameEventDefinition,
5704 ) -> Result<()> {
5705 for entry in &definition.entries {
5706 let value = self
5707 .get_field(entry)
5708 .unwrap_or_else(|_| entry.kind.default_value());
5709 stream.write(&value)?;
5710 }
5711 Ok(())
5712 }
5713}
5714#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5715#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5716pub struct TeamPlayCaptureBlockedEvent {
5717 pub cp: u8,
5718 pub cp_name: MaybeUtf8String,
5719 pub blocker: u8,
5720 pub victim: u8,
5721}
5722impl TeamPlayCaptureBlockedEvent {
5723 #[allow(unused_variables)]
5724 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5725 Ok(TeamPlayCaptureBlockedEvent {
5726 cp: read_value::<u8>(stream, definition.get_entry(622127901357767142u64), "cp")?,
5727 cp_name: read_value::<MaybeUtf8String>(
5728 stream,
5729 definition.get_entry(5054899044858273797u64),
5730 "cp_name",
5731 )?,
5732 blocker: read_value::<u8>(
5733 stream,
5734 definition.get_entry(9150196623075249301u64),
5735 "blocker",
5736 )?,
5737 victim: read_value::<u8>(
5738 stream,
5739 definition.get_entry(3120917251440744469u64),
5740 "victim",
5741 )?,
5742 })
5743 }
5744 #[allow(unused_variables)]
5745 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5746 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5747 match field.hash {
5748 622127901357767142u64 => Ok(self.cp.clone().into()),
5749 5054899044858273797u64 => Ok(self.cp_name.clone().into()),
5750 9150196623075249301u64 => Ok(self.blocker.clone().into()),
5751 3120917251440744469u64 => Ok(self.victim.clone().into()),
5752 _ => Err(ParseError::MissingGameEventValue {
5753 ty: "TeamPlayCaptureBlocked",
5754 field: "todo".into(),
5755 }),
5756 }
5757 }
5758 #[allow(unused_variables)]
5759 fn write(
5760 &self,
5761 stream: &mut BitWriteStream<LittleEndian>,
5762 definition: &GameEventDefinition,
5763 ) -> Result<()> {
5764 for entry in &definition.entries {
5765 let value = self
5766 .get_field(entry)
5767 .unwrap_or_else(|_| entry.kind.default_value());
5768 stream.write(&value)?;
5769 }
5770 Ok(())
5771 }
5772}
5773#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5774#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5775pub struct TeamPlayFlagEventEvent {
5776 pub player: u16,
5777 pub carrier: u16,
5778 pub event_type: u16,
5779 pub home: u8,
5780 pub team: u8,
5781}
5782impl TeamPlayFlagEventEvent {
5783 #[allow(unused_variables)]
5784 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5785 Ok(TeamPlayFlagEventEvent {
5786 player: read_value::<u16>(
5787 stream,
5788 definition.get_entry(5008278420455340480u64),
5789 "player",
5790 )?,
5791 carrier: read_value::<u16>(
5792 stream,
5793 definition.get_entry(6986802915220291447u64),
5794 "carrier",
5795 )?,
5796 event_type: read_value::<u16>(
5797 stream,
5798 definition.get_entry(5234087001556401511u64),
5799 "event_type",
5800 )?,
5801 home: read_value::<u8>(stream, definition.get_entry(4624382957487889774u64), "home")?,
5802 team: read_value::<u8>(
5803 stream,
5804 definition.get_entry(18024489754618217260u64),
5805 "team",
5806 )?,
5807 })
5808 }
5809 #[allow(unused_variables)]
5810 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5811 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5812 match field.hash {
5813 5008278420455340480u64 => Ok(self.player.clone().into()),
5814 6986802915220291447u64 => Ok(self.carrier.clone().into()),
5815 5234087001556401511u64 => Ok(self.event_type.clone().into()),
5816 4624382957487889774u64 => Ok(self.home.clone().into()),
5817 18024489754618217260u64 => Ok(self.team.clone().into()),
5818 _ => Err(ParseError::MissingGameEventValue {
5819 ty: "TeamPlayFlagEvent",
5820 field: "todo".into(),
5821 }),
5822 }
5823 }
5824 #[allow(unused_variables)]
5825 fn write(
5826 &self,
5827 stream: &mut BitWriteStream<LittleEndian>,
5828 definition: &GameEventDefinition,
5829 ) -> Result<()> {
5830 for entry in &definition.entries {
5831 let value = self
5832 .get_field(entry)
5833 .unwrap_or_else(|_| entry.kind.default_value());
5834 stream.write(&value)?;
5835 }
5836 Ok(())
5837 }
5838}
5839#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
5840#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
5841pub struct TeamPlayWinPanelEvent {
5842 pub panel_style: u8,
5843 pub winning_team: u8,
5844 pub win_reason: u8,
5845 pub cappers: MaybeUtf8String,
5846 pub flag_cap_limit: u16,
5847 pub blue_score: u16,
5848 pub red_score: u16,
5849 pub blue_score_prev: u16,
5850 pub red_score_prev: u16,
5851 pub round_complete: u16,
5852 pub rounds_remaining: u16,
5853 pub player_1: u16,
5854 pub player_1_points: u16,
5855 pub player_2: u16,
5856 pub player_2_points: u16,
5857 pub player_3: u16,
5858 pub player_3_points: u16,
5859 pub kill_stream_player_1: u16,
5860 pub kill_stream_player_1_count: u16,
5861 pub game_over: u8,
5862}
5863impl TeamPlayWinPanelEvent {
5864 #[allow(unused_variables)]
5865 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
5866 Ok(TeamPlayWinPanelEvent {
5867 panel_style: read_value::<u8>(
5868 stream,
5869 definition.get_entry(3076948889484157827u64),
5870 "panel_style",
5871 )?,
5872 winning_team: read_value::<u8>(
5873 stream,
5874 definition.get_entry(12760025138952247085u64),
5875 "winning_team",
5876 )?,
5877 win_reason: read_value::<u8>(
5878 stream,
5879 definition.get_entry(3803421146477351589u64),
5880 "win_reason",
5881 )?,
5882 cappers: read_value::<MaybeUtf8String>(
5883 stream,
5884 definition.get_entry(11245576010855792123u64),
5885 "cappers",
5886 )?,
5887 flag_cap_limit: read_value::<u16>(
5888 stream,
5889 definition.get_entry(8774624256288798788u64),
5890 "flag_cap_limit",
5891 )?,
5892 blue_score: read_value::<u16>(
5893 stream,
5894 definition.get_entry(12881173953286901124u64),
5895 "blue_score",
5896 )?,
5897 red_score: read_value::<u16>(
5898 stream,
5899 definition.get_entry(1115892277897790273u64),
5900 "red_score",
5901 )?,
5902 blue_score_prev: read_value::<u16>(
5903 stream,
5904 definition.get_entry(12382344057664863052u64),
5905 "blue_score_prev",
5906 )?,
5907 red_score_prev: read_value::<u16>(
5908 stream,
5909 definition.get_entry(9684982604781518527u64),
5910 "red_score_prev",
5911 )?,
5912 round_complete: read_value::<u16>(
5913 stream,
5914 definition.get_entry(12165785943437780003u64),
5915 "round_complete",
5916 )?,
5917 rounds_remaining: read_value::<u16>(
5918 stream,
5919 definition.get_entry(10434023640517397027u64),
5920 "rounds_remaining",
5921 )?,
5922 player_1: read_value::<u16>(
5923 stream,
5924 definition.get_entry(2316304829487618708u64),
5925 "player_1",
5926 )?,
5927 player_1_points: read_value::<u16>(
5928 stream,
5929 definition.get_entry(5201979123115161946u64),
5930 "player_1_points",
5931 )?,
5932 player_2: read_value::<u16>(
5933 stream,
5934 definition.get_entry(2316308128022503341u64),
5935 "player_2",
5936 )?,
5937 player_2_points: read_value::<u16>(
5938 stream,
5939 definition.get_entry(17826909355416759905u64),
5940 "player_2_points",
5941 )?,
5942 player_3: read_value::<u16>(
5943 stream,
5944 definition.get_entry(2316307028510875130u64),
5945 "player_3",
5946 )?,
5947 player_3_points: read_value::<u16>(
5948 stream,
5949 definition.get_entry(3496125461192453068u64),
5950 "player_3_points",
5951 )?,
5952 kill_stream_player_1: read_value::<u16>(
5953 stream,
5954 definition.get_entry(5168633764732789397u64),
5955 "kill_stream_player_1",
5956 )?,
5957 kill_stream_player_1_count: read_value::<u16>(
5958 stream,
5959 definition.get_entry(15596392604614003293u64),
5960 "kill_stream_player_1_count",
5961 )?,
5962 game_over: read_value::<u8>(
5963 stream,
5964 definition.get_entry(17040732377939006530u64),
5965 "game_over",
5966 )?,
5967 })
5968 }
5969 #[allow(unused_variables)]
5970 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
5971 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
5972 match field.hash {
5973 3076948889484157827u64 => Ok(self.panel_style.clone().into()),
5974 12760025138952247085u64 => Ok(self.winning_team.clone().into()),
5975 3803421146477351589u64 => Ok(self.win_reason.clone().into()),
5976 11245576010855792123u64 => Ok(self.cappers.clone().into()),
5977 8774624256288798788u64 => Ok(self.flag_cap_limit.clone().into()),
5978 12881173953286901124u64 => Ok(self.blue_score.clone().into()),
5979 1115892277897790273u64 => Ok(self.red_score.clone().into()),
5980 12382344057664863052u64 => Ok(self.blue_score_prev.clone().into()),
5981 9684982604781518527u64 => Ok(self.red_score_prev.clone().into()),
5982 12165785943437780003u64 => Ok(self.round_complete.clone().into()),
5983 10434023640517397027u64 => Ok(self.rounds_remaining.clone().into()),
5984 2316304829487618708u64 => Ok(self.player_1.clone().into()),
5985 5201979123115161946u64 => Ok(self.player_1_points.clone().into()),
5986 2316308128022503341u64 => Ok(self.player_2.clone().into()),
5987 17826909355416759905u64 => Ok(self.player_2_points.clone().into()),
5988 2316307028510875130u64 => Ok(self.player_3.clone().into()),
5989 3496125461192453068u64 => Ok(self.player_3_points.clone().into()),
5990 5168633764732789397u64 => Ok(self.kill_stream_player_1.clone().into()),
5991 15596392604614003293u64 => Ok(self.kill_stream_player_1_count.clone().into()),
5992 17040732377939006530u64 => Ok(self.game_over.clone().into()),
5993 _ => Err(ParseError::MissingGameEventValue {
5994 ty: "TeamPlayWinPanel",
5995 field: "todo".into(),
5996 }),
5997 }
5998 }
5999 #[allow(unused_variables)]
6000 fn write(
6001 &self,
6002 stream: &mut BitWriteStream<LittleEndian>,
6003 definition: &GameEventDefinition,
6004 ) -> Result<()> {
6005 for entry in &definition.entries {
6006 let value = self
6007 .get_field(entry)
6008 .unwrap_or_else(|_| entry.kind.default_value());
6009 stream.write(&value)?;
6010 }
6011 Ok(())
6012 }
6013}
6014#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6015#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6016pub struct TeamPlayTeamBalancedPlayerEvent {
6017 pub player: u16,
6018 pub team: u8,
6019}
6020impl TeamPlayTeamBalancedPlayerEvent {
6021 #[allow(unused_variables)]
6022 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6023 Ok(TeamPlayTeamBalancedPlayerEvent {
6024 player: read_value::<u16>(
6025 stream,
6026 definition.get_entry(5008278420455340480u64),
6027 "player",
6028 )?,
6029 team: read_value::<u8>(
6030 stream,
6031 definition.get_entry(18024489754618217260u64),
6032 "team",
6033 )?,
6034 })
6035 }
6036 #[allow(unused_variables)]
6037 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6038 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6039 match field.hash {
6040 5008278420455340480u64 => Ok(self.player.clone().into()),
6041 18024489754618217260u64 => Ok(self.team.clone().into()),
6042 _ => Err(ParseError::MissingGameEventValue {
6043 ty: "TeamPlayTeamBalancedPlayer",
6044 field: "todo".into(),
6045 }),
6046 }
6047 }
6048 #[allow(unused_variables)]
6049 fn write(
6050 &self,
6051 stream: &mut BitWriteStream<LittleEndian>,
6052 definition: &GameEventDefinition,
6053 ) -> Result<()> {
6054 for entry in &definition.entries {
6055 let value = self
6056 .get_field(entry)
6057 .unwrap_or_else(|_| entry.kind.default_value());
6058 stream.write(&value)?;
6059 }
6060 Ok(())
6061 }
6062}
6063#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6064#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6065pub struct TeamPlaySetupFinishedEvent {}
6066impl TeamPlaySetupFinishedEvent {
6067 #[allow(unused_variables)]
6068 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6069 Ok(TeamPlaySetupFinishedEvent {})
6070 }
6071 #[allow(unused_variables)]
6072 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6073 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6074 match field.hash {
6075 _ => Err(ParseError::MissingGameEventValue {
6076 ty: "TeamPlaySetupFinished",
6077 field: "todo".into(),
6078 }),
6079 }
6080 }
6081 #[allow(unused_variables)]
6082 fn write(
6083 &self,
6084 stream: &mut BitWriteStream<LittleEndian>,
6085 definition: &GameEventDefinition,
6086 ) -> Result<()> {
6087 for entry in &definition.entries {
6088 let value = self
6089 .get_field(entry)
6090 .unwrap_or_else(|_| entry.kind.default_value());
6091 stream.write(&value)?;
6092 }
6093 Ok(())
6094 }
6095}
6096#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6097#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6098pub struct TeamPlayAlertEvent {
6099 pub alert_type: u16,
6100}
6101impl TeamPlayAlertEvent {
6102 #[allow(unused_variables)]
6103 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6104 Ok(TeamPlayAlertEvent {
6105 alert_type: read_value::<u16>(
6106 stream,
6107 definition.get_entry(5455556148004663490u64),
6108 "alert_type",
6109 )?,
6110 })
6111 }
6112 #[allow(unused_variables)]
6113 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6114 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6115 match field.hash {
6116 5455556148004663490u64 => Ok(self.alert_type.clone().into()),
6117 _ => Err(ParseError::MissingGameEventValue {
6118 ty: "TeamPlayAlert",
6119 field: "todo".into(),
6120 }),
6121 }
6122 }
6123 #[allow(unused_variables)]
6124 fn write(
6125 &self,
6126 stream: &mut BitWriteStream<LittleEndian>,
6127 definition: &GameEventDefinition,
6128 ) -> Result<()> {
6129 for entry in &definition.entries {
6130 let value = self
6131 .get_field(entry)
6132 .unwrap_or_else(|_| entry.kind.default_value());
6133 stream.write(&value)?;
6134 }
6135 Ok(())
6136 }
6137}
6138#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6139#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6140pub struct TrainingCompleteEvent {
6141 pub next_map: MaybeUtf8String,
6142 pub map: MaybeUtf8String,
6143 pub text: MaybeUtf8String,
6144}
6145impl TrainingCompleteEvent {
6146 #[allow(unused_variables)]
6147 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6148 Ok(TrainingCompleteEvent {
6149 next_map: read_value::<MaybeUtf8String>(
6150 stream,
6151 definition.get_entry(13669032538247983969u64),
6152 "next_map",
6153 )?,
6154 map: read_value::<MaybeUtf8String>(
6155 stream,
6156 definition.get_entry(580780841256168849u64),
6157 "map",
6158 )?,
6159 text: read_value::<MaybeUtf8String>(
6160 stream,
6161 definition.get_entry(18015793717152399486u64),
6162 "text",
6163 )?,
6164 })
6165 }
6166 #[allow(unused_variables)]
6167 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6168 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6169 match field.hash {
6170 13669032538247983969u64 => Ok(self.next_map.clone().into()),
6171 580780841256168849u64 => Ok(self.map.clone().into()),
6172 18015793717152399486u64 => Ok(self.text.clone().into()),
6173 _ => Err(ParseError::MissingGameEventValue {
6174 ty: "TrainingComplete",
6175 field: "todo".into(),
6176 }),
6177 }
6178 }
6179 #[allow(unused_variables)]
6180 fn write(
6181 &self,
6182 stream: &mut BitWriteStream<LittleEndian>,
6183 definition: &GameEventDefinition,
6184 ) -> Result<()> {
6185 for entry in &definition.entries {
6186 let value = self
6187 .get_field(entry)
6188 .unwrap_or_else(|_| entry.kind.default_value());
6189 stream.write(&value)?;
6190 }
6191 Ok(())
6192 }
6193}
6194#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6195#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6196pub struct ShowFreezePanelEvent {
6197 pub killer: u16,
6198}
6199impl ShowFreezePanelEvent {
6200 #[allow(unused_variables)]
6201 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6202 Ok(ShowFreezePanelEvent {
6203 killer: read_value::<u16>(
6204 stream,
6205 definition.get_entry(7927307102854403058u64),
6206 "killer",
6207 )?,
6208 })
6209 }
6210 #[allow(unused_variables)]
6211 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6212 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6213 match field.hash {
6214 7927307102854403058u64 => Ok(self.killer.clone().into()),
6215 _ => Err(ParseError::MissingGameEventValue {
6216 ty: "ShowFreezePanel",
6217 field: "todo".into(),
6218 }),
6219 }
6220 }
6221 #[allow(unused_variables)]
6222 fn write(
6223 &self,
6224 stream: &mut BitWriteStream<LittleEndian>,
6225 definition: &GameEventDefinition,
6226 ) -> Result<()> {
6227 for entry in &definition.entries {
6228 let value = self
6229 .get_field(entry)
6230 .unwrap_or_else(|_| entry.kind.default_value());
6231 stream.write(&value)?;
6232 }
6233 Ok(())
6234 }
6235}
6236#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6237#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6238pub struct HideFreezePanelEvent {}
6239impl HideFreezePanelEvent {
6240 #[allow(unused_variables)]
6241 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6242 Ok(HideFreezePanelEvent {})
6243 }
6244 #[allow(unused_variables)]
6245 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6246 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6247 match field.hash {
6248 _ => Err(ParseError::MissingGameEventValue {
6249 ty: "HideFreezePanel",
6250 field: "todo".into(),
6251 }),
6252 }
6253 }
6254 #[allow(unused_variables)]
6255 fn write(
6256 &self,
6257 stream: &mut BitWriteStream<LittleEndian>,
6258 definition: &GameEventDefinition,
6259 ) -> Result<()> {
6260 for entry in &definition.entries {
6261 let value = self
6262 .get_field(entry)
6263 .unwrap_or_else(|_| entry.kind.default_value());
6264 stream.write(&value)?;
6265 }
6266 Ok(())
6267 }
6268}
6269#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6270#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6271pub struct FreezeCamStartedEvent {}
6272impl FreezeCamStartedEvent {
6273 #[allow(unused_variables)]
6274 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6275 Ok(FreezeCamStartedEvent {})
6276 }
6277 #[allow(unused_variables)]
6278 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6279 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6280 match field.hash {
6281 _ => Err(ParseError::MissingGameEventValue {
6282 ty: "FreezeCamStarted",
6283 field: "todo".into(),
6284 }),
6285 }
6286 }
6287 #[allow(unused_variables)]
6288 fn write(
6289 &self,
6290 stream: &mut BitWriteStream<LittleEndian>,
6291 definition: &GameEventDefinition,
6292 ) -> Result<()> {
6293 for entry in &definition.entries {
6294 let value = self
6295 .get_field(entry)
6296 .unwrap_or_else(|_| entry.kind.default_value());
6297 stream.write(&value)?;
6298 }
6299 Ok(())
6300 }
6301}
6302#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6303#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6304pub struct LocalPlayerChangeTeamEvent {}
6305impl LocalPlayerChangeTeamEvent {
6306 #[allow(unused_variables)]
6307 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6308 Ok(LocalPlayerChangeTeamEvent {})
6309 }
6310 #[allow(unused_variables)]
6311 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6312 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6313 match field.hash {
6314 _ => Err(ParseError::MissingGameEventValue {
6315 ty: "LocalPlayerChangeTeam",
6316 field: "todo".into(),
6317 }),
6318 }
6319 }
6320 #[allow(unused_variables)]
6321 fn write(
6322 &self,
6323 stream: &mut BitWriteStream<LittleEndian>,
6324 definition: &GameEventDefinition,
6325 ) -> Result<()> {
6326 for entry in &definition.entries {
6327 let value = self
6328 .get_field(entry)
6329 .unwrap_or_else(|_| entry.kind.default_value());
6330 stream.write(&value)?;
6331 }
6332 Ok(())
6333 }
6334}
6335#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6336#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6337pub struct LocalPlayerScoreChangedEvent {
6338 pub score: u16,
6339}
6340impl LocalPlayerScoreChangedEvent {
6341 #[allow(unused_variables)]
6342 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6343 Ok(LocalPlayerScoreChangedEvent {
6344 score: read_value::<u16>(
6345 stream,
6346 definition.get_entry(13911166232573650165u64),
6347 "score",
6348 )?,
6349 })
6350 }
6351 #[allow(unused_variables)]
6352 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6353 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6354 match field.hash {
6355 13911166232573650165u64 => Ok(self.score.clone().into()),
6356 _ => Err(ParseError::MissingGameEventValue {
6357 ty: "LocalPlayerScoreChanged",
6358 field: "todo".into(),
6359 }),
6360 }
6361 }
6362 #[allow(unused_variables)]
6363 fn write(
6364 &self,
6365 stream: &mut BitWriteStream<LittleEndian>,
6366 definition: &GameEventDefinition,
6367 ) -> Result<()> {
6368 for entry in &definition.entries {
6369 let value = self
6370 .get_field(entry)
6371 .unwrap_or_else(|_| entry.kind.default_value());
6372 stream.write(&value)?;
6373 }
6374 Ok(())
6375 }
6376}
6377#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6378#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6379pub struct LocalPlayerChangeClassEvent {}
6380impl LocalPlayerChangeClassEvent {
6381 #[allow(unused_variables)]
6382 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6383 Ok(LocalPlayerChangeClassEvent {})
6384 }
6385 #[allow(unused_variables)]
6386 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6387 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6388 match field.hash {
6389 _ => Err(ParseError::MissingGameEventValue {
6390 ty: "LocalPlayerChangeClass",
6391 field: "todo".into(),
6392 }),
6393 }
6394 }
6395 #[allow(unused_variables)]
6396 fn write(
6397 &self,
6398 stream: &mut BitWriteStream<LittleEndian>,
6399 definition: &GameEventDefinition,
6400 ) -> Result<()> {
6401 for entry in &definition.entries {
6402 let value = self
6403 .get_field(entry)
6404 .unwrap_or_else(|_| entry.kind.default_value());
6405 stream.write(&value)?;
6406 }
6407 Ok(())
6408 }
6409}
6410#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6411#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6412pub struct LocalPlayerRespawnEvent {}
6413impl LocalPlayerRespawnEvent {
6414 #[allow(unused_variables)]
6415 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6416 Ok(LocalPlayerRespawnEvent {})
6417 }
6418 #[allow(unused_variables)]
6419 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6420 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6421 match field.hash {
6422 _ => Err(ParseError::MissingGameEventValue {
6423 ty: "LocalPlayerRespawn",
6424 field: "todo".into(),
6425 }),
6426 }
6427 }
6428 #[allow(unused_variables)]
6429 fn write(
6430 &self,
6431 stream: &mut BitWriteStream<LittleEndian>,
6432 definition: &GameEventDefinition,
6433 ) -> Result<()> {
6434 for entry in &definition.entries {
6435 let value = self
6436 .get_field(entry)
6437 .unwrap_or_else(|_| entry.kind.default_value());
6438 stream.write(&value)?;
6439 }
6440 Ok(())
6441 }
6442}
6443#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6444#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6445pub struct BuildingInfoChangedEvent {
6446 pub building_type: u8,
6447 pub object_mode: u8,
6448 pub remove: u8,
6449}
6450impl BuildingInfoChangedEvent {
6451 #[allow(unused_variables)]
6452 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6453 Ok(BuildingInfoChangedEvent {
6454 building_type: read_value::<u8>(
6455 stream,
6456 definition.get_entry(11928805672381350942u64),
6457 "building_type",
6458 )?,
6459 object_mode: read_value::<u8>(
6460 stream,
6461 definition.get_entry(10575483099853176920u64),
6462 "object_mode",
6463 )?,
6464 remove: read_value::<u8>(
6465 stream,
6466 definition.get_entry(18444559702367749501u64),
6467 "remove",
6468 )?,
6469 })
6470 }
6471 #[allow(unused_variables)]
6472 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6473 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6474 match field.hash {
6475 11928805672381350942u64 => Ok(self.building_type.clone().into()),
6476 10575483099853176920u64 => Ok(self.object_mode.clone().into()),
6477 18444559702367749501u64 => Ok(self.remove.clone().into()),
6478 _ => Err(ParseError::MissingGameEventValue {
6479 ty: "BuildingInfoChanged",
6480 field: "todo".into(),
6481 }),
6482 }
6483 }
6484 #[allow(unused_variables)]
6485 fn write(
6486 &self,
6487 stream: &mut BitWriteStream<LittleEndian>,
6488 definition: &GameEventDefinition,
6489 ) -> Result<()> {
6490 for entry in &definition.entries {
6491 let value = self
6492 .get_field(entry)
6493 .unwrap_or_else(|_| entry.kind.default_value());
6494 stream.write(&value)?;
6495 }
6496 Ok(())
6497 }
6498}
6499#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6500#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6501pub struct LocalPlayerChangeDisguiseEvent {
6502 pub disguised: bool,
6503}
6504impl LocalPlayerChangeDisguiseEvent {
6505 #[allow(unused_variables)]
6506 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6507 Ok(LocalPlayerChangeDisguiseEvent {
6508 disguised: read_value::<bool>(
6509 stream,
6510 definition.get_entry(12536453236572645170u64),
6511 "disguised",
6512 )?,
6513 })
6514 }
6515 #[allow(unused_variables)]
6516 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6517 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6518 match field.hash {
6519 12536453236572645170u64 => Ok(self.disguised.clone().into()),
6520 _ => Err(ParseError::MissingGameEventValue {
6521 ty: "LocalPlayerChangeDisguise",
6522 field: "todo".into(),
6523 }),
6524 }
6525 }
6526 #[allow(unused_variables)]
6527 fn write(
6528 &self,
6529 stream: &mut BitWriteStream<LittleEndian>,
6530 definition: &GameEventDefinition,
6531 ) -> Result<()> {
6532 for entry in &definition.entries {
6533 let value = self
6534 .get_field(entry)
6535 .unwrap_or_else(|_| entry.kind.default_value());
6536 stream.write(&value)?;
6537 }
6538 Ok(())
6539 }
6540}
6541#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6542#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6543pub struct PlayerAccountChangedEvent {
6544 pub old_value: u16,
6545 pub new_value: u16,
6546}
6547impl PlayerAccountChangedEvent {
6548 #[allow(unused_variables)]
6549 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6550 Ok(PlayerAccountChangedEvent {
6551 old_value: read_value::<u16>(
6552 stream,
6553 definition.get_entry(12791125728741340200u64),
6554 "old_value",
6555 )?,
6556 new_value: read_value::<u16>(
6557 stream,
6558 definition.get_entry(4557144879184858675u64),
6559 "new_value",
6560 )?,
6561 })
6562 }
6563 #[allow(unused_variables)]
6564 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6565 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6566 match field.hash {
6567 12791125728741340200u64 => Ok(self.old_value.clone().into()),
6568 4557144879184858675u64 => Ok(self.new_value.clone().into()),
6569 _ => Err(ParseError::MissingGameEventValue {
6570 ty: "PlayerAccountChanged",
6571 field: "todo".into(),
6572 }),
6573 }
6574 }
6575 #[allow(unused_variables)]
6576 fn write(
6577 &self,
6578 stream: &mut BitWriteStream<LittleEndian>,
6579 definition: &GameEventDefinition,
6580 ) -> Result<()> {
6581 for entry in &definition.entries {
6582 let value = self
6583 .get_field(entry)
6584 .unwrap_or_else(|_| entry.kind.default_value());
6585 stream.write(&value)?;
6586 }
6587 Ok(())
6588 }
6589}
6590#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6591#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6592pub struct SpyPdaResetEvent {}
6593impl SpyPdaResetEvent {
6594 #[allow(unused_variables)]
6595 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6596 Ok(SpyPdaResetEvent {})
6597 }
6598 #[allow(unused_variables)]
6599 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6600 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6601 match field.hash {
6602 _ => Err(ParseError::MissingGameEventValue {
6603 ty: "SpyPdaReset",
6604 field: "todo".into(),
6605 }),
6606 }
6607 }
6608 #[allow(unused_variables)]
6609 fn write(
6610 &self,
6611 stream: &mut BitWriteStream<LittleEndian>,
6612 definition: &GameEventDefinition,
6613 ) -> Result<()> {
6614 for entry in &definition.entries {
6615 let value = self
6616 .get_field(entry)
6617 .unwrap_or_else(|_| entry.kind.default_value());
6618 stream.write(&value)?;
6619 }
6620 Ok(())
6621 }
6622}
6623#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6624#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6625pub struct FlagStatusUpdateEvent {
6626 pub user_id: u16,
6627 pub ent_index: u32,
6628}
6629impl FlagStatusUpdateEvent {
6630 #[allow(unused_variables)]
6631 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6632 Ok(FlagStatusUpdateEvent {
6633 user_id: read_value::<u16>(
6634 stream,
6635 definition.get_entry(17826443226371159423u64),
6636 "user_id",
6637 )?,
6638 ent_index: read_value::<u32>(
6639 stream,
6640 definition.get_entry(17554918082946193550u64),
6641 "ent_index",
6642 )?,
6643 })
6644 }
6645 #[allow(unused_variables)]
6646 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6647 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6648 match field.hash {
6649 17826443226371159423u64 => Ok(self.user_id.clone().into()),
6650 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
6651 _ => Err(ParseError::MissingGameEventValue {
6652 ty: "FlagStatusUpdate",
6653 field: "todo".into(),
6654 }),
6655 }
6656 }
6657 #[allow(unused_variables)]
6658 fn write(
6659 &self,
6660 stream: &mut BitWriteStream<LittleEndian>,
6661 definition: &GameEventDefinition,
6662 ) -> Result<()> {
6663 for entry in &definition.entries {
6664 let value = self
6665 .get_field(entry)
6666 .unwrap_or_else(|_| entry.kind.default_value());
6667 stream.write(&value)?;
6668 }
6669 Ok(())
6670 }
6671}
6672#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6673#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6674pub struct PlayerStatsUpdatedEvent {
6675 pub force_upload: bool,
6676}
6677impl PlayerStatsUpdatedEvent {
6678 #[allow(unused_variables)]
6679 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6680 Ok(PlayerStatsUpdatedEvent {
6681 force_upload: read_value::<bool>(
6682 stream,
6683 definition.get_entry(9059172244575932677u64),
6684 "force_upload",
6685 )?,
6686 })
6687 }
6688 #[allow(unused_variables)]
6689 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6690 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6691 match field.hash {
6692 9059172244575932677u64 => Ok(self.force_upload.clone().into()),
6693 _ => Err(ParseError::MissingGameEventValue {
6694 ty: "PlayerStatsUpdated",
6695 field: "todo".into(),
6696 }),
6697 }
6698 }
6699 #[allow(unused_variables)]
6700 fn write(
6701 &self,
6702 stream: &mut BitWriteStream<LittleEndian>,
6703 definition: &GameEventDefinition,
6704 ) -> Result<()> {
6705 for entry in &definition.entries {
6706 let value = self
6707 .get_field(entry)
6708 .unwrap_or_else(|_| entry.kind.default_value());
6709 stream.write(&value)?;
6710 }
6711 Ok(())
6712 }
6713}
6714#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6715#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6716pub struct PlayingCommentaryEvent {}
6717impl PlayingCommentaryEvent {
6718 #[allow(unused_variables)]
6719 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6720 Ok(PlayingCommentaryEvent {})
6721 }
6722 #[allow(unused_variables)]
6723 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6724 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6725 match field.hash {
6726 _ => Err(ParseError::MissingGameEventValue {
6727 ty: "PlayingCommentary",
6728 field: "todo".into(),
6729 }),
6730 }
6731 }
6732 #[allow(unused_variables)]
6733 fn write(
6734 &self,
6735 stream: &mut BitWriteStream<LittleEndian>,
6736 definition: &GameEventDefinition,
6737 ) -> Result<()> {
6738 for entry in &definition.entries {
6739 let value = self
6740 .get_field(entry)
6741 .unwrap_or_else(|_| entry.kind.default_value());
6742 stream.write(&value)?;
6743 }
6744 Ok(())
6745 }
6746}
6747#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6748#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6749pub struct PlayerChargeDeployedEvent {
6750 pub user_id: u16,
6751 pub target_id: u16,
6752}
6753impl PlayerChargeDeployedEvent {
6754 #[allow(unused_variables)]
6755 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6756 Ok(PlayerChargeDeployedEvent {
6757 user_id: read_value::<u16>(
6758 stream,
6759 definition.get_entry(17826443226371159423u64),
6760 "user_id",
6761 )?,
6762 target_id: read_value::<u16>(
6763 stream,
6764 definition.get_entry(10554794794880602069u64),
6765 "target_id",
6766 )?,
6767 })
6768 }
6769 #[allow(unused_variables)]
6770 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6771 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6772 match field.hash {
6773 17826443226371159423u64 => Ok(self.user_id.clone().into()),
6774 10554794794880602069u64 => Ok(self.target_id.clone().into()),
6775 _ => Err(ParseError::MissingGameEventValue {
6776 ty: "PlayerChargeDeployed",
6777 field: "todo".into(),
6778 }),
6779 }
6780 }
6781 #[allow(unused_variables)]
6782 fn write(
6783 &self,
6784 stream: &mut BitWriteStream<LittleEndian>,
6785 definition: &GameEventDefinition,
6786 ) -> Result<()> {
6787 for entry in &definition.entries {
6788 let value = self
6789 .get_field(entry)
6790 .unwrap_or_else(|_| entry.kind.default_value());
6791 stream.write(&value)?;
6792 }
6793 Ok(())
6794 }
6795}
6796#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6797#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6798pub struct PlayerBuiltObjectEvent {
6799 pub user_id: u16,
6800 pub object: u16,
6801 pub index: u16,
6802}
6803impl PlayerBuiltObjectEvent {
6804 #[allow(unused_variables)]
6805 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6806 Ok(PlayerBuiltObjectEvent {
6807 user_id: read_value::<u16>(
6808 stream,
6809 definition.get_entry(17826443226371159423u64),
6810 "user_id",
6811 )?,
6812 object: read_value::<u16>(
6813 stream,
6814 definition.get_entry(10231808476453998586u64),
6815 "object",
6816 )?,
6817 index: read_value::<u16>(
6818 stream,
6819 definition.get_entry(9497966886403524235u64),
6820 "index",
6821 )?,
6822 })
6823 }
6824 #[allow(unused_variables)]
6825 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6826 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6827 match field.hash {
6828 17826443226371159423u64 => Ok(self.user_id.clone().into()),
6829 10231808476453998586u64 => Ok(self.object.clone().into()),
6830 9497966886403524235u64 => Ok(self.index.clone().into()),
6831 _ => Err(ParseError::MissingGameEventValue {
6832 ty: "PlayerBuiltObject",
6833 field: "todo".into(),
6834 }),
6835 }
6836 }
6837 #[allow(unused_variables)]
6838 fn write(
6839 &self,
6840 stream: &mut BitWriteStream<LittleEndian>,
6841 definition: &GameEventDefinition,
6842 ) -> Result<()> {
6843 for entry in &definition.entries {
6844 let value = self
6845 .get_field(entry)
6846 .unwrap_or_else(|_| entry.kind.default_value());
6847 stream.write(&value)?;
6848 }
6849 Ok(())
6850 }
6851}
6852#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6853#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6854pub struct PlayerUpgradedObjectEvent {
6855 pub user_id: u16,
6856 pub object: u16,
6857 pub index: u16,
6858 pub is_builder: bool,
6859}
6860impl PlayerUpgradedObjectEvent {
6861 #[allow(unused_variables)]
6862 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6863 Ok(PlayerUpgradedObjectEvent {
6864 user_id: read_value::<u16>(
6865 stream,
6866 definition.get_entry(17826443226371159423u64),
6867 "user_id",
6868 )?,
6869 object: read_value::<u16>(
6870 stream,
6871 definition.get_entry(10231808476453998586u64),
6872 "object",
6873 )?,
6874 index: read_value::<u16>(
6875 stream,
6876 definition.get_entry(9497966886403524235u64),
6877 "index",
6878 )?,
6879 is_builder: read_value::<bool>(
6880 stream,
6881 definition.get_entry(16922823115528993136u64),
6882 "is_builder",
6883 )?,
6884 })
6885 }
6886 #[allow(unused_variables)]
6887 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6888 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6889 match field.hash {
6890 17826443226371159423u64 => Ok(self.user_id.clone().into()),
6891 10231808476453998586u64 => Ok(self.object.clone().into()),
6892 9497966886403524235u64 => Ok(self.index.clone().into()),
6893 16922823115528993136u64 => Ok(self.is_builder.clone().into()),
6894 _ => Err(ParseError::MissingGameEventValue {
6895 ty: "PlayerUpgradedObject",
6896 field: "todo".into(),
6897 }),
6898 }
6899 }
6900 #[allow(unused_variables)]
6901 fn write(
6902 &self,
6903 stream: &mut BitWriteStream<LittleEndian>,
6904 definition: &GameEventDefinition,
6905 ) -> Result<()> {
6906 for entry in &definition.entries {
6907 let value = self
6908 .get_field(entry)
6909 .unwrap_or_else(|_| entry.kind.default_value());
6910 stream.write(&value)?;
6911 }
6912 Ok(())
6913 }
6914}
6915#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6916#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6917pub struct PlayerCarryObjectEvent {
6918 pub user_id: u16,
6919 pub object: u16,
6920 pub index: u16,
6921}
6922impl PlayerCarryObjectEvent {
6923 #[allow(unused_variables)]
6924 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6925 Ok(PlayerCarryObjectEvent {
6926 user_id: read_value::<u16>(
6927 stream,
6928 definition.get_entry(17826443226371159423u64),
6929 "user_id",
6930 )?,
6931 object: read_value::<u16>(
6932 stream,
6933 definition.get_entry(10231808476453998586u64),
6934 "object",
6935 )?,
6936 index: read_value::<u16>(
6937 stream,
6938 definition.get_entry(9497966886403524235u64),
6939 "index",
6940 )?,
6941 })
6942 }
6943 #[allow(unused_variables)]
6944 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
6945 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
6946 match field.hash {
6947 17826443226371159423u64 => Ok(self.user_id.clone().into()),
6948 10231808476453998586u64 => Ok(self.object.clone().into()),
6949 9497966886403524235u64 => Ok(self.index.clone().into()),
6950 _ => Err(ParseError::MissingGameEventValue {
6951 ty: "PlayerCarryObject",
6952 field: "todo".into(),
6953 }),
6954 }
6955 }
6956 #[allow(unused_variables)]
6957 fn write(
6958 &self,
6959 stream: &mut BitWriteStream<LittleEndian>,
6960 definition: &GameEventDefinition,
6961 ) -> Result<()> {
6962 for entry in &definition.entries {
6963 let value = self
6964 .get_field(entry)
6965 .unwrap_or_else(|_| entry.kind.default_value());
6966 stream.write(&value)?;
6967 }
6968 Ok(())
6969 }
6970}
6971#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
6972#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
6973pub struct PlayerDropObjectEvent {
6974 pub user_id: u16,
6975 pub object: u16,
6976 pub index: u16,
6977}
6978impl PlayerDropObjectEvent {
6979 #[allow(unused_variables)]
6980 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
6981 Ok(PlayerDropObjectEvent {
6982 user_id: read_value::<u16>(
6983 stream,
6984 definition.get_entry(17826443226371159423u64),
6985 "user_id",
6986 )?,
6987 object: read_value::<u16>(
6988 stream,
6989 definition.get_entry(10231808476453998586u64),
6990 "object",
6991 )?,
6992 index: read_value::<u16>(
6993 stream,
6994 definition.get_entry(9497966886403524235u64),
6995 "index",
6996 )?,
6997 })
6998 }
6999 #[allow(unused_variables)]
7000 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7001 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7002 match field.hash {
7003 17826443226371159423u64 => Ok(self.user_id.clone().into()),
7004 10231808476453998586u64 => Ok(self.object.clone().into()),
7005 9497966886403524235u64 => Ok(self.index.clone().into()),
7006 _ => Err(ParseError::MissingGameEventValue {
7007 ty: "PlayerDropObject",
7008 field: "todo".into(),
7009 }),
7010 }
7011 }
7012 #[allow(unused_variables)]
7013 fn write(
7014 &self,
7015 stream: &mut BitWriteStream<LittleEndian>,
7016 definition: &GameEventDefinition,
7017 ) -> Result<()> {
7018 for entry in &definition.entries {
7019 let value = self
7020 .get_field(entry)
7021 .unwrap_or_else(|_| entry.kind.default_value());
7022 stream.write(&value)?;
7023 }
7024 Ok(())
7025 }
7026}
7027#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7028#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7029pub struct ObjectRemovedEvent {
7030 pub user_id: u16,
7031 pub object_type: u16,
7032 pub index: u16,
7033}
7034impl ObjectRemovedEvent {
7035 #[allow(unused_variables)]
7036 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7037 Ok(ObjectRemovedEvent {
7038 user_id: read_value::<u16>(
7039 stream,
7040 definition.get_entry(17826443226371159423u64),
7041 "user_id",
7042 )?,
7043 object_type: read_value::<u16>(
7044 stream,
7045 definition.get_entry(6025769100165056826u64),
7046 "object_type",
7047 )?,
7048 index: read_value::<u16>(
7049 stream,
7050 definition.get_entry(9497966886403524235u64),
7051 "index",
7052 )?,
7053 })
7054 }
7055 #[allow(unused_variables)]
7056 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7057 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7058 match field.hash {
7059 17826443226371159423u64 => Ok(self.user_id.clone().into()),
7060 6025769100165056826u64 => Ok(self.object_type.clone().into()),
7061 9497966886403524235u64 => Ok(self.index.clone().into()),
7062 _ => Err(ParseError::MissingGameEventValue {
7063 ty: "ObjectRemoved",
7064 field: "todo".into(),
7065 }),
7066 }
7067 }
7068 #[allow(unused_variables)]
7069 fn write(
7070 &self,
7071 stream: &mut BitWriteStream<LittleEndian>,
7072 definition: &GameEventDefinition,
7073 ) -> Result<()> {
7074 for entry in &definition.entries {
7075 let value = self
7076 .get_field(entry)
7077 .unwrap_or_else(|_| entry.kind.default_value());
7078 stream.write(&value)?;
7079 }
7080 Ok(())
7081 }
7082}
7083#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7084#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7085pub struct ObjectDestroyedEvent {
7086 pub user_id: u16,
7087 pub attacker: u16,
7088 pub assister: u16,
7089 pub weapon: MaybeUtf8String,
7090 pub weapon_id: u16,
7091 pub object_type: u16,
7092 pub index: u16,
7093 pub was_building: bool,
7094}
7095impl ObjectDestroyedEvent {
7096 #[allow(unused_variables)]
7097 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7098 Ok(ObjectDestroyedEvent {
7099 user_id: read_value::<u16>(
7100 stream,
7101 definition.get_entry(17826443226371159423u64),
7102 "user_id",
7103 )?,
7104 attacker: read_value::<u16>(
7105 stream,
7106 definition.get_entry(7198542740550218478u64),
7107 "attacker",
7108 )?,
7109 assister: read_value::<u16>(
7110 stream,
7111 definition.get_entry(17978308754419261977u64),
7112 "assister",
7113 )?,
7114 weapon: read_value::<MaybeUtf8String>(
7115 stream,
7116 definition.get_entry(11580461223051554305u64),
7117 "weapon",
7118 )?,
7119 weapon_id: read_value::<u16>(
7120 stream,
7121 definition.get_entry(5542695206485500884u64),
7122 "weapon_id",
7123 )?,
7124 object_type: read_value::<u16>(
7125 stream,
7126 definition.get_entry(6025769100165056826u64),
7127 "object_type",
7128 )?,
7129 index: read_value::<u16>(
7130 stream,
7131 definition.get_entry(9497966886403524235u64),
7132 "index",
7133 )?,
7134 was_building: read_value::<bool>(
7135 stream,
7136 definition.get_entry(13090762770129151523u64),
7137 "was_building",
7138 )?,
7139 })
7140 }
7141 #[allow(unused_variables)]
7142 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7143 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7144 match field.hash {
7145 17826443226371159423u64 => Ok(self.user_id.clone().into()),
7146 7198542740550218478u64 => Ok(self.attacker.clone().into()),
7147 17978308754419261977u64 => Ok(self.assister.clone().into()),
7148 11580461223051554305u64 => Ok(self.weapon.clone().into()),
7149 5542695206485500884u64 => Ok(self.weapon_id.clone().into()),
7150 6025769100165056826u64 => Ok(self.object_type.clone().into()),
7151 9497966886403524235u64 => Ok(self.index.clone().into()),
7152 13090762770129151523u64 => Ok(self.was_building.clone().into()),
7153 _ => Err(ParseError::MissingGameEventValue {
7154 ty: "ObjectDestroyed",
7155 field: "todo".into(),
7156 }),
7157 }
7158 }
7159 #[allow(unused_variables)]
7160 fn write(
7161 &self,
7162 stream: &mut BitWriteStream<LittleEndian>,
7163 definition: &GameEventDefinition,
7164 ) -> Result<()> {
7165 for entry in &definition.entries {
7166 let value = self
7167 .get_field(entry)
7168 .unwrap_or_else(|_| entry.kind.default_value());
7169 stream.write(&value)?;
7170 }
7171 Ok(())
7172 }
7173}
7174#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7175#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7176pub struct ObjectDetonatedEvent {
7177 pub user_id: u16,
7178 pub object_type: u16,
7179 pub index: u16,
7180}
7181impl ObjectDetonatedEvent {
7182 #[allow(unused_variables)]
7183 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7184 Ok(ObjectDetonatedEvent {
7185 user_id: read_value::<u16>(
7186 stream,
7187 definition.get_entry(17826443226371159423u64),
7188 "user_id",
7189 )?,
7190 object_type: read_value::<u16>(
7191 stream,
7192 definition.get_entry(6025769100165056826u64),
7193 "object_type",
7194 )?,
7195 index: read_value::<u16>(
7196 stream,
7197 definition.get_entry(9497966886403524235u64),
7198 "index",
7199 )?,
7200 })
7201 }
7202 #[allow(unused_variables)]
7203 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7204 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7205 match field.hash {
7206 17826443226371159423u64 => Ok(self.user_id.clone().into()),
7207 6025769100165056826u64 => Ok(self.object_type.clone().into()),
7208 9497966886403524235u64 => Ok(self.index.clone().into()),
7209 _ => Err(ParseError::MissingGameEventValue {
7210 ty: "ObjectDetonated",
7211 field: "todo".into(),
7212 }),
7213 }
7214 }
7215 #[allow(unused_variables)]
7216 fn write(
7217 &self,
7218 stream: &mut BitWriteStream<LittleEndian>,
7219 definition: &GameEventDefinition,
7220 ) -> Result<()> {
7221 for entry in &definition.entries {
7222 let value = self
7223 .get_field(entry)
7224 .unwrap_or_else(|_| entry.kind.default_value());
7225 stream.write(&value)?;
7226 }
7227 Ok(())
7228 }
7229}
7230#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7231#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7232pub struct AchievementEarnedEvent {
7233 pub player: u8,
7234 pub achievement: u16,
7235}
7236impl AchievementEarnedEvent {
7237 #[allow(unused_variables)]
7238 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7239 Ok(AchievementEarnedEvent {
7240 player: read_value::<u8>(
7241 stream,
7242 definition.get_entry(5008278420455340480u64),
7243 "player",
7244 )?,
7245 achievement: read_value::<u16>(
7246 stream,
7247 definition.get_entry(7071905471600864408u64),
7248 "achievement",
7249 )?,
7250 })
7251 }
7252 #[allow(unused_variables)]
7253 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7254 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7255 match field.hash {
7256 5008278420455340480u64 => Ok(self.player.clone().into()),
7257 7071905471600864408u64 => Ok(self.achievement.clone().into()),
7258 _ => Err(ParseError::MissingGameEventValue {
7259 ty: "AchievementEarned",
7260 field: "todo".into(),
7261 }),
7262 }
7263 }
7264 #[allow(unused_variables)]
7265 fn write(
7266 &self,
7267 stream: &mut BitWriteStream<LittleEndian>,
7268 definition: &GameEventDefinition,
7269 ) -> Result<()> {
7270 for entry in &definition.entries {
7271 let value = self
7272 .get_field(entry)
7273 .unwrap_or_else(|_| entry.kind.default_value());
7274 stream.write(&value)?;
7275 }
7276 Ok(())
7277 }
7278}
7279#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7280#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7281pub struct SpecTargetUpdatedEvent {}
7282impl SpecTargetUpdatedEvent {
7283 #[allow(unused_variables)]
7284 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7285 Ok(SpecTargetUpdatedEvent {})
7286 }
7287 #[allow(unused_variables)]
7288 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7289 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7290 match field.hash {
7291 _ => Err(ParseError::MissingGameEventValue {
7292 ty: "SpecTargetUpdated",
7293 field: "todo".into(),
7294 }),
7295 }
7296 }
7297 #[allow(unused_variables)]
7298 fn write(
7299 &self,
7300 stream: &mut BitWriteStream<LittleEndian>,
7301 definition: &GameEventDefinition,
7302 ) -> Result<()> {
7303 for entry in &definition.entries {
7304 let value = self
7305 .get_field(entry)
7306 .unwrap_or_else(|_| entry.kind.default_value());
7307 stream.write(&value)?;
7308 }
7309 Ok(())
7310 }
7311}
7312#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7313#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7314pub struct TournamentStateUpdateEvent {
7315 pub user_id: u16,
7316 pub name_change: bool,
7317 pub ready_state: u16,
7318 pub new_name: MaybeUtf8String,
7319}
7320impl TournamentStateUpdateEvent {
7321 #[allow(unused_variables)]
7322 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7323 Ok(TournamentStateUpdateEvent {
7324 user_id: read_value::<u16>(
7325 stream,
7326 definition.get_entry(17826443226371159423u64),
7327 "user_id",
7328 )?,
7329 name_change: read_value::<bool>(
7330 stream,
7331 definition.get_entry(2507746477842667538u64),
7332 "name_change",
7333 )?,
7334 ready_state: read_value::<u16>(
7335 stream,
7336 definition.get_entry(14125289189230288425u64),
7337 "ready_state",
7338 )?,
7339 new_name: read_value::<MaybeUtf8String>(
7340 stream,
7341 definition.get_entry(8904377156710117674u64),
7342 "new_name",
7343 )?,
7344 })
7345 }
7346 #[allow(unused_variables)]
7347 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7348 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7349 match field.hash {
7350 17826443226371159423u64 => Ok(self.user_id.clone().into()),
7351 2507746477842667538u64 => Ok(self.name_change.clone().into()),
7352 14125289189230288425u64 => Ok(self.ready_state.clone().into()),
7353 8904377156710117674u64 => Ok(self.new_name.clone().into()),
7354 _ => Err(ParseError::MissingGameEventValue {
7355 ty: "TournamentStateUpdate",
7356 field: "todo".into(),
7357 }),
7358 }
7359 }
7360 #[allow(unused_variables)]
7361 fn write(
7362 &self,
7363 stream: &mut BitWriteStream<LittleEndian>,
7364 definition: &GameEventDefinition,
7365 ) -> Result<()> {
7366 for entry in &definition.entries {
7367 let value = self
7368 .get_field(entry)
7369 .unwrap_or_else(|_| entry.kind.default_value());
7370 stream.write(&value)?;
7371 }
7372 Ok(())
7373 }
7374}
7375#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7376#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7377pub struct TournamentEnableCountdownEvent {}
7378impl TournamentEnableCountdownEvent {
7379 #[allow(unused_variables)]
7380 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7381 Ok(TournamentEnableCountdownEvent {})
7382 }
7383 #[allow(unused_variables)]
7384 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7385 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7386 match field.hash {
7387 _ => Err(ParseError::MissingGameEventValue {
7388 ty: "TournamentEnableCountdown",
7389 field: "todo".into(),
7390 }),
7391 }
7392 }
7393 #[allow(unused_variables)]
7394 fn write(
7395 &self,
7396 stream: &mut BitWriteStream<LittleEndian>,
7397 definition: &GameEventDefinition,
7398 ) -> Result<()> {
7399 for entry in &definition.entries {
7400 let value = self
7401 .get_field(entry)
7402 .unwrap_or_else(|_| entry.kind.default_value());
7403 stream.write(&value)?;
7404 }
7405 Ok(())
7406 }
7407}
7408#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7409#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7410pub struct PlayerCalledForMedicEvent {
7411 pub user_id: u16,
7412}
7413impl PlayerCalledForMedicEvent {
7414 #[allow(unused_variables)]
7415 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7416 Ok(PlayerCalledForMedicEvent {
7417 user_id: read_value::<u16>(
7418 stream,
7419 definition.get_entry(17826443226371159423u64),
7420 "user_id",
7421 )?,
7422 })
7423 }
7424 #[allow(unused_variables)]
7425 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7426 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7427 match field.hash {
7428 17826443226371159423u64 => Ok(self.user_id.clone().into()),
7429 _ => Err(ParseError::MissingGameEventValue {
7430 ty: "PlayerCalledForMedic",
7431 field: "todo".into(),
7432 }),
7433 }
7434 }
7435 #[allow(unused_variables)]
7436 fn write(
7437 &self,
7438 stream: &mut BitWriteStream<LittleEndian>,
7439 definition: &GameEventDefinition,
7440 ) -> Result<()> {
7441 for entry in &definition.entries {
7442 let value = self
7443 .get_field(entry)
7444 .unwrap_or_else(|_| entry.kind.default_value());
7445 stream.write(&value)?;
7446 }
7447 Ok(())
7448 }
7449}
7450#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7451#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7452pub struct PlayerAskedForBallEvent {
7453 pub user_id: u16,
7454}
7455impl PlayerAskedForBallEvent {
7456 #[allow(unused_variables)]
7457 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7458 Ok(PlayerAskedForBallEvent {
7459 user_id: read_value::<u16>(
7460 stream,
7461 definition.get_entry(17826443226371159423u64),
7462 "user_id",
7463 )?,
7464 })
7465 }
7466 #[allow(unused_variables)]
7467 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7468 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7469 match field.hash {
7470 17826443226371159423u64 => Ok(self.user_id.clone().into()),
7471 _ => Err(ParseError::MissingGameEventValue {
7472 ty: "PlayerAskedForBall",
7473 field: "todo".into(),
7474 }),
7475 }
7476 }
7477 #[allow(unused_variables)]
7478 fn write(
7479 &self,
7480 stream: &mut BitWriteStream<LittleEndian>,
7481 definition: &GameEventDefinition,
7482 ) -> Result<()> {
7483 for entry in &definition.entries {
7484 let value = self
7485 .get_field(entry)
7486 .unwrap_or_else(|_| entry.kind.default_value());
7487 stream.write(&value)?;
7488 }
7489 Ok(())
7490 }
7491}
7492#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7493#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7494pub struct LocalPlayerBecameObserverEvent {}
7495impl LocalPlayerBecameObserverEvent {
7496 #[allow(unused_variables)]
7497 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7498 Ok(LocalPlayerBecameObserverEvent {})
7499 }
7500 #[allow(unused_variables)]
7501 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7502 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7503 match field.hash {
7504 _ => Err(ParseError::MissingGameEventValue {
7505 ty: "LocalPlayerBecameObserver",
7506 field: "todo".into(),
7507 }),
7508 }
7509 }
7510 #[allow(unused_variables)]
7511 fn write(
7512 &self,
7513 stream: &mut BitWriteStream<LittleEndian>,
7514 definition: &GameEventDefinition,
7515 ) -> Result<()> {
7516 for entry in &definition.entries {
7517 let value = self
7518 .get_field(entry)
7519 .unwrap_or_else(|_| entry.kind.default_value());
7520 stream.write(&value)?;
7521 }
7522 Ok(())
7523 }
7524}
7525#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7526#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7527pub struct PlayerIgnitedInvEvent {
7528 pub pyro_ent_index: u8,
7529 pub victim_ent_index: u8,
7530 pub medic_ent_index: u8,
7531}
7532impl PlayerIgnitedInvEvent {
7533 #[allow(unused_variables)]
7534 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7535 Ok(PlayerIgnitedInvEvent {
7536 pyro_ent_index: read_value::<u8>(
7537 stream,
7538 definition.get_entry(2481028106190820025u64),
7539 "pyro_ent_index",
7540 )?,
7541 victim_ent_index: read_value::<u8>(
7542 stream,
7543 definition.get_entry(7608903543976233025u64),
7544 "victim_ent_index",
7545 )?,
7546 medic_ent_index: read_value::<u8>(
7547 stream,
7548 definition.get_entry(9117426914612648485u64),
7549 "medic_ent_index",
7550 )?,
7551 })
7552 }
7553 #[allow(unused_variables)]
7554 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7555 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7556 match field.hash {
7557 2481028106190820025u64 => Ok(self.pyro_ent_index.clone().into()),
7558 7608903543976233025u64 => Ok(self.victim_ent_index.clone().into()),
7559 9117426914612648485u64 => Ok(self.medic_ent_index.clone().into()),
7560 _ => Err(ParseError::MissingGameEventValue {
7561 ty: "PlayerIgnitedInv",
7562 field: "todo".into(),
7563 }),
7564 }
7565 }
7566 #[allow(unused_variables)]
7567 fn write(
7568 &self,
7569 stream: &mut BitWriteStream<LittleEndian>,
7570 definition: &GameEventDefinition,
7571 ) -> Result<()> {
7572 for entry in &definition.entries {
7573 let value = self
7574 .get_field(entry)
7575 .unwrap_or_else(|_| entry.kind.default_value());
7576 stream.write(&value)?;
7577 }
7578 Ok(())
7579 }
7580}
7581#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7582#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7583pub struct PlayerIgnitedEvent {
7584 pub pyro_ent_index: u8,
7585 pub victim_ent_index: u8,
7586 pub weapon_id: u8,
7587}
7588impl PlayerIgnitedEvent {
7589 #[allow(unused_variables)]
7590 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7591 Ok(PlayerIgnitedEvent {
7592 pyro_ent_index: read_value::<u8>(
7593 stream,
7594 definition.get_entry(2481028106190820025u64),
7595 "pyro_ent_index",
7596 )?,
7597 victim_ent_index: read_value::<u8>(
7598 stream,
7599 definition.get_entry(7608903543976233025u64),
7600 "victim_ent_index",
7601 )?,
7602 weapon_id: read_value::<u8>(
7603 stream,
7604 definition.get_entry(5542695206485500884u64),
7605 "weapon_id",
7606 )?,
7607 })
7608 }
7609 #[allow(unused_variables)]
7610 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7611 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7612 match field.hash {
7613 2481028106190820025u64 => Ok(self.pyro_ent_index.clone().into()),
7614 7608903543976233025u64 => Ok(self.victim_ent_index.clone().into()),
7615 5542695206485500884u64 => Ok(self.weapon_id.clone().into()),
7616 _ => Err(ParseError::MissingGameEventValue {
7617 ty: "PlayerIgnited",
7618 field: "todo".into(),
7619 }),
7620 }
7621 }
7622 #[allow(unused_variables)]
7623 fn write(
7624 &self,
7625 stream: &mut BitWriteStream<LittleEndian>,
7626 definition: &GameEventDefinition,
7627 ) -> Result<()> {
7628 for entry in &definition.entries {
7629 let value = self
7630 .get_field(entry)
7631 .unwrap_or_else(|_| entry.kind.default_value());
7632 stream.write(&value)?;
7633 }
7634 Ok(())
7635 }
7636}
7637#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7638#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7639pub struct PlayerExtinguishedEvent {
7640 pub victim: u8,
7641 pub healer: u8,
7642 pub item_definition_index: u16,
7643}
7644impl PlayerExtinguishedEvent {
7645 #[allow(unused_variables)]
7646 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7647 Ok(PlayerExtinguishedEvent {
7648 victim: read_value::<u8>(
7649 stream,
7650 definition.get_entry(3120917251440744469u64),
7651 "victim",
7652 )?,
7653 healer: read_value::<u8>(
7654 stream,
7655 definition.get_entry(9195440821534910520u64),
7656 "healer",
7657 )?,
7658 item_definition_index: read_value::<u16>(
7659 stream,
7660 definition.get_entry(4926523576391011283u64),
7661 "item_definition_index",
7662 )?,
7663 })
7664 }
7665 #[allow(unused_variables)]
7666 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7667 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7668 match field.hash {
7669 3120917251440744469u64 => Ok(self.victim.clone().into()),
7670 9195440821534910520u64 => Ok(self.healer.clone().into()),
7671 4926523576391011283u64 => Ok(self.item_definition_index.clone().into()),
7672 _ => Err(ParseError::MissingGameEventValue {
7673 ty: "PlayerExtinguished",
7674 field: "todo".into(),
7675 }),
7676 }
7677 }
7678 #[allow(unused_variables)]
7679 fn write(
7680 &self,
7681 stream: &mut BitWriteStream<LittleEndian>,
7682 definition: &GameEventDefinition,
7683 ) -> Result<()> {
7684 for entry in &definition.entries {
7685 let value = self
7686 .get_field(entry)
7687 .unwrap_or_else(|_| entry.kind.default_value());
7688 stream.write(&value)?;
7689 }
7690 Ok(())
7691 }
7692}
7693#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7694#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7695pub struct PlayerTeleportedEvent {
7696 pub user_id: u16,
7697 pub builder_id: u16,
7698 pub dist: f32,
7699}
7700impl PlayerTeleportedEvent {
7701 #[allow(unused_variables)]
7702 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7703 Ok(PlayerTeleportedEvent {
7704 user_id: read_value::<u16>(
7705 stream,
7706 definition.get_entry(17826443226371159423u64),
7707 "user_id",
7708 )?,
7709 builder_id: read_value::<u16>(
7710 stream,
7711 definition.get_entry(3387979893847309533u64),
7712 "builder_id",
7713 )?,
7714 dist: read_value::<f32>(
7715 stream,
7716 definition.get_entry(14574961654905149033u64),
7717 "dist",
7718 )?,
7719 })
7720 }
7721 #[allow(unused_variables)]
7722 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7723 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7724 match field.hash {
7725 17826443226371159423u64 => Ok(self.user_id.clone().into()),
7726 3387979893847309533u64 => Ok(self.builder_id.clone().into()),
7727 14574961654905149033u64 => Ok(self.dist.clone().into()),
7728 _ => Err(ParseError::MissingGameEventValue {
7729 ty: "PlayerTeleported",
7730 field: "todo".into(),
7731 }),
7732 }
7733 }
7734 #[allow(unused_variables)]
7735 fn write(
7736 &self,
7737 stream: &mut BitWriteStream<LittleEndian>,
7738 definition: &GameEventDefinition,
7739 ) -> Result<()> {
7740 for entry in &definition.entries {
7741 let value = self
7742 .get_field(entry)
7743 .unwrap_or_else(|_| entry.kind.default_value());
7744 stream.write(&value)?;
7745 }
7746 Ok(())
7747 }
7748}
7749#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7750#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7751pub struct PlayerHealedMedicCallEvent {
7752 pub user_id: u16,
7753}
7754impl PlayerHealedMedicCallEvent {
7755 #[allow(unused_variables)]
7756 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7757 Ok(PlayerHealedMedicCallEvent {
7758 user_id: read_value::<u16>(
7759 stream,
7760 definition.get_entry(17826443226371159423u64),
7761 "user_id",
7762 )?,
7763 })
7764 }
7765 #[allow(unused_variables)]
7766 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7767 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7768 match field.hash {
7769 17826443226371159423u64 => Ok(self.user_id.clone().into()),
7770 _ => Err(ParseError::MissingGameEventValue {
7771 ty: "PlayerHealedMedicCall",
7772 field: "todo".into(),
7773 }),
7774 }
7775 }
7776 #[allow(unused_variables)]
7777 fn write(
7778 &self,
7779 stream: &mut BitWriteStream<LittleEndian>,
7780 definition: &GameEventDefinition,
7781 ) -> Result<()> {
7782 for entry in &definition.entries {
7783 let value = self
7784 .get_field(entry)
7785 .unwrap_or_else(|_| entry.kind.default_value());
7786 stream.write(&value)?;
7787 }
7788 Ok(())
7789 }
7790}
7791#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7792#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7793pub struct LocalPlayerChargeReadyEvent {}
7794impl LocalPlayerChargeReadyEvent {
7795 #[allow(unused_variables)]
7796 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7797 Ok(LocalPlayerChargeReadyEvent {})
7798 }
7799 #[allow(unused_variables)]
7800 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7801 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7802 match field.hash {
7803 _ => Err(ParseError::MissingGameEventValue {
7804 ty: "LocalPlayerChargeReady",
7805 field: "todo".into(),
7806 }),
7807 }
7808 }
7809 #[allow(unused_variables)]
7810 fn write(
7811 &self,
7812 stream: &mut BitWriteStream<LittleEndian>,
7813 definition: &GameEventDefinition,
7814 ) -> Result<()> {
7815 for entry in &definition.entries {
7816 let value = self
7817 .get_field(entry)
7818 .unwrap_or_else(|_| entry.kind.default_value());
7819 stream.write(&value)?;
7820 }
7821 Ok(())
7822 }
7823}
7824#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7825#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7826pub struct LocalPlayerWindDownEvent {}
7827impl LocalPlayerWindDownEvent {
7828 #[allow(unused_variables)]
7829 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7830 Ok(LocalPlayerWindDownEvent {})
7831 }
7832 #[allow(unused_variables)]
7833 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7834 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7835 match field.hash {
7836 _ => Err(ParseError::MissingGameEventValue {
7837 ty: "LocalPlayerWindDown",
7838 field: "todo".into(),
7839 }),
7840 }
7841 }
7842 #[allow(unused_variables)]
7843 fn write(
7844 &self,
7845 stream: &mut BitWriteStream<LittleEndian>,
7846 definition: &GameEventDefinition,
7847 ) -> Result<()> {
7848 for entry in &definition.entries {
7849 let value = self
7850 .get_field(entry)
7851 .unwrap_or_else(|_| entry.kind.default_value());
7852 stream.write(&value)?;
7853 }
7854 Ok(())
7855 }
7856}
7857#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7858#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7859pub struct PlayerInvulnedEvent {
7860 pub user_id: u16,
7861 pub medic_user_id: u16,
7862}
7863impl PlayerInvulnedEvent {
7864 #[allow(unused_variables)]
7865 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7866 Ok(PlayerInvulnedEvent {
7867 user_id: read_value::<u16>(
7868 stream,
7869 definition.get_entry(17826443226371159423u64),
7870 "user_id",
7871 )?,
7872 medic_user_id: read_value::<u16>(
7873 stream,
7874 definition.get_entry(1211611822706104928u64),
7875 "medic_user_id",
7876 )?,
7877 })
7878 }
7879 #[allow(unused_variables)]
7880 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7881 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7882 match field.hash {
7883 17826443226371159423u64 => Ok(self.user_id.clone().into()),
7884 1211611822706104928u64 => Ok(self.medic_user_id.clone().into()),
7885 _ => Err(ParseError::MissingGameEventValue {
7886 ty: "PlayerInvulned",
7887 field: "todo".into(),
7888 }),
7889 }
7890 }
7891 #[allow(unused_variables)]
7892 fn write(
7893 &self,
7894 stream: &mut BitWriteStream<LittleEndian>,
7895 definition: &GameEventDefinition,
7896 ) -> Result<()> {
7897 for entry in &definition.entries {
7898 let value = self
7899 .get_field(entry)
7900 .unwrap_or_else(|_| entry.kind.default_value());
7901 stream.write(&value)?;
7902 }
7903 Ok(())
7904 }
7905}
7906#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7907#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7908pub struct EscortSpeedEvent {
7909 pub team: u8,
7910 pub speed: u8,
7911 pub players: u8,
7912}
7913impl EscortSpeedEvent {
7914 #[allow(unused_variables)]
7915 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7916 Ok(EscortSpeedEvent {
7917 team: read_value::<u8>(
7918 stream,
7919 definition.get_entry(18024489754618217260u64),
7920 "team",
7921 )?,
7922 speed: read_value::<u8>(
7923 stream,
7924 definition.get_entry(2486349329025994304u64),
7925 "speed",
7926 )?,
7927 players: read_value::<u8>(
7928 stream,
7929 definition.get_entry(11016838732397775657u64),
7930 "players",
7931 )?,
7932 })
7933 }
7934 #[allow(unused_variables)]
7935 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7936 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7937 match field.hash {
7938 18024489754618217260u64 => Ok(self.team.clone().into()),
7939 2486349329025994304u64 => Ok(self.speed.clone().into()),
7940 11016838732397775657u64 => Ok(self.players.clone().into()),
7941 _ => Err(ParseError::MissingGameEventValue {
7942 ty: "EscortSpeed",
7943 field: "todo".into(),
7944 }),
7945 }
7946 }
7947 #[allow(unused_variables)]
7948 fn write(
7949 &self,
7950 stream: &mut BitWriteStream<LittleEndian>,
7951 definition: &GameEventDefinition,
7952 ) -> Result<()> {
7953 for entry in &definition.entries {
7954 let value = self
7955 .get_field(entry)
7956 .unwrap_or_else(|_| entry.kind.default_value());
7957 stream.write(&value)?;
7958 }
7959 Ok(())
7960 }
7961}
7962#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
7963#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
7964pub struct EscortProgressEvent {
7965 pub team: u8,
7966 pub progress: f32,
7967 pub reset: bool,
7968}
7969impl EscortProgressEvent {
7970 #[allow(unused_variables)]
7971 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
7972 Ok(EscortProgressEvent {
7973 team: read_value::<u8>(
7974 stream,
7975 definition.get_entry(18024489754618217260u64),
7976 "team",
7977 )?,
7978 progress: read_value::<f32>(
7979 stream,
7980 definition.get_entry(17983033035584588230u64),
7981 "progress",
7982 )?,
7983 reset: read_value::<bool>(
7984 stream,
7985 definition.get_entry(1086335023529244512u64),
7986 "reset",
7987 )?,
7988 })
7989 }
7990 #[allow(unused_variables)]
7991 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
7992 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
7993 match field.hash {
7994 18024489754618217260u64 => Ok(self.team.clone().into()),
7995 17983033035584588230u64 => Ok(self.progress.clone().into()),
7996 1086335023529244512u64 => Ok(self.reset.clone().into()),
7997 _ => Err(ParseError::MissingGameEventValue {
7998 ty: "EscortProgress",
7999 field: "todo".into(),
8000 }),
8001 }
8002 }
8003 #[allow(unused_variables)]
8004 fn write(
8005 &self,
8006 stream: &mut BitWriteStream<LittleEndian>,
8007 definition: &GameEventDefinition,
8008 ) -> Result<()> {
8009 for entry in &definition.entries {
8010 let value = self
8011 .get_field(entry)
8012 .unwrap_or_else(|_| entry.kind.default_value());
8013 stream.write(&value)?;
8014 }
8015 Ok(())
8016 }
8017}
8018#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8019#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8020pub struct EscortRecedeEvent {
8021 pub team: u8,
8022 pub recede_time: f32,
8023}
8024impl EscortRecedeEvent {
8025 #[allow(unused_variables)]
8026 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8027 Ok(EscortRecedeEvent {
8028 team: read_value::<u8>(
8029 stream,
8030 definition.get_entry(18024489754618217260u64),
8031 "team",
8032 )?,
8033 recede_time: read_value::<f32>(
8034 stream,
8035 definition.get_entry(12986815124312535790u64),
8036 "recede_time",
8037 )?,
8038 })
8039 }
8040 #[allow(unused_variables)]
8041 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8042 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8043 match field.hash {
8044 18024489754618217260u64 => Ok(self.team.clone().into()),
8045 12986815124312535790u64 => Ok(self.recede_time.clone().into()),
8046 _ => Err(ParseError::MissingGameEventValue {
8047 ty: "EscortRecede",
8048 field: "todo".into(),
8049 }),
8050 }
8051 }
8052 #[allow(unused_variables)]
8053 fn write(
8054 &self,
8055 stream: &mut BitWriteStream<LittleEndian>,
8056 definition: &GameEventDefinition,
8057 ) -> Result<()> {
8058 for entry in &definition.entries {
8059 let value = self
8060 .get_field(entry)
8061 .unwrap_or_else(|_| entry.kind.default_value());
8062 stream.write(&value)?;
8063 }
8064 Ok(())
8065 }
8066}
8067#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8068#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8069pub struct GameUIActivatedEvent {}
8070impl GameUIActivatedEvent {
8071 #[allow(unused_variables)]
8072 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8073 Ok(GameUIActivatedEvent {})
8074 }
8075 #[allow(unused_variables)]
8076 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8077 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8078 match field.hash {
8079 _ => Err(ParseError::MissingGameEventValue {
8080 ty: "GameUIActivated",
8081 field: "todo".into(),
8082 }),
8083 }
8084 }
8085 #[allow(unused_variables)]
8086 fn write(
8087 &self,
8088 stream: &mut BitWriteStream<LittleEndian>,
8089 definition: &GameEventDefinition,
8090 ) -> Result<()> {
8091 for entry in &definition.entries {
8092 let value = self
8093 .get_field(entry)
8094 .unwrap_or_else(|_| entry.kind.default_value());
8095 stream.write(&value)?;
8096 }
8097 Ok(())
8098 }
8099}
8100#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8101#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8102pub struct GameUIHiddenEvent {}
8103impl GameUIHiddenEvent {
8104 #[allow(unused_variables)]
8105 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8106 Ok(GameUIHiddenEvent {})
8107 }
8108 #[allow(unused_variables)]
8109 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8110 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8111 match field.hash {
8112 _ => Err(ParseError::MissingGameEventValue {
8113 ty: "GameUIHidden",
8114 field: "todo".into(),
8115 }),
8116 }
8117 }
8118 #[allow(unused_variables)]
8119 fn write(
8120 &self,
8121 stream: &mut BitWriteStream<LittleEndian>,
8122 definition: &GameEventDefinition,
8123 ) -> Result<()> {
8124 for entry in &definition.entries {
8125 let value = self
8126 .get_field(entry)
8127 .unwrap_or_else(|_| entry.kind.default_value());
8128 stream.write(&value)?;
8129 }
8130 Ok(())
8131 }
8132}
8133#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8134#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8135pub struct PlayerEscortScoreEvent {
8136 pub player: u8,
8137 pub points: u8,
8138}
8139impl PlayerEscortScoreEvent {
8140 #[allow(unused_variables)]
8141 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8142 Ok(PlayerEscortScoreEvent {
8143 player: read_value::<u8>(
8144 stream,
8145 definition.get_entry(5008278420455340480u64),
8146 "player",
8147 )?,
8148 points: read_value::<u8>(
8149 stream,
8150 definition.get_entry(15925482014108518566u64),
8151 "points",
8152 )?,
8153 })
8154 }
8155 #[allow(unused_variables)]
8156 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8157 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8158 match field.hash {
8159 5008278420455340480u64 => Ok(self.player.clone().into()),
8160 15925482014108518566u64 => Ok(self.points.clone().into()),
8161 _ => Err(ParseError::MissingGameEventValue {
8162 ty: "PlayerEscortScore",
8163 field: "todo".into(),
8164 }),
8165 }
8166 }
8167 #[allow(unused_variables)]
8168 fn write(
8169 &self,
8170 stream: &mut BitWriteStream<LittleEndian>,
8171 definition: &GameEventDefinition,
8172 ) -> Result<()> {
8173 for entry in &definition.entries {
8174 let value = self
8175 .get_field(entry)
8176 .unwrap_or_else(|_| entry.kind.default_value());
8177 stream.write(&value)?;
8178 }
8179 Ok(())
8180 }
8181}
8182#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8183#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8184pub struct PlayerHealOnHitEvent {
8185 pub amount: u16,
8186 pub ent_index: u8,
8187 pub weapon_def_index: u32,
8188}
8189impl PlayerHealOnHitEvent {
8190 #[allow(unused_variables)]
8191 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8192 Ok(PlayerHealOnHitEvent {
8193 amount: read_value::<u16>(
8194 stream,
8195 definition.get_entry(9301057475299076457u64),
8196 "amount",
8197 )?,
8198 ent_index: read_value::<u8>(
8199 stream,
8200 definition.get_entry(17554918082946193550u64),
8201 "ent_index",
8202 )?,
8203 weapon_def_index: read_value::<u32>(
8204 stream,
8205 definition.get_entry(4132306594868589054u64),
8206 "weapon_def_index",
8207 )?,
8208 })
8209 }
8210 #[allow(unused_variables)]
8211 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8212 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8213 match field.hash {
8214 9301057475299076457u64 => Ok(self.amount.clone().into()),
8215 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
8216 4132306594868589054u64 => Ok(self.weapon_def_index.clone().into()),
8217 _ => Err(ParseError::MissingGameEventValue {
8218 ty: "PlayerHealOnHit",
8219 field: "todo".into(),
8220 }),
8221 }
8222 }
8223 #[allow(unused_variables)]
8224 fn write(
8225 &self,
8226 stream: &mut BitWriteStream<LittleEndian>,
8227 definition: &GameEventDefinition,
8228 ) -> Result<()> {
8229 for entry in &definition.entries {
8230 let value = self
8231 .get_field(entry)
8232 .unwrap_or_else(|_| entry.kind.default_value());
8233 stream.write(&value)?;
8234 }
8235 Ok(())
8236 }
8237}
8238#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8239#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8240pub struct PlayerStealSandvichEvent {
8241 pub owner: u16,
8242 pub target: u16,
8243}
8244impl PlayerStealSandvichEvent {
8245 #[allow(unused_variables)]
8246 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8247 Ok(PlayerStealSandvichEvent {
8248 owner: read_value::<u16>(
8249 stream,
8250 definition.get_entry(12002927925776846068u64),
8251 "owner",
8252 )?,
8253 target: read_value::<u16>(
8254 stream,
8255 definition.get_entry(1653916590517707752u64),
8256 "target",
8257 )?,
8258 })
8259 }
8260 #[allow(unused_variables)]
8261 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8262 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8263 match field.hash {
8264 12002927925776846068u64 => Ok(self.owner.clone().into()),
8265 1653916590517707752u64 => Ok(self.target.clone().into()),
8266 _ => Err(ParseError::MissingGameEventValue {
8267 ty: "PlayerStealSandvich",
8268 field: "todo".into(),
8269 }),
8270 }
8271 }
8272 #[allow(unused_variables)]
8273 fn write(
8274 &self,
8275 stream: &mut BitWriteStream<LittleEndian>,
8276 definition: &GameEventDefinition,
8277 ) -> Result<()> {
8278 for entry in &definition.entries {
8279 let value = self
8280 .get_field(entry)
8281 .unwrap_or_else(|_| entry.kind.default_value());
8282 stream.write(&value)?;
8283 }
8284 Ok(())
8285 }
8286}
8287#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8288#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8289pub struct ShowClassLayoutEvent {
8290 pub show: bool,
8291}
8292impl ShowClassLayoutEvent {
8293 #[allow(unused_variables)]
8294 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8295 Ok(ShowClassLayoutEvent {
8296 show: read_value::<bool>(stream, definition.get_entry(5106060638016120252u64), "show")?,
8297 })
8298 }
8299 #[allow(unused_variables)]
8300 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8301 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8302 match field.hash {
8303 5106060638016120252u64 => Ok(self.show.clone().into()),
8304 _ => Err(ParseError::MissingGameEventValue {
8305 ty: "ShowClassLayout",
8306 field: "todo".into(),
8307 }),
8308 }
8309 }
8310 #[allow(unused_variables)]
8311 fn write(
8312 &self,
8313 stream: &mut BitWriteStream<LittleEndian>,
8314 definition: &GameEventDefinition,
8315 ) -> Result<()> {
8316 for entry in &definition.entries {
8317 let value = self
8318 .get_field(entry)
8319 .unwrap_or_else(|_| entry.kind.default_value());
8320 stream.write(&value)?;
8321 }
8322 Ok(())
8323 }
8324}
8325#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8326#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8327pub struct ShowVsPanelEvent {
8328 pub show: bool,
8329}
8330impl ShowVsPanelEvent {
8331 #[allow(unused_variables)]
8332 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8333 Ok(ShowVsPanelEvent {
8334 show: read_value::<bool>(stream, definition.get_entry(5106060638016120252u64), "show")?,
8335 })
8336 }
8337 #[allow(unused_variables)]
8338 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8339 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8340 match field.hash {
8341 5106060638016120252u64 => Ok(self.show.clone().into()),
8342 _ => Err(ParseError::MissingGameEventValue {
8343 ty: "ShowVsPanel",
8344 field: "todo".into(),
8345 }),
8346 }
8347 }
8348 #[allow(unused_variables)]
8349 fn write(
8350 &self,
8351 stream: &mut BitWriteStream<LittleEndian>,
8352 definition: &GameEventDefinition,
8353 ) -> Result<()> {
8354 for entry in &definition.entries {
8355 let value = self
8356 .get_field(entry)
8357 .unwrap_or_else(|_| entry.kind.default_value());
8358 stream.write(&value)?;
8359 }
8360 Ok(())
8361 }
8362}
8363#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8364#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8365pub struct PlayerDamagedEvent {
8366 pub amount: u16,
8367 pub kind: u32,
8368}
8369impl PlayerDamagedEvent {
8370 #[allow(unused_variables)]
8371 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8372 Ok(PlayerDamagedEvent {
8373 amount: read_value::<u16>(
8374 stream,
8375 definition.get_entry(9301057475299076457u64),
8376 "amount",
8377 )?,
8378 kind: read_value::<u32>(
8379 stream,
8380 definition.get_entry(12075340201627130925u64),
8381 "kind",
8382 )?,
8383 })
8384 }
8385 #[allow(unused_variables)]
8386 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8387 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8388 match field.hash {
8389 9301057475299076457u64 => Ok(self.amount.clone().into()),
8390 12075340201627130925u64 => Ok(self.kind.clone().into()),
8391 _ => Err(ParseError::MissingGameEventValue {
8392 ty: "PlayerDamaged",
8393 field: "todo".into(),
8394 }),
8395 }
8396 }
8397 #[allow(unused_variables)]
8398 fn write(
8399 &self,
8400 stream: &mut BitWriteStream<LittleEndian>,
8401 definition: &GameEventDefinition,
8402 ) -> Result<()> {
8403 for entry in &definition.entries {
8404 let value = self
8405 .get_field(entry)
8406 .unwrap_or_else(|_| entry.kind.default_value());
8407 stream.write(&value)?;
8408 }
8409 Ok(())
8410 }
8411}
8412#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8413#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8414pub struct ArenaPlayerNotificationEvent {
8415 pub player: u8,
8416 pub message: u8,
8417}
8418impl ArenaPlayerNotificationEvent {
8419 #[allow(unused_variables)]
8420 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8421 Ok(ArenaPlayerNotificationEvent {
8422 player: read_value::<u8>(
8423 stream,
8424 definition.get_entry(5008278420455340480u64),
8425 "player",
8426 )?,
8427 message: read_value::<u8>(
8428 stream,
8429 definition.get_entry(6080987277291999908u64),
8430 "message",
8431 )?,
8432 })
8433 }
8434 #[allow(unused_variables)]
8435 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8436 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8437 match field.hash {
8438 5008278420455340480u64 => Ok(self.player.clone().into()),
8439 6080987277291999908u64 => Ok(self.message.clone().into()),
8440 _ => Err(ParseError::MissingGameEventValue {
8441 ty: "ArenaPlayerNotification",
8442 field: "todo".into(),
8443 }),
8444 }
8445 }
8446 #[allow(unused_variables)]
8447 fn write(
8448 &self,
8449 stream: &mut BitWriteStream<LittleEndian>,
8450 definition: &GameEventDefinition,
8451 ) -> Result<()> {
8452 for entry in &definition.entries {
8453 let value = self
8454 .get_field(entry)
8455 .unwrap_or_else(|_| entry.kind.default_value());
8456 stream.write(&value)?;
8457 }
8458 Ok(())
8459 }
8460}
8461#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8462#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8463pub struct ArenaMatchMaxStreakEvent {
8464 pub team: u8,
8465 pub streak: u8,
8466}
8467impl ArenaMatchMaxStreakEvent {
8468 #[allow(unused_variables)]
8469 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8470 Ok(ArenaMatchMaxStreakEvent {
8471 team: read_value::<u8>(
8472 stream,
8473 definition.get_entry(18024489754618217260u64),
8474 "team",
8475 )?,
8476 streak: read_value::<u8>(
8477 stream,
8478 definition.get_entry(5722439984700485459u64),
8479 "streak",
8480 )?,
8481 })
8482 }
8483 #[allow(unused_variables)]
8484 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8485 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8486 match field.hash {
8487 18024489754618217260u64 => Ok(self.team.clone().into()),
8488 5722439984700485459u64 => Ok(self.streak.clone().into()),
8489 _ => Err(ParseError::MissingGameEventValue {
8490 ty: "ArenaMatchMaxStreak",
8491 field: "todo".into(),
8492 }),
8493 }
8494 }
8495 #[allow(unused_variables)]
8496 fn write(
8497 &self,
8498 stream: &mut BitWriteStream<LittleEndian>,
8499 definition: &GameEventDefinition,
8500 ) -> Result<()> {
8501 for entry in &definition.entries {
8502 let value = self
8503 .get_field(entry)
8504 .unwrap_or_else(|_| entry.kind.default_value());
8505 stream.write(&value)?;
8506 }
8507 Ok(())
8508 }
8509}
8510#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8511#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8512pub struct ArenaRoundStartEvent {}
8513impl ArenaRoundStartEvent {
8514 #[allow(unused_variables)]
8515 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8516 Ok(ArenaRoundStartEvent {})
8517 }
8518 #[allow(unused_variables)]
8519 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8520 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8521 match field.hash {
8522 _ => Err(ParseError::MissingGameEventValue {
8523 ty: "ArenaRoundStart",
8524 field: "todo".into(),
8525 }),
8526 }
8527 }
8528 #[allow(unused_variables)]
8529 fn write(
8530 &self,
8531 stream: &mut BitWriteStream<LittleEndian>,
8532 definition: &GameEventDefinition,
8533 ) -> Result<()> {
8534 for entry in &definition.entries {
8535 let value = self
8536 .get_field(entry)
8537 .unwrap_or_else(|_| entry.kind.default_value());
8538 stream.write(&value)?;
8539 }
8540 Ok(())
8541 }
8542}
8543#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8544#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8545pub struct ArenaWinPanelEvent {
8546 pub panel_style: u8,
8547 pub winning_team: u8,
8548 pub win_reason: u8,
8549 pub cappers: MaybeUtf8String,
8550 pub flag_cap_limit: u16,
8551 pub blue_score: u16,
8552 pub red_score: u16,
8553 pub blue_score_prev: u16,
8554 pub red_score_prev: u16,
8555 pub round_complete: u16,
8556 pub player_1: u16,
8557 pub player_1_damage: u16,
8558 pub player_1_healing: u16,
8559 pub player_1_lifetime: u16,
8560 pub player_1_kills: u16,
8561 pub player_2: u16,
8562 pub player_2_damage: u16,
8563 pub player_2_healing: u16,
8564 pub player_2_lifetime: u16,
8565 pub player_2_kills: u16,
8566 pub player_3: u16,
8567 pub player_3_damage: u16,
8568 pub player_3_healing: u16,
8569 pub player_3_lifetime: u16,
8570 pub player_3_kills: u16,
8571 pub player_4: u16,
8572 pub player_4_damage: u16,
8573 pub player_4_healing: u16,
8574 pub player_4_lifetime: u16,
8575 pub player_4_kills: u16,
8576 pub player_5: u16,
8577 pub player_5_damage: u16,
8578 pub player_5_healing: u16,
8579 pub player_5_lifetime: u16,
8580 pub player_5_kills: u16,
8581 pub player_6: u16,
8582 pub player_6_damage: u16,
8583 pub player_6_healing: u16,
8584 pub player_6_lifetime: u16,
8585 pub player_6_kills: u16,
8586}
8587impl ArenaWinPanelEvent {
8588 #[allow(unused_variables)]
8589 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8590 Ok(ArenaWinPanelEvent {
8591 panel_style: read_value::<u8>(
8592 stream,
8593 definition.get_entry(3076948889484157827u64),
8594 "panel_style",
8595 )?,
8596 winning_team: read_value::<u8>(
8597 stream,
8598 definition.get_entry(12760025138952247085u64),
8599 "winning_team",
8600 )?,
8601 win_reason: read_value::<u8>(
8602 stream,
8603 definition.get_entry(3803421146477351589u64),
8604 "win_reason",
8605 )?,
8606 cappers: read_value::<MaybeUtf8String>(
8607 stream,
8608 definition.get_entry(11245576010855792123u64),
8609 "cappers",
8610 )?,
8611 flag_cap_limit: read_value::<u16>(
8612 stream,
8613 definition.get_entry(8774624256288798788u64),
8614 "flag_cap_limit",
8615 )?,
8616 blue_score: read_value::<u16>(
8617 stream,
8618 definition.get_entry(12881173953286901124u64),
8619 "blue_score",
8620 )?,
8621 red_score: read_value::<u16>(
8622 stream,
8623 definition.get_entry(1115892277897790273u64),
8624 "red_score",
8625 )?,
8626 blue_score_prev: read_value::<u16>(
8627 stream,
8628 definition.get_entry(12382344057664863052u64),
8629 "blue_score_prev",
8630 )?,
8631 red_score_prev: read_value::<u16>(
8632 stream,
8633 definition.get_entry(9684982604781518527u64),
8634 "red_score_prev",
8635 )?,
8636 round_complete: read_value::<u16>(
8637 stream,
8638 definition.get_entry(12165785943437780003u64),
8639 "round_complete",
8640 )?,
8641 player_1: read_value::<u16>(
8642 stream,
8643 definition.get_entry(2316304829487618708u64),
8644 "player_1",
8645 )?,
8646 player_1_damage: read_value::<u16>(
8647 stream,
8648 definition.get_entry(10394500961929970236u64),
8649 "player_1_damage",
8650 )?,
8651 player_1_healing: read_value::<u16>(
8652 stream,
8653 definition.get_entry(4434975577362185857u64),
8654 "player_1_healing",
8655 )?,
8656 player_1_lifetime: read_value::<u16>(
8657 stream,
8658 definition.get_entry(9525810424766332458u64),
8659 "player_1_lifetime",
8660 )?,
8661 player_1_kills: read_value::<u16>(
8662 stream,
8663 definition.get_entry(9144050188623277698u64),
8664 "player_1_kills",
8665 )?,
8666 player_2: read_value::<u16>(
8667 stream,
8668 definition.get_entry(2316308128022503341u64),
8669 "player_2",
8670 )?,
8671 player_2_damage: read_value::<u16>(
8672 stream,
8673 definition.get_entry(10233858120128677491u64),
8674 "player_2_damage",
8675 )?,
8676 player_2_healing: read_value::<u16>(
8677 stream,
8678 definition.get_entry(14185483197478656496u64),
8679 "player_2_healing",
8680 )?,
8681 player_2_lifetime: read_value::<u16>(
8682 stream,
8683 definition.get_entry(4136489886055437333u64),
8684 "player_2_lifetime",
8685 )?,
8686 player_2_kills: read_value::<u16>(
8687 stream,
8688 definition.get_entry(4674312054664562187u64),
8689 "player_2_kills",
8690 )?,
8691 player_3: read_value::<u16>(
8692 stream,
8693 definition.get_entry(2316307028510875130u64),
8694 "player_3",
8695 )?,
8696 player_3_damage: read_value::<u16>(
8697 stream,
8698 definition.get_entry(39363359054721358u64),
8699 "player_3_damage",
8700 )?,
8701 player_3_healing: read_value::<u16>(
8702 stream,
8703 definition.get_entry(3236287490998805827u64),
8704 "player_3_healing",
8705 )?,
8706 player_3_lifetime: read_value::<u16>(
8707 stream,
8708 definition.get_entry(14621494996524927732u64),
8709 "player_3_lifetime",
8710 )?,
8711 player_3_kills: read_value::<u16>(
8712 stream,
8713 definition.get_entry(3863298646261365396u64),
8714 "player_3_kills",
8715 )?,
8716 player_4: read_value::<u16>(
8717 stream,
8718 definition.get_entry(2316301530952734075u64),
8719 "player_4",
8720 )?,
8721 player_4_damage: read_value::<u16>(
8722 stream,
8723 definition.get_entry(10597470269304895533u64),
8724 "player_4_damage",
8725 )?,
8726 player_4_healing: read_value::<u16>(
8727 stream,
8728 definition.get_entry(16447535156948377850u64),
8729 "player_4_healing",
8730 )?,
8731 player_4_lifetime: read_value::<u16>(
8732 stream,
8733 definition.get_entry(7059298629593792111u64),
8734 "player_4_lifetime",
8735 )?,
8736 player_4_kills: read_value::<u16>(
8737 stream,
8738 definition.get_entry(3991910781166784861u64),
8739 "player_4_kills",
8740 )?,
8741 player_5: read_value::<u16>(
8742 stream,
8743 definition.get_entry(2316300431441105864u64),
8744 "player_5",
8745 )?,
8746 player_5_damage: read_value::<u16>(
8747 stream,
8748 definition.get_entry(5792678822030670832u64),
8749 "player_5_damage",
8750 )?,
8751 player_5_healing: read_value::<u16>(
8752 stream,
8753 definition.get_entry(10549804756926849709u64),
8754 "player_5_healing",
8755 )?,
8756 player_5_lifetime: read_value::<u16>(
8757 stream,
8758 definition.get_entry(5937207214365195550u64),
8759 "player_5_lifetime",
8760 )?,
8761 player_5_kills: read_value::<u16>(
8762 stream,
8763 definition.get_entry(12801315132847255054u64),
8764 "player_5_kills",
8765 )?,
8766 player_6: read_value::<u16>(
8767 stream,
8768 definition.get_entry(2316303729975990497u64),
8769 "player_6",
8770 )?,
8771 player_6_damage: read_value::<u16>(
8772 stream,
8773 definition.get_entry(11907089275040254807u64),
8774 "player_6_damage",
8775 )?,
8776 player_6_healing: read_value::<u16>(
8777 stream,
8778 definition.get_entry(12917045825324352380u64),
8779 "player_6_healing",
8780 )?,
8781 player_6_lifetime: read_value::<u16>(
8782 stream,
8783 definition.get_entry(2459117320880115529u64),
8784 "player_6_lifetime",
8785 )?,
8786 player_6_kills: read_value::<u16>(
8787 stream,
8788 definition.get_entry(9062282318485088775u64),
8789 "player_6_kills",
8790 )?,
8791 })
8792 }
8793 #[allow(unused_variables)]
8794 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8795 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8796 match field.hash {
8797 3076948889484157827u64 => Ok(self.panel_style.clone().into()),
8798 12760025138952247085u64 => Ok(self.winning_team.clone().into()),
8799 3803421146477351589u64 => Ok(self.win_reason.clone().into()),
8800 11245576010855792123u64 => Ok(self.cappers.clone().into()),
8801 8774624256288798788u64 => Ok(self.flag_cap_limit.clone().into()),
8802 12881173953286901124u64 => Ok(self.blue_score.clone().into()),
8803 1115892277897790273u64 => Ok(self.red_score.clone().into()),
8804 12382344057664863052u64 => Ok(self.blue_score_prev.clone().into()),
8805 9684982604781518527u64 => Ok(self.red_score_prev.clone().into()),
8806 12165785943437780003u64 => Ok(self.round_complete.clone().into()),
8807 2316304829487618708u64 => Ok(self.player_1.clone().into()),
8808 10394500961929970236u64 => Ok(self.player_1_damage.clone().into()),
8809 4434975577362185857u64 => Ok(self.player_1_healing.clone().into()),
8810 9525810424766332458u64 => Ok(self.player_1_lifetime.clone().into()),
8811 9144050188623277698u64 => Ok(self.player_1_kills.clone().into()),
8812 2316308128022503341u64 => Ok(self.player_2.clone().into()),
8813 10233858120128677491u64 => Ok(self.player_2_damage.clone().into()),
8814 14185483197478656496u64 => Ok(self.player_2_healing.clone().into()),
8815 4136489886055437333u64 => Ok(self.player_2_lifetime.clone().into()),
8816 4674312054664562187u64 => Ok(self.player_2_kills.clone().into()),
8817 2316307028510875130u64 => Ok(self.player_3.clone().into()),
8818 39363359054721358u64 => Ok(self.player_3_damage.clone().into()),
8819 3236287490998805827u64 => Ok(self.player_3_healing.clone().into()),
8820 14621494996524927732u64 => Ok(self.player_3_lifetime.clone().into()),
8821 3863298646261365396u64 => Ok(self.player_3_kills.clone().into()),
8822 2316301530952734075u64 => Ok(self.player_4.clone().into()),
8823 10597470269304895533u64 => Ok(self.player_4_damage.clone().into()),
8824 16447535156948377850u64 => Ok(self.player_4_healing.clone().into()),
8825 7059298629593792111u64 => Ok(self.player_4_lifetime.clone().into()),
8826 3991910781166784861u64 => Ok(self.player_4_kills.clone().into()),
8827 2316300431441105864u64 => Ok(self.player_5.clone().into()),
8828 5792678822030670832u64 => Ok(self.player_5_damage.clone().into()),
8829 10549804756926849709u64 => Ok(self.player_5_healing.clone().into()),
8830 5937207214365195550u64 => Ok(self.player_5_lifetime.clone().into()),
8831 12801315132847255054u64 => Ok(self.player_5_kills.clone().into()),
8832 2316303729975990497u64 => Ok(self.player_6.clone().into()),
8833 11907089275040254807u64 => Ok(self.player_6_damage.clone().into()),
8834 12917045825324352380u64 => Ok(self.player_6_healing.clone().into()),
8835 2459117320880115529u64 => Ok(self.player_6_lifetime.clone().into()),
8836 9062282318485088775u64 => Ok(self.player_6_kills.clone().into()),
8837 _ => Err(ParseError::MissingGameEventValue {
8838 ty: "ArenaWinPanel",
8839 field: "todo".into(),
8840 }),
8841 }
8842 }
8843 #[allow(unused_variables)]
8844 fn write(
8845 &self,
8846 stream: &mut BitWriteStream<LittleEndian>,
8847 definition: &GameEventDefinition,
8848 ) -> Result<()> {
8849 for entry in &definition.entries {
8850 let value = self
8851 .get_field(entry)
8852 .unwrap_or_else(|_| entry.kind.default_value());
8853 stream.write(&value)?;
8854 }
8855 Ok(())
8856 }
8857}
8858#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8859#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8860pub struct PveWinPanelEvent {
8861 pub panel_style: u8,
8862 pub winning_team: u8,
8863 pub win_reason: u8,
8864}
8865impl PveWinPanelEvent {
8866 #[allow(unused_variables)]
8867 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8868 Ok(PveWinPanelEvent {
8869 panel_style: read_value::<u8>(
8870 stream,
8871 definition.get_entry(3076948889484157827u64),
8872 "panel_style",
8873 )?,
8874 winning_team: read_value::<u8>(
8875 stream,
8876 definition.get_entry(12760025138952247085u64),
8877 "winning_team",
8878 )?,
8879 win_reason: read_value::<u8>(
8880 stream,
8881 definition.get_entry(3803421146477351589u64),
8882 "win_reason",
8883 )?,
8884 })
8885 }
8886 #[allow(unused_variables)]
8887 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8888 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8889 match field.hash {
8890 3076948889484157827u64 => Ok(self.panel_style.clone().into()),
8891 12760025138952247085u64 => Ok(self.winning_team.clone().into()),
8892 3803421146477351589u64 => Ok(self.win_reason.clone().into()),
8893 _ => Err(ParseError::MissingGameEventValue {
8894 ty: "PveWinPanel",
8895 field: "todo".into(),
8896 }),
8897 }
8898 }
8899 #[allow(unused_variables)]
8900 fn write(
8901 &self,
8902 stream: &mut BitWriteStream<LittleEndian>,
8903 definition: &GameEventDefinition,
8904 ) -> Result<()> {
8905 for entry in &definition.entries {
8906 let value = self
8907 .get_field(entry)
8908 .unwrap_or_else(|_| entry.kind.default_value());
8909 stream.write(&value)?;
8910 }
8911 Ok(())
8912 }
8913}
8914#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8915#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8916pub struct AirDashEvent {
8917 pub player: u8,
8918}
8919impl AirDashEvent {
8920 #[allow(unused_variables)]
8921 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8922 Ok(AirDashEvent {
8923 player: read_value::<u8>(
8924 stream,
8925 definition.get_entry(5008278420455340480u64),
8926 "player",
8927 )?,
8928 })
8929 }
8930 #[allow(unused_variables)]
8931 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8932 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8933 match field.hash {
8934 5008278420455340480u64 => Ok(self.player.clone().into()),
8935 _ => Err(ParseError::MissingGameEventValue {
8936 ty: "AirDash",
8937 field: "todo".into(),
8938 }),
8939 }
8940 }
8941 #[allow(unused_variables)]
8942 fn write(
8943 &self,
8944 stream: &mut BitWriteStream<LittleEndian>,
8945 definition: &GameEventDefinition,
8946 ) -> Result<()> {
8947 for entry in &definition.entries {
8948 let value = self
8949 .get_field(entry)
8950 .unwrap_or_else(|_| entry.kind.default_value());
8951 stream.write(&value)?;
8952 }
8953 Ok(())
8954 }
8955}
8956#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8957#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
8958pub struct LandedEvent {
8959 pub player: u8,
8960}
8961impl LandedEvent {
8962 #[allow(unused_variables)]
8963 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
8964 Ok(LandedEvent {
8965 player: read_value::<u8>(
8966 stream,
8967 definition.get_entry(5008278420455340480u64),
8968 "player",
8969 )?,
8970 })
8971 }
8972 #[allow(unused_variables)]
8973 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
8974 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
8975 match field.hash {
8976 5008278420455340480u64 => Ok(self.player.clone().into()),
8977 _ => Err(ParseError::MissingGameEventValue {
8978 ty: "Landed",
8979 field: "todo".into(),
8980 }),
8981 }
8982 }
8983 #[allow(unused_variables)]
8984 fn write(
8985 &self,
8986 stream: &mut BitWriteStream<LittleEndian>,
8987 definition: &GameEventDefinition,
8988 ) -> Result<()> {
8989 for entry in &definition.entries {
8990 let value = self
8991 .get_field(entry)
8992 .unwrap_or_else(|_| entry.kind.default_value());
8993 stream.write(&value)?;
8994 }
8995 Ok(())
8996 }
8997}
8998#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
8999#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9000pub struct PlayerDamageDodgedEvent {
9001 pub damage: u16,
9002}
9003impl PlayerDamageDodgedEvent {
9004 #[allow(unused_variables)]
9005 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9006 Ok(PlayerDamageDodgedEvent {
9007 damage: read_value::<u16>(
9008 stream,
9009 definition.get_entry(9179190079975030720u64),
9010 "damage",
9011 )?,
9012 })
9013 }
9014 #[allow(unused_variables)]
9015 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9016 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9017 match field.hash {
9018 9179190079975030720u64 => Ok(self.damage.clone().into()),
9019 _ => Err(ParseError::MissingGameEventValue {
9020 ty: "PlayerDamageDodged",
9021 field: "todo".into(),
9022 }),
9023 }
9024 }
9025 #[allow(unused_variables)]
9026 fn write(
9027 &self,
9028 stream: &mut BitWriteStream<LittleEndian>,
9029 definition: &GameEventDefinition,
9030 ) -> Result<()> {
9031 for entry in &definition.entries {
9032 let value = self
9033 .get_field(entry)
9034 .unwrap_or_else(|_| entry.kind.default_value());
9035 stream.write(&value)?;
9036 }
9037 Ok(())
9038 }
9039}
9040#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9041#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9042pub struct PlayerStunnedEvent {
9043 pub stunner: u16,
9044 pub victim: u16,
9045 pub victim_capping: bool,
9046 pub big_stun: bool,
9047}
9048impl PlayerStunnedEvent {
9049 #[allow(unused_variables)]
9050 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9051 Ok(PlayerStunnedEvent {
9052 stunner: read_value::<u16>(
9053 stream,
9054 definition.get_entry(14931815241283043822u64),
9055 "stunner",
9056 )?,
9057 victim: read_value::<u16>(
9058 stream,
9059 definition.get_entry(3120917251440744469u64),
9060 "victim",
9061 )?,
9062 victim_capping: read_value::<bool>(
9063 stream,
9064 definition.get_entry(6103089581884104798u64),
9065 "victim_capping",
9066 )?,
9067 big_stun: read_value::<bool>(
9068 stream,
9069 definition.get_entry(2754291295915618874u64),
9070 "big_stun",
9071 )?,
9072 })
9073 }
9074 #[allow(unused_variables)]
9075 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9076 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9077 match field.hash {
9078 14931815241283043822u64 => Ok(self.stunner.clone().into()),
9079 3120917251440744469u64 => Ok(self.victim.clone().into()),
9080 6103089581884104798u64 => Ok(self.victim_capping.clone().into()),
9081 2754291295915618874u64 => Ok(self.big_stun.clone().into()),
9082 _ => Err(ParseError::MissingGameEventValue {
9083 ty: "PlayerStunned",
9084 field: "todo".into(),
9085 }),
9086 }
9087 }
9088 #[allow(unused_variables)]
9089 fn write(
9090 &self,
9091 stream: &mut BitWriteStream<LittleEndian>,
9092 definition: &GameEventDefinition,
9093 ) -> Result<()> {
9094 for entry in &definition.entries {
9095 let value = self
9096 .get_field(entry)
9097 .unwrap_or_else(|_| entry.kind.default_value());
9098 stream.write(&value)?;
9099 }
9100 Ok(())
9101 }
9102}
9103#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9104#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9105pub struct ScoutGrandSlamEvent {
9106 pub scout_id: u16,
9107 pub target_id: u16,
9108}
9109impl ScoutGrandSlamEvent {
9110 #[allow(unused_variables)]
9111 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9112 Ok(ScoutGrandSlamEvent {
9113 scout_id: read_value::<u16>(
9114 stream,
9115 definition.get_entry(7064780806045746163u64),
9116 "scout_id",
9117 )?,
9118 target_id: read_value::<u16>(
9119 stream,
9120 definition.get_entry(13239627154349772880u64),
9121 "target_id",
9122 )?,
9123 })
9124 }
9125 #[allow(unused_variables)]
9126 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9127 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9128 match field.hash {
9129 7064780806045746163u64 => Ok(self.scout_id.clone().into()),
9130 13239627154349772880u64 => Ok(self.target_id.clone().into()),
9131 _ => Err(ParseError::MissingGameEventValue {
9132 ty: "ScoutGrandSlam",
9133 field: "todo".into(),
9134 }),
9135 }
9136 }
9137 #[allow(unused_variables)]
9138 fn write(
9139 &self,
9140 stream: &mut BitWriteStream<LittleEndian>,
9141 definition: &GameEventDefinition,
9142 ) -> Result<()> {
9143 for entry in &definition.entries {
9144 let value = self
9145 .get_field(entry)
9146 .unwrap_or_else(|_| entry.kind.default_value());
9147 stream.write(&value)?;
9148 }
9149 Ok(())
9150 }
9151}
9152#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9153#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9154pub struct ScoutSlamdollLandedEvent {
9155 pub target_index: u16,
9156 pub x: f32,
9157 pub y: f32,
9158 pub z: f32,
9159}
9160impl ScoutSlamdollLandedEvent {
9161 #[allow(unused_variables)]
9162 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9163 Ok(ScoutSlamdollLandedEvent {
9164 target_index: read_value::<u16>(
9165 stream,
9166 definition.get_entry(654399427416389339u64),
9167 "target_index",
9168 )?,
9169 x: read_value::<f32>(stream, definition.get_entry(12638214688346347271u64), "x")?,
9170 y: read_value::<f32>(stream, definition.get_entry(12638213588834719060u64), "y")?,
9171 z: read_value::<f32>(stream, definition.get_entry(12638216887369603693u64), "z")?,
9172 })
9173 }
9174 #[allow(unused_variables)]
9175 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9176 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9177 match field.hash {
9178 654399427416389339u64 => Ok(self.target_index.clone().into()),
9179 12638214688346347271u64 => Ok(self.x.clone().into()),
9180 12638213588834719060u64 => Ok(self.y.clone().into()),
9181 12638216887369603693u64 => Ok(self.z.clone().into()),
9182 _ => Err(ParseError::MissingGameEventValue {
9183 ty: "ScoutSlamdollLanded",
9184 field: "todo".into(),
9185 }),
9186 }
9187 }
9188 #[allow(unused_variables)]
9189 fn write(
9190 &self,
9191 stream: &mut BitWriteStream<LittleEndian>,
9192 definition: &GameEventDefinition,
9193 ) -> Result<()> {
9194 for entry in &definition.entries {
9195 let value = self
9196 .get_field(entry)
9197 .unwrap_or_else(|_| entry.kind.default_value());
9198 stream.write(&value)?;
9199 }
9200 Ok(())
9201 }
9202}
9203#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9204#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9205pub struct ArrowImpactEvent {
9206 pub attached_entity: u16,
9207 pub shooter: u16,
9208 pub bone_index_attached: u16,
9209 pub bone_position_x: f32,
9210 pub bone_position_y: f32,
9211 pub bone_position_z: f32,
9212 pub bone_angles_x: f32,
9213 pub bone_angles_y: f32,
9214 pub bone_angles_z: f32,
9215 pub projectile_type: u16,
9216 pub is_crit: bool,
9217}
9218impl ArrowImpactEvent {
9219 #[allow(unused_variables)]
9220 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9221 Ok(ArrowImpactEvent {
9222 attached_entity: read_value::<u16>(
9223 stream,
9224 definition.get_entry(961881214683019338u64),
9225 "attached_entity",
9226 )?,
9227 shooter: read_value::<u16>(
9228 stream,
9229 definition.get_entry(13826298252589476871u64),
9230 "shooter",
9231 )?,
9232 bone_index_attached: read_value::<u16>(
9233 stream,
9234 definition.get_entry(6360700909751330309u64),
9235 "bone_index_attached",
9236 )?,
9237 bone_position_x: read_value::<f32>(
9238 stream,
9239 definition.get_entry(10378941398473653372u64),
9240 "bone_position_x",
9241 )?,
9242 bone_position_y: read_value::<f32>(
9243 stream,
9244 definition.get_entry(10378942497985281583u64),
9245 "bone_position_y",
9246 )?,
9247 bone_position_z: read_value::<f32>(
9248 stream,
9249 definition.get_entry(10378943597496909794u64),
9250 "bone_position_z",
9251 )?,
9252 bone_angles_x: read_value::<f32>(
9253 stream,
9254 definition.get_entry(5043211860521425589u64),
9255 "bone_angles_x",
9256 )?,
9257 bone_angles_y: read_value::<f32>(
9258 stream,
9259 definition.get_entry(5043210761009797378u64),
9260 "bone_angles_y",
9261 )?,
9262 bone_angles_z: read_value::<f32>(
9263 stream,
9264 definition.get_entry(5043209661498169167u64),
9265 "bone_angles_z",
9266 )?,
9267 projectile_type: read_value::<u16>(
9268 stream,
9269 definition.get_entry(9968460680690579194u64),
9270 "projectile_type",
9271 )?,
9272 is_crit: read_value::<bool>(
9273 stream,
9274 definition.get_entry(15363801587511353021u64),
9275 "is_crit",
9276 )?,
9277 })
9278 }
9279 #[allow(unused_variables)]
9280 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9281 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9282 match field.hash {
9283 961881214683019338u64 => Ok(self.attached_entity.clone().into()),
9284 13826298252589476871u64 => Ok(self.shooter.clone().into()),
9285 6360700909751330309u64 => Ok(self.bone_index_attached.clone().into()),
9286 10378941398473653372u64 => Ok(self.bone_position_x.clone().into()),
9287 10378942497985281583u64 => Ok(self.bone_position_y.clone().into()),
9288 10378943597496909794u64 => Ok(self.bone_position_z.clone().into()),
9289 5043211860521425589u64 => Ok(self.bone_angles_x.clone().into()),
9290 5043210761009797378u64 => Ok(self.bone_angles_y.clone().into()),
9291 5043209661498169167u64 => Ok(self.bone_angles_z.clone().into()),
9292 9968460680690579194u64 => Ok(self.projectile_type.clone().into()),
9293 15363801587511353021u64 => Ok(self.is_crit.clone().into()),
9294 _ => Err(ParseError::MissingGameEventValue {
9295 ty: "ArrowImpact",
9296 field: "todo".into(),
9297 }),
9298 }
9299 }
9300 #[allow(unused_variables)]
9301 fn write(
9302 &self,
9303 stream: &mut BitWriteStream<LittleEndian>,
9304 definition: &GameEventDefinition,
9305 ) -> Result<()> {
9306 for entry in &definition.entries {
9307 let value = self
9308 .get_field(entry)
9309 .unwrap_or_else(|_| entry.kind.default_value());
9310 stream.write(&value)?;
9311 }
9312 Ok(())
9313 }
9314}
9315#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9316#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9317pub struct PlayerJaratedEvent {
9318 pub thrower_ent_index: u8,
9319 pub victim_ent_index: u8,
9320}
9321impl PlayerJaratedEvent {
9322 #[allow(unused_variables)]
9323 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9324 Ok(PlayerJaratedEvent {
9325 thrower_ent_index: read_value::<u8>(
9326 stream,
9327 definition.get_entry(7733252424873930810u64),
9328 "thrower_ent_index",
9329 )?,
9330 victim_ent_index: read_value::<u8>(
9331 stream,
9332 definition.get_entry(7608903543976233025u64),
9333 "victim_ent_index",
9334 )?,
9335 })
9336 }
9337 #[allow(unused_variables)]
9338 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9339 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9340 match field.hash {
9341 7733252424873930810u64 => Ok(self.thrower_ent_index.clone().into()),
9342 7608903543976233025u64 => Ok(self.victim_ent_index.clone().into()),
9343 _ => Err(ParseError::MissingGameEventValue {
9344 ty: "PlayerJarated",
9345 field: "todo".into(),
9346 }),
9347 }
9348 }
9349 #[allow(unused_variables)]
9350 fn write(
9351 &self,
9352 stream: &mut BitWriteStream<LittleEndian>,
9353 definition: &GameEventDefinition,
9354 ) -> Result<()> {
9355 for entry in &definition.entries {
9356 let value = self
9357 .get_field(entry)
9358 .unwrap_or_else(|_| entry.kind.default_value());
9359 stream.write(&value)?;
9360 }
9361 Ok(())
9362 }
9363}
9364#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9365#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9366pub struct PlayerJaratedFadeEvent {
9367 pub thrower_ent_index: u8,
9368 pub victim_ent_index: u8,
9369}
9370impl PlayerJaratedFadeEvent {
9371 #[allow(unused_variables)]
9372 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9373 Ok(PlayerJaratedFadeEvent {
9374 thrower_ent_index: read_value::<u8>(
9375 stream,
9376 definition.get_entry(7733252424873930810u64),
9377 "thrower_ent_index",
9378 )?,
9379 victim_ent_index: read_value::<u8>(
9380 stream,
9381 definition.get_entry(7608903543976233025u64),
9382 "victim_ent_index",
9383 )?,
9384 })
9385 }
9386 #[allow(unused_variables)]
9387 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9388 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9389 match field.hash {
9390 7733252424873930810u64 => Ok(self.thrower_ent_index.clone().into()),
9391 7608903543976233025u64 => Ok(self.victim_ent_index.clone().into()),
9392 _ => Err(ParseError::MissingGameEventValue {
9393 ty: "PlayerJaratedFade",
9394 field: "todo".into(),
9395 }),
9396 }
9397 }
9398 #[allow(unused_variables)]
9399 fn write(
9400 &self,
9401 stream: &mut BitWriteStream<LittleEndian>,
9402 definition: &GameEventDefinition,
9403 ) -> Result<()> {
9404 for entry in &definition.entries {
9405 let value = self
9406 .get_field(entry)
9407 .unwrap_or_else(|_| entry.kind.default_value());
9408 stream.write(&value)?;
9409 }
9410 Ok(())
9411 }
9412}
9413#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9414#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9415pub struct PlayerShieldBlockedEvent {
9416 pub attacker_ent_index: u8,
9417 pub blocker_ent_index: u8,
9418}
9419impl PlayerShieldBlockedEvent {
9420 #[allow(unused_variables)]
9421 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9422 Ok(PlayerShieldBlockedEvent {
9423 attacker_ent_index: read_value::<u8>(
9424 stream,
9425 definition.get_entry(1824579233645723292u64),
9426 "attacker_ent_index",
9427 )?,
9428 blocker_ent_index: read_value::<u8>(
9429 stream,
9430 definition.get_entry(1554237712520490433u64),
9431 "blocker_ent_index",
9432 )?,
9433 })
9434 }
9435 #[allow(unused_variables)]
9436 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9437 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9438 match field.hash {
9439 1824579233645723292u64 => Ok(self.attacker_ent_index.clone().into()),
9440 1554237712520490433u64 => Ok(self.blocker_ent_index.clone().into()),
9441 _ => Err(ParseError::MissingGameEventValue {
9442 ty: "PlayerShieldBlocked",
9443 field: "todo".into(),
9444 }),
9445 }
9446 }
9447 #[allow(unused_variables)]
9448 fn write(
9449 &self,
9450 stream: &mut BitWriteStream<LittleEndian>,
9451 definition: &GameEventDefinition,
9452 ) -> Result<()> {
9453 for entry in &definition.entries {
9454 let value = self
9455 .get_field(entry)
9456 .unwrap_or_else(|_| entry.kind.default_value());
9457 stream.write(&value)?;
9458 }
9459 Ok(())
9460 }
9461}
9462#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9463#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9464pub struct PlayerPinnedEvent {
9465 pub pinned: u8,
9466}
9467impl PlayerPinnedEvent {
9468 #[allow(unused_variables)]
9469 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9470 Ok(PlayerPinnedEvent {
9471 pinned: read_value::<u8>(
9472 stream,
9473 definition.get_entry(6882141757131022863u64),
9474 "pinned",
9475 )?,
9476 })
9477 }
9478 #[allow(unused_variables)]
9479 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9480 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9481 match field.hash {
9482 6882141757131022863u64 => Ok(self.pinned.clone().into()),
9483 _ => Err(ParseError::MissingGameEventValue {
9484 ty: "PlayerPinned",
9485 field: "todo".into(),
9486 }),
9487 }
9488 }
9489 #[allow(unused_variables)]
9490 fn write(
9491 &self,
9492 stream: &mut BitWriteStream<LittleEndian>,
9493 definition: &GameEventDefinition,
9494 ) -> Result<()> {
9495 for entry in &definition.entries {
9496 let value = self
9497 .get_field(entry)
9498 .unwrap_or_else(|_| entry.kind.default_value());
9499 stream.write(&value)?;
9500 }
9501 Ok(())
9502 }
9503}
9504#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9505#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9506pub struct PlayerHealedByMedicEvent {
9507 pub medic: u8,
9508}
9509impl PlayerHealedByMedicEvent {
9510 #[allow(unused_variables)]
9511 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9512 Ok(PlayerHealedByMedicEvent {
9513 medic: read_value::<u8>(
9514 stream,
9515 definition.get_entry(12912869923554243305u64),
9516 "medic",
9517 )?,
9518 })
9519 }
9520 #[allow(unused_variables)]
9521 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9522 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9523 match field.hash {
9524 12912869923554243305u64 => Ok(self.medic.clone().into()),
9525 _ => Err(ParseError::MissingGameEventValue {
9526 ty: "PlayerHealedByMedic",
9527 field: "todo".into(),
9528 }),
9529 }
9530 }
9531 #[allow(unused_variables)]
9532 fn write(
9533 &self,
9534 stream: &mut BitWriteStream<LittleEndian>,
9535 definition: &GameEventDefinition,
9536 ) -> Result<()> {
9537 for entry in &definition.entries {
9538 let value = self
9539 .get_field(entry)
9540 .unwrap_or_else(|_| entry.kind.default_value());
9541 stream.write(&value)?;
9542 }
9543 Ok(())
9544 }
9545}
9546#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9547#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9548pub struct PlayerSappedObjectEvent {
9549 pub user_id: u16,
9550 pub owner_id: u16,
9551 pub object: u8,
9552 pub sapper_id: u16,
9553}
9554impl PlayerSappedObjectEvent {
9555 #[allow(unused_variables)]
9556 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9557 Ok(PlayerSappedObjectEvent {
9558 user_id: read_value::<u16>(
9559 stream,
9560 definition.get_entry(17826443226371159423u64),
9561 "user_id",
9562 )?,
9563 owner_id: read_value::<u16>(
9564 stream,
9565 definition.get_entry(3274630577613078265u64),
9566 "owner_id",
9567 )?,
9568 object: read_value::<u8>(
9569 stream,
9570 definition.get_entry(10231808476453998586u64),
9571 "object",
9572 )?,
9573 sapper_id: read_value::<u16>(
9574 stream,
9575 definition.get_entry(14334448895032880407u64),
9576 "sapper_id",
9577 )?,
9578 })
9579 }
9580 #[allow(unused_variables)]
9581 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9582 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9583 match field.hash {
9584 17826443226371159423u64 => Ok(self.user_id.clone().into()),
9585 3274630577613078265u64 => Ok(self.owner_id.clone().into()),
9586 10231808476453998586u64 => Ok(self.object.clone().into()),
9587 14334448895032880407u64 => Ok(self.sapper_id.clone().into()),
9588 _ => Err(ParseError::MissingGameEventValue {
9589 ty: "PlayerSappedObject",
9590 field: "todo".into(),
9591 }),
9592 }
9593 }
9594 #[allow(unused_variables)]
9595 fn write(
9596 &self,
9597 stream: &mut BitWriteStream<LittleEndian>,
9598 definition: &GameEventDefinition,
9599 ) -> Result<()> {
9600 for entry in &definition.entries {
9601 let value = self
9602 .get_field(entry)
9603 .unwrap_or_else(|_| entry.kind.default_value());
9604 stream.write(&value)?;
9605 }
9606 Ok(())
9607 }
9608}
9609#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9610#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9611pub struct ItemFoundEvent {
9612 pub player: u8,
9613 pub quality: u8,
9614 pub method: u8,
9615 pub item_def: u32,
9616 pub is_strange: u8,
9617 pub is_unusual: u8,
9618 pub wear: f32,
9619}
9620impl ItemFoundEvent {
9621 #[allow(unused_variables)]
9622 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9623 Ok(ItemFoundEvent {
9624 player: read_value::<u8>(
9625 stream,
9626 definition.get_entry(5008278420455340480u64),
9627 "player",
9628 )?,
9629 quality: read_value::<u8>(
9630 stream,
9631 definition.get_entry(8827161447210483302u64),
9632 "quality",
9633 )?,
9634 method: read_value::<u8>(
9635 stream,
9636 definition.get_entry(2525399976365011888u64),
9637 "method",
9638 )?,
9639 item_def: read_value::<u32>(
9640 stream,
9641 definition.get_entry(13929934279997928333u64),
9642 "item_def",
9643 )?,
9644 is_strange: read_value::<u8>(
9645 stream,
9646 definition.get_entry(4841352240690495167u64),
9647 "is_strange",
9648 )?,
9649 is_unusual: read_value::<u8>(
9650 stream,
9651 definition.get_entry(17913208470555068296u64),
9652 "is_unusual",
9653 )?,
9654 wear: read_value::<f32>(stream, definition.get_entry(4427899308794289118u64), "wear")?,
9655 })
9656 }
9657 #[allow(unused_variables)]
9658 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9659 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9660 match field.hash {
9661 5008278420455340480u64 => Ok(self.player.clone().into()),
9662 8827161447210483302u64 => Ok(self.quality.clone().into()),
9663 2525399976365011888u64 => Ok(self.method.clone().into()),
9664 13929934279997928333u64 => Ok(self.item_def.clone().into()),
9665 4841352240690495167u64 => Ok(self.is_strange.clone().into()),
9666 17913208470555068296u64 => Ok(self.is_unusual.clone().into()),
9667 4427899308794289118u64 => Ok(self.wear.clone().into()),
9668 _ => Err(ParseError::MissingGameEventValue {
9669 ty: "ItemFound",
9670 field: "todo".into(),
9671 }),
9672 }
9673 }
9674 #[allow(unused_variables)]
9675 fn write(
9676 &self,
9677 stream: &mut BitWriteStream<LittleEndian>,
9678 definition: &GameEventDefinition,
9679 ) -> Result<()> {
9680 for entry in &definition.entries {
9681 let value = self
9682 .get_field(entry)
9683 .unwrap_or_else(|_| entry.kind.default_value());
9684 stream.write(&value)?;
9685 }
9686 Ok(())
9687 }
9688}
9689#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9690#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9691pub struct ShowAnnotationEvent {
9692 pub world_pos_x: f32,
9693 pub world_pos_y: f32,
9694 pub world_pos_z: f32,
9695 pub world_normal_x: f32,
9696 pub world_normal_y: f32,
9697 pub world_normal_z: f32,
9698 pub id: u32,
9699 pub text: MaybeUtf8String,
9700 pub lifetime: f32,
9701 pub visibility_bit_field: u32,
9702 pub follow_ent_index: u32,
9703 pub show_distance: bool,
9704 pub play_sound: MaybeUtf8String,
9705 pub show_effect: bool,
9706}
9707impl ShowAnnotationEvent {
9708 #[allow(unused_variables)]
9709 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9710 Ok(ShowAnnotationEvent {
9711 world_pos_x: read_value::<f32>(
9712 stream,
9713 definition.get_entry(17136446437287500353u64),
9714 "world_pos_x",
9715 )?,
9716 world_pos_y: read_value::<f32>(
9717 stream,
9718 definition.get_entry(17136445337775872142u64),
9719 "world_pos_y",
9720 )?,
9721 world_pos_z: read_value::<f32>(
9722 stream,
9723 definition.get_entry(17136444238264243931u64),
9724 "world_pos_z",
9725 )?,
9726 world_normal_x: read_value::<f32>(
9727 stream,
9728 definition.get_entry(6094703810714717260u64),
9729 "world_normal_x",
9730 )?,
9731 world_normal_y: read_value::<f32>(
9732 stream,
9733 definition.get_entry(6094704910226345471u64),
9734 "world_normal_y",
9735 )?,
9736 world_normal_z: read_value::<f32>(
9737 stream,
9738 definition.get_entry(6094706009737973682u64),
9739 "world_normal_z",
9740 )?,
9741 id: read_value::<u32>(stream, definition.get_entry(628021283683842752u64), "id")?,
9742 text: read_value::<MaybeUtf8String>(
9743 stream,
9744 definition.get_entry(18015793717152399486u64),
9745 "text",
9746 )?,
9747 lifetime: read_value::<f32>(
9748 stream,
9749 definition.get_entry(17408443252967694094u64),
9750 "lifetime",
9751 )?,
9752 visibility_bit_field: read_value::<u32>(
9753 stream,
9754 definition.get_entry(3514840313863479388u64),
9755 "visibility_bit_field",
9756 )?,
9757 follow_ent_index: read_value::<u32>(
9758 stream,
9759 definition.get_entry(5396668150069485958u64),
9760 "follow_ent_index",
9761 )?,
9762 show_distance: read_value::<bool>(
9763 stream,
9764 definition.get_entry(10815115409701055510u64),
9765 "show_distance",
9766 )?,
9767 play_sound: read_value::<MaybeUtf8String>(
9768 stream,
9769 definition.get_entry(9580177307637293387u64),
9770 "play_sound",
9771 )?,
9772 show_effect: read_value::<bool>(
9773 stream,
9774 definition.get_entry(16061793018411867440u64),
9775 "show_effect",
9776 )?,
9777 })
9778 }
9779 #[allow(unused_variables)]
9780 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9781 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9782 match field.hash {
9783 17136446437287500353u64 => Ok(self.world_pos_x.clone().into()),
9784 17136445337775872142u64 => Ok(self.world_pos_y.clone().into()),
9785 17136444238264243931u64 => Ok(self.world_pos_z.clone().into()),
9786 6094703810714717260u64 => Ok(self.world_normal_x.clone().into()),
9787 6094704910226345471u64 => Ok(self.world_normal_y.clone().into()),
9788 6094706009737973682u64 => Ok(self.world_normal_z.clone().into()),
9789 628021283683842752u64 => Ok(self.id.clone().into()),
9790 18015793717152399486u64 => Ok(self.text.clone().into()),
9791 17408443252967694094u64 => Ok(self.lifetime.clone().into()),
9792 3514840313863479388u64 => Ok(self.visibility_bit_field.clone().into()),
9793 5396668150069485958u64 => Ok(self.follow_ent_index.clone().into()),
9794 10815115409701055510u64 => Ok(self.show_distance.clone().into()),
9795 9580177307637293387u64 => Ok(self.play_sound.clone().into()),
9796 16061793018411867440u64 => Ok(self.show_effect.clone().into()),
9797 _ => Err(ParseError::MissingGameEventValue {
9798 ty: "ShowAnnotation",
9799 field: "todo".into(),
9800 }),
9801 }
9802 }
9803 #[allow(unused_variables)]
9804 fn write(
9805 &self,
9806 stream: &mut BitWriteStream<LittleEndian>,
9807 definition: &GameEventDefinition,
9808 ) -> Result<()> {
9809 for entry in &definition.entries {
9810 let value = self
9811 .get_field(entry)
9812 .unwrap_or_else(|_| entry.kind.default_value());
9813 stream.write(&value)?;
9814 }
9815 Ok(())
9816 }
9817}
9818#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9819#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9820pub struct HideAnnotationEvent {
9821 pub id: u32,
9822}
9823impl HideAnnotationEvent {
9824 #[allow(unused_variables)]
9825 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9826 Ok(HideAnnotationEvent {
9827 id: read_value::<u32>(stream, definition.get_entry(628021283683842752u64), "id")?,
9828 })
9829 }
9830 #[allow(unused_variables)]
9831 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9832 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9833 match field.hash {
9834 628021283683842752u64 => Ok(self.id.clone().into()),
9835 _ => Err(ParseError::MissingGameEventValue {
9836 ty: "HideAnnotation",
9837 field: "todo".into(),
9838 }),
9839 }
9840 }
9841 #[allow(unused_variables)]
9842 fn write(
9843 &self,
9844 stream: &mut BitWriteStream<LittleEndian>,
9845 definition: &GameEventDefinition,
9846 ) -> Result<()> {
9847 for entry in &definition.entries {
9848 let value = self
9849 .get_field(entry)
9850 .unwrap_or_else(|_| entry.kind.default_value());
9851 stream.write(&value)?;
9852 }
9853 Ok(())
9854 }
9855}
9856#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9857#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9858pub struct PostInventoryApplicationEvent {
9859 pub user_id: u16,
9860}
9861impl PostInventoryApplicationEvent {
9862 #[allow(unused_variables)]
9863 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9864 Ok(PostInventoryApplicationEvent {
9865 user_id: read_value::<u16>(
9866 stream,
9867 definition.get_entry(17826443226371159423u64),
9868 "user_id",
9869 )?,
9870 })
9871 }
9872 #[allow(unused_variables)]
9873 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9874 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9875 match field.hash {
9876 17826443226371159423u64 => Ok(self.user_id.clone().into()),
9877 _ => Err(ParseError::MissingGameEventValue {
9878 ty: "PostInventoryApplication",
9879 field: "todo".into(),
9880 }),
9881 }
9882 }
9883 #[allow(unused_variables)]
9884 fn write(
9885 &self,
9886 stream: &mut BitWriteStream<LittleEndian>,
9887 definition: &GameEventDefinition,
9888 ) -> Result<()> {
9889 for entry in &definition.entries {
9890 let value = self
9891 .get_field(entry)
9892 .unwrap_or_else(|_| entry.kind.default_value());
9893 stream.write(&value)?;
9894 }
9895 Ok(())
9896 }
9897}
9898#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9899#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9900pub struct ControlPointUnlockUpdatedEvent {
9901 pub index: u16,
9902 pub time: f32,
9903}
9904impl ControlPointUnlockUpdatedEvent {
9905 #[allow(unused_variables)]
9906 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9907 Ok(ControlPointUnlockUpdatedEvent {
9908 index: read_value::<u16>(
9909 stream,
9910 definition.get_entry(9497966886403524235u64),
9911 "index",
9912 )?,
9913 time: read_value::<f32>(stream, definition.get_entry(2185518981507421060u64), "time")?,
9914 })
9915 }
9916 #[allow(unused_variables)]
9917 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9918 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9919 match field.hash {
9920 9497966886403524235u64 => Ok(self.index.clone().into()),
9921 2185518981507421060u64 => Ok(self.time.clone().into()),
9922 _ => Err(ParseError::MissingGameEventValue {
9923 ty: "ControlPointUnlockUpdated",
9924 field: "todo".into(),
9925 }),
9926 }
9927 }
9928 #[allow(unused_variables)]
9929 fn write(
9930 &self,
9931 stream: &mut BitWriteStream<LittleEndian>,
9932 definition: &GameEventDefinition,
9933 ) -> Result<()> {
9934 for entry in &definition.entries {
9935 let value = self
9936 .get_field(entry)
9937 .unwrap_or_else(|_| entry.kind.default_value());
9938 stream.write(&value)?;
9939 }
9940 Ok(())
9941 }
9942}
9943#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9944#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9945pub struct DeployBuffBannerEvent {
9946 pub buff_type: u8,
9947 pub buff_owner: u16,
9948}
9949impl DeployBuffBannerEvent {
9950 #[allow(unused_variables)]
9951 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
9952 Ok(DeployBuffBannerEvent {
9953 buff_type: read_value::<u8>(
9954 stream,
9955 definition.get_entry(15706957908546287009u64),
9956 "buff_type",
9957 )?,
9958 buff_owner: read_value::<u16>(
9959 stream,
9960 definition.get_entry(16619542197404164576u64),
9961 "buff_owner",
9962 )?,
9963 })
9964 }
9965 #[allow(unused_variables)]
9966 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
9967 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
9968 match field.hash {
9969 15706957908546287009u64 => Ok(self.buff_type.clone().into()),
9970 16619542197404164576u64 => Ok(self.buff_owner.clone().into()),
9971 _ => Err(ParseError::MissingGameEventValue {
9972 ty: "DeployBuffBanner",
9973 field: "todo".into(),
9974 }),
9975 }
9976 }
9977 #[allow(unused_variables)]
9978 fn write(
9979 &self,
9980 stream: &mut BitWriteStream<LittleEndian>,
9981 definition: &GameEventDefinition,
9982 ) -> Result<()> {
9983 for entry in &definition.entries {
9984 let value = self
9985 .get_field(entry)
9986 .unwrap_or_else(|_| entry.kind.default_value());
9987 stream.write(&value)?;
9988 }
9989 Ok(())
9990 }
9991}
9992#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
9993#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
9994pub struct PlayerBuffEvent {
9995 pub user_id: u16,
9996 pub buff_owner: u16,
9997 pub buff_type: u8,
9998}
9999impl PlayerBuffEvent {
10000 #[allow(unused_variables)]
10001 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10002 Ok(PlayerBuffEvent {
10003 user_id: read_value::<u16>(
10004 stream,
10005 definition.get_entry(17826443226371159423u64),
10006 "user_id",
10007 )?,
10008 buff_owner: read_value::<u16>(
10009 stream,
10010 definition.get_entry(16619542197404164576u64),
10011 "buff_owner",
10012 )?,
10013 buff_type: read_value::<u8>(
10014 stream,
10015 definition.get_entry(15706957908546287009u64),
10016 "buff_type",
10017 )?,
10018 })
10019 }
10020 #[allow(unused_variables)]
10021 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10022 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10023 match field.hash {
10024 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10025 16619542197404164576u64 => Ok(self.buff_owner.clone().into()),
10026 15706957908546287009u64 => Ok(self.buff_type.clone().into()),
10027 _ => Err(ParseError::MissingGameEventValue {
10028 ty: "PlayerBuff",
10029 field: "todo".into(),
10030 }),
10031 }
10032 }
10033 #[allow(unused_variables)]
10034 fn write(
10035 &self,
10036 stream: &mut BitWriteStream<LittleEndian>,
10037 definition: &GameEventDefinition,
10038 ) -> Result<()> {
10039 for entry in &definition.entries {
10040 let value = self
10041 .get_field(entry)
10042 .unwrap_or_else(|_| entry.kind.default_value());
10043 stream.write(&value)?;
10044 }
10045 Ok(())
10046 }
10047}
10048#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10049#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10050pub struct MedicDeathEvent {
10051 pub user_id: u16,
10052 pub attacker: u16,
10053 pub healing: u16,
10054 pub charged: bool,
10055}
10056impl MedicDeathEvent {
10057 #[allow(unused_variables)]
10058 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10059 Ok(MedicDeathEvent {
10060 user_id: read_value::<u16>(
10061 stream,
10062 definition.get_entry(17826443226371159423u64),
10063 "user_id",
10064 )?,
10065 attacker: read_value::<u16>(
10066 stream,
10067 definition.get_entry(7198542740550218478u64),
10068 "attacker",
10069 )?,
10070 healing: read_value::<u16>(
10071 stream,
10072 definition.get_entry(2721180038881757981u64),
10073 "healing",
10074 )?,
10075 charged: read_value::<bool>(
10076 stream,
10077 definition.get_entry(17260212114554334191u64),
10078 "charged",
10079 )?,
10080 })
10081 }
10082 #[allow(unused_variables)]
10083 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10084 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10085 match field.hash {
10086 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10087 7198542740550218478u64 => Ok(self.attacker.clone().into()),
10088 2721180038881757981u64 => Ok(self.healing.clone().into()),
10089 17260212114554334191u64 => Ok(self.charged.clone().into()),
10090 _ => Err(ParseError::MissingGameEventValue {
10091 ty: "MedicDeath",
10092 field: "todo".into(),
10093 }),
10094 }
10095 }
10096 #[allow(unused_variables)]
10097 fn write(
10098 &self,
10099 stream: &mut BitWriteStream<LittleEndian>,
10100 definition: &GameEventDefinition,
10101 ) -> Result<()> {
10102 for entry in &definition.entries {
10103 let value = self
10104 .get_field(entry)
10105 .unwrap_or_else(|_| entry.kind.default_value());
10106 stream.write(&value)?;
10107 }
10108 Ok(())
10109 }
10110}
10111#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10112#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10113pub struct OvertimeNagEvent {}
10114impl OvertimeNagEvent {
10115 #[allow(unused_variables)]
10116 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10117 Ok(OvertimeNagEvent {})
10118 }
10119 #[allow(unused_variables)]
10120 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10121 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10122 match field.hash {
10123 _ => Err(ParseError::MissingGameEventValue {
10124 ty: "OvertimeNag",
10125 field: "todo".into(),
10126 }),
10127 }
10128 }
10129 #[allow(unused_variables)]
10130 fn write(
10131 &self,
10132 stream: &mut BitWriteStream<LittleEndian>,
10133 definition: &GameEventDefinition,
10134 ) -> Result<()> {
10135 for entry in &definition.entries {
10136 let value = self
10137 .get_field(entry)
10138 .unwrap_or_else(|_| entry.kind.default_value());
10139 stream.write(&value)?;
10140 }
10141 Ok(())
10142 }
10143}
10144#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10145#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10146pub struct TeamsChangedEvent {}
10147impl TeamsChangedEvent {
10148 #[allow(unused_variables)]
10149 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10150 Ok(TeamsChangedEvent {})
10151 }
10152 #[allow(unused_variables)]
10153 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10154 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10155 match field.hash {
10156 _ => Err(ParseError::MissingGameEventValue {
10157 ty: "TeamsChanged",
10158 field: "todo".into(),
10159 }),
10160 }
10161 }
10162 #[allow(unused_variables)]
10163 fn write(
10164 &self,
10165 stream: &mut BitWriteStream<LittleEndian>,
10166 definition: &GameEventDefinition,
10167 ) -> Result<()> {
10168 for entry in &definition.entries {
10169 let value = self
10170 .get_field(entry)
10171 .unwrap_or_else(|_| entry.kind.default_value());
10172 stream.write(&value)?;
10173 }
10174 Ok(())
10175 }
10176}
10177#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10178#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10179pub struct HalloweenPumpkinGrabEvent {
10180 pub user_id: u16,
10181}
10182impl HalloweenPumpkinGrabEvent {
10183 #[allow(unused_variables)]
10184 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10185 Ok(HalloweenPumpkinGrabEvent {
10186 user_id: read_value::<u16>(
10187 stream,
10188 definition.get_entry(17826443226371159423u64),
10189 "user_id",
10190 )?,
10191 })
10192 }
10193 #[allow(unused_variables)]
10194 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10195 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10196 match field.hash {
10197 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10198 _ => Err(ParseError::MissingGameEventValue {
10199 ty: "HalloweenPumpkinGrab",
10200 field: "todo".into(),
10201 }),
10202 }
10203 }
10204 #[allow(unused_variables)]
10205 fn write(
10206 &self,
10207 stream: &mut BitWriteStream<LittleEndian>,
10208 definition: &GameEventDefinition,
10209 ) -> Result<()> {
10210 for entry in &definition.entries {
10211 let value = self
10212 .get_field(entry)
10213 .unwrap_or_else(|_| entry.kind.default_value());
10214 stream.write(&value)?;
10215 }
10216 Ok(())
10217 }
10218}
10219#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10220#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10221pub struct RocketJumpEvent {
10222 pub user_id: u16,
10223 pub play_sound: bool,
10224}
10225impl RocketJumpEvent {
10226 #[allow(unused_variables)]
10227 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10228 Ok(RocketJumpEvent {
10229 user_id: read_value::<u16>(
10230 stream,
10231 definition.get_entry(17826443226371159423u64),
10232 "user_id",
10233 )?,
10234 play_sound: read_value::<bool>(
10235 stream,
10236 definition.get_entry(2035986273219443074u64),
10237 "play_sound",
10238 )?,
10239 })
10240 }
10241 #[allow(unused_variables)]
10242 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10243 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10244 match field.hash {
10245 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10246 2035986273219443074u64 => Ok(self.play_sound.clone().into()),
10247 _ => Err(ParseError::MissingGameEventValue {
10248 ty: "RocketJump",
10249 field: "todo".into(),
10250 }),
10251 }
10252 }
10253 #[allow(unused_variables)]
10254 fn write(
10255 &self,
10256 stream: &mut BitWriteStream<LittleEndian>,
10257 definition: &GameEventDefinition,
10258 ) -> Result<()> {
10259 for entry in &definition.entries {
10260 let value = self
10261 .get_field(entry)
10262 .unwrap_or_else(|_| entry.kind.default_value());
10263 stream.write(&value)?;
10264 }
10265 Ok(())
10266 }
10267}
10268#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10269#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10270pub struct RocketJumpLandedEvent {
10271 pub user_id: u16,
10272}
10273impl RocketJumpLandedEvent {
10274 #[allow(unused_variables)]
10275 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10276 Ok(RocketJumpLandedEvent {
10277 user_id: read_value::<u16>(
10278 stream,
10279 definition.get_entry(17826443226371159423u64),
10280 "user_id",
10281 )?,
10282 })
10283 }
10284 #[allow(unused_variables)]
10285 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10286 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10287 match field.hash {
10288 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10289 _ => Err(ParseError::MissingGameEventValue {
10290 ty: "RocketJumpLanded",
10291 field: "todo".into(),
10292 }),
10293 }
10294 }
10295 #[allow(unused_variables)]
10296 fn write(
10297 &self,
10298 stream: &mut BitWriteStream<LittleEndian>,
10299 definition: &GameEventDefinition,
10300 ) -> Result<()> {
10301 for entry in &definition.entries {
10302 let value = self
10303 .get_field(entry)
10304 .unwrap_or_else(|_| entry.kind.default_value());
10305 stream.write(&value)?;
10306 }
10307 Ok(())
10308 }
10309}
10310#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10311#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10312pub struct StickyJumpEvent {
10313 pub user_id: u16,
10314 pub play_sound: bool,
10315}
10316impl StickyJumpEvent {
10317 #[allow(unused_variables)]
10318 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10319 Ok(StickyJumpEvent {
10320 user_id: read_value::<u16>(
10321 stream,
10322 definition.get_entry(17826443226371159423u64),
10323 "user_id",
10324 )?,
10325 play_sound: read_value::<bool>(
10326 stream,
10327 definition.get_entry(2035986273219443074u64),
10328 "play_sound",
10329 )?,
10330 })
10331 }
10332 #[allow(unused_variables)]
10333 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10334 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10335 match field.hash {
10336 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10337 2035986273219443074u64 => Ok(self.play_sound.clone().into()),
10338 _ => Err(ParseError::MissingGameEventValue {
10339 ty: "StickyJump",
10340 field: "todo".into(),
10341 }),
10342 }
10343 }
10344 #[allow(unused_variables)]
10345 fn write(
10346 &self,
10347 stream: &mut BitWriteStream<LittleEndian>,
10348 definition: &GameEventDefinition,
10349 ) -> Result<()> {
10350 for entry in &definition.entries {
10351 let value = self
10352 .get_field(entry)
10353 .unwrap_or_else(|_| entry.kind.default_value());
10354 stream.write(&value)?;
10355 }
10356 Ok(())
10357 }
10358}
10359#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10360#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10361pub struct StickyJumpLandedEvent {
10362 pub user_id: u16,
10363}
10364impl StickyJumpLandedEvent {
10365 #[allow(unused_variables)]
10366 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10367 Ok(StickyJumpLandedEvent {
10368 user_id: read_value::<u16>(
10369 stream,
10370 definition.get_entry(17826443226371159423u64),
10371 "user_id",
10372 )?,
10373 })
10374 }
10375 #[allow(unused_variables)]
10376 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10377 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10378 match field.hash {
10379 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10380 _ => Err(ParseError::MissingGameEventValue {
10381 ty: "StickyJumpLanded",
10382 field: "todo".into(),
10383 }),
10384 }
10385 }
10386 #[allow(unused_variables)]
10387 fn write(
10388 &self,
10389 stream: &mut BitWriteStream<LittleEndian>,
10390 definition: &GameEventDefinition,
10391 ) -> Result<()> {
10392 for entry in &definition.entries {
10393 let value = self
10394 .get_field(entry)
10395 .unwrap_or_else(|_| entry.kind.default_value());
10396 stream.write(&value)?;
10397 }
10398 Ok(())
10399 }
10400}
10401#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10402#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10403pub struct RocketPackLaunchEvent {
10404 pub user_id: u16,
10405 pub play_sound: bool,
10406}
10407impl RocketPackLaunchEvent {
10408 #[allow(unused_variables)]
10409 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10410 Ok(RocketPackLaunchEvent {
10411 user_id: read_value::<u16>(
10412 stream,
10413 definition.get_entry(17826443226371159423u64),
10414 "user_id",
10415 )?,
10416 play_sound: read_value::<bool>(
10417 stream,
10418 definition.get_entry(2035986273219443074u64),
10419 "play_sound",
10420 )?,
10421 })
10422 }
10423 #[allow(unused_variables)]
10424 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10425 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10426 match field.hash {
10427 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10428 2035986273219443074u64 => Ok(self.play_sound.clone().into()),
10429 _ => Err(ParseError::MissingGameEventValue {
10430 ty: "RocketPackLaunch",
10431 field: "todo".into(),
10432 }),
10433 }
10434 }
10435 #[allow(unused_variables)]
10436 fn write(
10437 &self,
10438 stream: &mut BitWriteStream<LittleEndian>,
10439 definition: &GameEventDefinition,
10440 ) -> Result<()> {
10441 for entry in &definition.entries {
10442 let value = self
10443 .get_field(entry)
10444 .unwrap_or_else(|_| entry.kind.default_value());
10445 stream.write(&value)?;
10446 }
10447 Ok(())
10448 }
10449}
10450#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10451#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10452pub struct RocketPackLandedEvent {
10453 pub user_id: u16,
10454}
10455impl RocketPackLandedEvent {
10456 #[allow(unused_variables)]
10457 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10458 Ok(RocketPackLandedEvent {
10459 user_id: read_value::<u16>(
10460 stream,
10461 definition.get_entry(17826443226371159423u64),
10462 "user_id",
10463 )?,
10464 })
10465 }
10466 #[allow(unused_variables)]
10467 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10468 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10469 match field.hash {
10470 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10471 _ => Err(ParseError::MissingGameEventValue {
10472 ty: "RocketPackLanded",
10473 field: "todo".into(),
10474 }),
10475 }
10476 }
10477 #[allow(unused_variables)]
10478 fn write(
10479 &self,
10480 stream: &mut BitWriteStream<LittleEndian>,
10481 definition: &GameEventDefinition,
10482 ) -> Result<()> {
10483 for entry in &definition.entries {
10484 let value = self
10485 .get_field(entry)
10486 .unwrap_or_else(|_| entry.kind.default_value());
10487 stream.write(&value)?;
10488 }
10489 Ok(())
10490 }
10491}
10492#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10493#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10494pub struct MedicDefendedEvent {
10495 pub user_id: u16,
10496 pub medic: u16,
10497}
10498impl MedicDefendedEvent {
10499 #[allow(unused_variables)]
10500 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10501 Ok(MedicDefendedEvent {
10502 user_id: read_value::<u16>(
10503 stream,
10504 definition.get_entry(17826443226371159423u64),
10505 "user_id",
10506 )?,
10507 medic: read_value::<u16>(
10508 stream,
10509 definition.get_entry(12912869923554243305u64),
10510 "medic",
10511 )?,
10512 })
10513 }
10514 #[allow(unused_variables)]
10515 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10516 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10517 match field.hash {
10518 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10519 12912869923554243305u64 => Ok(self.medic.clone().into()),
10520 _ => Err(ParseError::MissingGameEventValue {
10521 ty: "MedicDefended",
10522 field: "todo".into(),
10523 }),
10524 }
10525 }
10526 #[allow(unused_variables)]
10527 fn write(
10528 &self,
10529 stream: &mut BitWriteStream<LittleEndian>,
10530 definition: &GameEventDefinition,
10531 ) -> Result<()> {
10532 for entry in &definition.entries {
10533 let value = self
10534 .get_field(entry)
10535 .unwrap_or_else(|_| entry.kind.default_value());
10536 stream.write(&value)?;
10537 }
10538 Ok(())
10539 }
10540}
10541#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10542#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10543pub struct LocalPlayerHealedEvent {
10544 pub amount: u16,
10545}
10546impl LocalPlayerHealedEvent {
10547 #[allow(unused_variables)]
10548 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10549 Ok(LocalPlayerHealedEvent {
10550 amount: read_value::<u16>(
10551 stream,
10552 definition.get_entry(9301057475299076457u64),
10553 "amount",
10554 )?,
10555 })
10556 }
10557 #[allow(unused_variables)]
10558 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10559 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10560 match field.hash {
10561 9301057475299076457u64 => Ok(self.amount.clone().into()),
10562 _ => Err(ParseError::MissingGameEventValue {
10563 ty: "LocalPlayerHealed",
10564 field: "todo".into(),
10565 }),
10566 }
10567 }
10568 #[allow(unused_variables)]
10569 fn write(
10570 &self,
10571 stream: &mut BitWriteStream<LittleEndian>,
10572 definition: &GameEventDefinition,
10573 ) -> Result<()> {
10574 for entry in &definition.entries {
10575 let value = self
10576 .get_field(entry)
10577 .unwrap_or_else(|_| entry.kind.default_value());
10578 stream.write(&value)?;
10579 }
10580 Ok(())
10581 }
10582}
10583#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10584#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10585pub struct PlayerDestroyedPipeBombEvent {
10586 pub user_id: u16,
10587}
10588impl PlayerDestroyedPipeBombEvent {
10589 #[allow(unused_variables)]
10590 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10591 Ok(PlayerDestroyedPipeBombEvent {
10592 user_id: read_value::<u16>(
10593 stream,
10594 definition.get_entry(17826443226371159423u64),
10595 "user_id",
10596 )?,
10597 })
10598 }
10599 #[allow(unused_variables)]
10600 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10601 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10602 match field.hash {
10603 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10604 _ => Err(ParseError::MissingGameEventValue {
10605 ty: "PlayerDestroyedPipeBomb",
10606 field: "todo".into(),
10607 }),
10608 }
10609 }
10610 #[allow(unused_variables)]
10611 fn write(
10612 &self,
10613 stream: &mut BitWriteStream<LittleEndian>,
10614 definition: &GameEventDefinition,
10615 ) -> Result<()> {
10616 for entry in &definition.entries {
10617 let value = self
10618 .get_field(entry)
10619 .unwrap_or_else(|_| entry.kind.default_value());
10620 stream.write(&value)?;
10621 }
10622 Ok(())
10623 }
10624}
10625#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10626#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10627pub struct ObjectDeflectedEvent {
10628 pub user_id: u16,
10629 pub owner_id: u16,
10630 pub weapon_id: u16,
10631 pub object_ent_index: u16,
10632}
10633impl ObjectDeflectedEvent {
10634 #[allow(unused_variables)]
10635 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10636 Ok(ObjectDeflectedEvent {
10637 user_id: read_value::<u16>(
10638 stream,
10639 definition.get_entry(17826443226371159423u64),
10640 "user_id",
10641 )?,
10642 owner_id: read_value::<u16>(
10643 stream,
10644 definition.get_entry(3274630577613078265u64),
10645 "owner_id",
10646 )?,
10647 weapon_id: read_value::<u16>(
10648 stream,
10649 definition.get_entry(5542695206485500884u64),
10650 "weapon_id",
10651 )?,
10652 object_ent_index: read_value::<u16>(
10653 stream,
10654 definition.get_entry(8474579522830253112u64),
10655 "object_ent_index",
10656 )?,
10657 })
10658 }
10659 #[allow(unused_variables)]
10660 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10661 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10662 match field.hash {
10663 17826443226371159423u64 => Ok(self.user_id.clone().into()),
10664 3274630577613078265u64 => Ok(self.owner_id.clone().into()),
10665 5542695206485500884u64 => Ok(self.weapon_id.clone().into()),
10666 8474579522830253112u64 => Ok(self.object_ent_index.clone().into()),
10667 _ => Err(ParseError::MissingGameEventValue {
10668 ty: "ObjectDeflected",
10669 field: "todo".into(),
10670 }),
10671 }
10672 }
10673 #[allow(unused_variables)]
10674 fn write(
10675 &self,
10676 stream: &mut BitWriteStream<LittleEndian>,
10677 definition: &GameEventDefinition,
10678 ) -> Result<()> {
10679 for entry in &definition.entries {
10680 let value = self
10681 .get_field(entry)
10682 .unwrap_or_else(|_| entry.kind.default_value());
10683 stream.write(&value)?;
10684 }
10685 Ok(())
10686 }
10687}
10688#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10689#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10690pub struct PlayerMvpEvent {
10691 pub player: u16,
10692}
10693impl PlayerMvpEvent {
10694 #[allow(unused_variables)]
10695 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10696 Ok(PlayerMvpEvent {
10697 player: read_value::<u16>(
10698 stream,
10699 definition.get_entry(5008278420455340480u64),
10700 "player",
10701 )?,
10702 })
10703 }
10704 #[allow(unused_variables)]
10705 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10706 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10707 match field.hash {
10708 5008278420455340480u64 => Ok(self.player.clone().into()),
10709 _ => Err(ParseError::MissingGameEventValue {
10710 ty: "PlayerMvp",
10711 field: "todo".into(),
10712 }),
10713 }
10714 }
10715 #[allow(unused_variables)]
10716 fn write(
10717 &self,
10718 stream: &mut BitWriteStream<LittleEndian>,
10719 definition: &GameEventDefinition,
10720 ) -> Result<()> {
10721 for entry in &definition.entries {
10722 let value = self
10723 .get_field(entry)
10724 .unwrap_or_else(|_| entry.kind.default_value());
10725 stream.write(&value)?;
10726 }
10727 Ok(())
10728 }
10729}
10730#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10731#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10732pub struct RaidSpawnMobEvent {}
10733impl RaidSpawnMobEvent {
10734 #[allow(unused_variables)]
10735 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10736 Ok(RaidSpawnMobEvent {})
10737 }
10738 #[allow(unused_variables)]
10739 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10740 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10741 match field.hash {
10742 _ => Err(ParseError::MissingGameEventValue {
10743 ty: "RaidSpawnMob",
10744 field: "todo".into(),
10745 }),
10746 }
10747 }
10748 #[allow(unused_variables)]
10749 fn write(
10750 &self,
10751 stream: &mut BitWriteStream<LittleEndian>,
10752 definition: &GameEventDefinition,
10753 ) -> Result<()> {
10754 for entry in &definition.entries {
10755 let value = self
10756 .get_field(entry)
10757 .unwrap_or_else(|_| entry.kind.default_value());
10758 stream.write(&value)?;
10759 }
10760 Ok(())
10761 }
10762}
10763#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10764#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10765pub struct RaidSpawnSquadEvent {}
10766impl RaidSpawnSquadEvent {
10767 #[allow(unused_variables)]
10768 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10769 Ok(RaidSpawnSquadEvent {})
10770 }
10771 #[allow(unused_variables)]
10772 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10773 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10774 match field.hash {
10775 _ => Err(ParseError::MissingGameEventValue {
10776 ty: "RaidSpawnSquad",
10777 field: "todo".into(),
10778 }),
10779 }
10780 }
10781 #[allow(unused_variables)]
10782 fn write(
10783 &self,
10784 stream: &mut BitWriteStream<LittleEndian>,
10785 definition: &GameEventDefinition,
10786 ) -> Result<()> {
10787 for entry in &definition.entries {
10788 let value = self
10789 .get_field(entry)
10790 .unwrap_or_else(|_| entry.kind.default_value());
10791 stream.write(&value)?;
10792 }
10793 Ok(())
10794 }
10795}
10796#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10797#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10798pub struct NavBlockedEvent {
10799 pub area: u32,
10800 pub blocked: bool,
10801}
10802impl NavBlockedEvent {
10803 #[allow(unused_variables)]
10804 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10805 Ok(NavBlockedEvent {
10806 area: read_value::<u32>(stream, definition.get_entry(9894459526856489156u64), "area")?,
10807 blocked: read_value::<bool>(
10808 stream,
10809 definition.get_entry(9150172433819428659u64),
10810 "blocked",
10811 )?,
10812 })
10813 }
10814 #[allow(unused_variables)]
10815 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10816 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10817 match field.hash {
10818 9894459526856489156u64 => Ok(self.area.clone().into()),
10819 9150172433819428659u64 => Ok(self.blocked.clone().into()),
10820 _ => Err(ParseError::MissingGameEventValue {
10821 ty: "NavBlocked",
10822 field: "todo".into(),
10823 }),
10824 }
10825 }
10826 #[allow(unused_variables)]
10827 fn write(
10828 &self,
10829 stream: &mut BitWriteStream<LittleEndian>,
10830 definition: &GameEventDefinition,
10831 ) -> Result<()> {
10832 for entry in &definition.entries {
10833 let value = self
10834 .get_field(entry)
10835 .unwrap_or_else(|_| entry.kind.default_value());
10836 stream.write(&value)?;
10837 }
10838 Ok(())
10839 }
10840}
10841#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10842#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10843pub struct PathTrackPassedEvent {
10844 pub index: u16,
10845}
10846impl PathTrackPassedEvent {
10847 #[allow(unused_variables)]
10848 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10849 Ok(PathTrackPassedEvent {
10850 index: read_value::<u16>(
10851 stream,
10852 definition.get_entry(9497966886403524235u64),
10853 "index",
10854 )?,
10855 })
10856 }
10857 #[allow(unused_variables)]
10858 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10859 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10860 match field.hash {
10861 9497966886403524235u64 => Ok(self.index.clone().into()),
10862 _ => Err(ParseError::MissingGameEventValue {
10863 ty: "PathTrackPassed",
10864 field: "todo".into(),
10865 }),
10866 }
10867 }
10868 #[allow(unused_variables)]
10869 fn write(
10870 &self,
10871 stream: &mut BitWriteStream<LittleEndian>,
10872 definition: &GameEventDefinition,
10873 ) -> Result<()> {
10874 for entry in &definition.entries {
10875 let value = self
10876 .get_field(entry)
10877 .unwrap_or_else(|_| entry.kind.default_value());
10878 stream.write(&value)?;
10879 }
10880 Ok(())
10881 }
10882}
10883#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10884#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10885pub struct NumCappersChangedEvent {
10886 pub index: u16,
10887 pub count: u8,
10888}
10889impl NumCappersChangedEvent {
10890 #[allow(unused_variables)]
10891 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10892 Ok(NumCappersChangedEvent {
10893 index: read_value::<u16>(
10894 stream,
10895 definition.get_entry(9497966886403524235u64),
10896 "index",
10897 )?,
10898 count: read_value::<u8>(
10899 stream,
10900 definition.get_entry(12818901015042040436u64),
10901 "count",
10902 )?,
10903 })
10904 }
10905 #[allow(unused_variables)]
10906 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10907 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10908 match field.hash {
10909 9497966886403524235u64 => Ok(self.index.clone().into()),
10910 12818901015042040436u64 => Ok(self.count.clone().into()),
10911 _ => Err(ParseError::MissingGameEventValue {
10912 ty: "NumCappersChanged",
10913 field: "todo".into(),
10914 }),
10915 }
10916 }
10917 #[allow(unused_variables)]
10918 fn write(
10919 &self,
10920 stream: &mut BitWriteStream<LittleEndian>,
10921 definition: &GameEventDefinition,
10922 ) -> Result<()> {
10923 for entry in &definition.entries {
10924 let value = self
10925 .get_field(entry)
10926 .unwrap_or_else(|_| entry.kind.default_value());
10927 stream.write(&value)?;
10928 }
10929 Ok(())
10930 }
10931}
10932#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10933#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10934pub struct PlayerRegenerateEvent {}
10935impl PlayerRegenerateEvent {
10936 #[allow(unused_variables)]
10937 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10938 Ok(PlayerRegenerateEvent {})
10939 }
10940 #[allow(unused_variables)]
10941 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10942 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10943 match field.hash {
10944 _ => Err(ParseError::MissingGameEventValue {
10945 ty: "PlayerRegenerate",
10946 field: "todo".into(),
10947 }),
10948 }
10949 }
10950 #[allow(unused_variables)]
10951 fn write(
10952 &self,
10953 stream: &mut BitWriteStream<LittleEndian>,
10954 definition: &GameEventDefinition,
10955 ) -> Result<()> {
10956 for entry in &definition.entries {
10957 let value = self
10958 .get_field(entry)
10959 .unwrap_or_else(|_| entry.kind.default_value());
10960 stream.write(&value)?;
10961 }
10962 Ok(())
10963 }
10964}
10965#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
10966#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
10967pub struct UpdateStatusItemEvent {
10968 pub index: u8,
10969 pub object: u8,
10970}
10971impl UpdateStatusItemEvent {
10972 #[allow(unused_variables)]
10973 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
10974 Ok(UpdateStatusItemEvent {
10975 index: read_value::<u8>(
10976 stream,
10977 definition.get_entry(9497966886403524235u64),
10978 "index",
10979 )?,
10980 object: read_value::<u8>(
10981 stream,
10982 definition.get_entry(10231808476453998586u64),
10983 "object",
10984 )?,
10985 })
10986 }
10987 #[allow(unused_variables)]
10988 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
10989 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
10990 match field.hash {
10991 9497966886403524235u64 => Ok(self.index.clone().into()),
10992 10231808476453998586u64 => Ok(self.object.clone().into()),
10993 _ => Err(ParseError::MissingGameEventValue {
10994 ty: "UpdateStatusItem",
10995 field: "todo".into(),
10996 }),
10997 }
10998 }
10999 #[allow(unused_variables)]
11000 fn write(
11001 &self,
11002 stream: &mut BitWriteStream<LittleEndian>,
11003 definition: &GameEventDefinition,
11004 ) -> Result<()> {
11005 for entry in &definition.entries {
11006 let value = self
11007 .get_field(entry)
11008 .unwrap_or_else(|_| entry.kind.default_value());
11009 stream.write(&value)?;
11010 }
11011 Ok(())
11012 }
11013}
11014#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11015#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11016pub struct StatsResetRoundEvent {}
11017impl StatsResetRoundEvent {
11018 #[allow(unused_variables)]
11019 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11020 Ok(StatsResetRoundEvent {})
11021 }
11022 #[allow(unused_variables)]
11023 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11024 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11025 match field.hash {
11026 _ => Err(ParseError::MissingGameEventValue {
11027 ty: "StatsResetRound",
11028 field: "todo".into(),
11029 }),
11030 }
11031 }
11032 #[allow(unused_variables)]
11033 fn write(
11034 &self,
11035 stream: &mut BitWriteStream<LittleEndian>,
11036 definition: &GameEventDefinition,
11037 ) -> Result<()> {
11038 for entry in &definition.entries {
11039 let value = self
11040 .get_field(entry)
11041 .unwrap_or_else(|_| entry.kind.default_value());
11042 stream.write(&value)?;
11043 }
11044 Ok(())
11045 }
11046}
11047#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11048#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11049pub struct ScoreStatsAccumulatedUpdateEvent {}
11050impl ScoreStatsAccumulatedUpdateEvent {
11051 #[allow(unused_variables)]
11052 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11053 Ok(ScoreStatsAccumulatedUpdateEvent {})
11054 }
11055 #[allow(unused_variables)]
11056 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11057 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11058 match field.hash {
11059 _ => Err(ParseError::MissingGameEventValue {
11060 ty: "ScoreStatsAccumulatedUpdate",
11061 field: "todo".into(),
11062 }),
11063 }
11064 }
11065 #[allow(unused_variables)]
11066 fn write(
11067 &self,
11068 stream: &mut BitWriteStream<LittleEndian>,
11069 definition: &GameEventDefinition,
11070 ) -> Result<()> {
11071 for entry in &definition.entries {
11072 let value = self
11073 .get_field(entry)
11074 .unwrap_or_else(|_| entry.kind.default_value());
11075 stream.write(&value)?;
11076 }
11077 Ok(())
11078 }
11079}
11080#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11081#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11082pub struct ScoreStatsAccumulatedResetEvent {}
11083impl ScoreStatsAccumulatedResetEvent {
11084 #[allow(unused_variables)]
11085 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11086 Ok(ScoreStatsAccumulatedResetEvent {})
11087 }
11088 #[allow(unused_variables)]
11089 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11090 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11091 match field.hash {
11092 _ => Err(ParseError::MissingGameEventValue {
11093 ty: "ScoreStatsAccumulatedReset",
11094 field: "todo".into(),
11095 }),
11096 }
11097 }
11098 #[allow(unused_variables)]
11099 fn write(
11100 &self,
11101 stream: &mut BitWriteStream<LittleEndian>,
11102 definition: &GameEventDefinition,
11103 ) -> Result<()> {
11104 for entry in &definition.entries {
11105 let value = self
11106 .get_field(entry)
11107 .unwrap_or_else(|_| entry.kind.default_value());
11108 stream.write(&value)?;
11109 }
11110 Ok(())
11111 }
11112}
11113#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11114#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11115pub struct AchievementEarnedLocalEvent {
11116 pub achievement: u16,
11117}
11118impl AchievementEarnedLocalEvent {
11119 #[allow(unused_variables)]
11120 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11121 Ok(AchievementEarnedLocalEvent {
11122 achievement: read_value::<u16>(
11123 stream,
11124 definition.get_entry(7071905471600864408u64),
11125 "achievement",
11126 )?,
11127 })
11128 }
11129 #[allow(unused_variables)]
11130 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11131 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11132 match field.hash {
11133 7071905471600864408u64 => Ok(self.achievement.clone().into()),
11134 _ => Err(ParseError::MissingGameEventValue {
11135 ty: "AchievementEarnedLocal",
11136 field: "todo".into(),
11137 }),
11138 }
11139 }
11140 #[allow(unused_variables)]
11141 fn write(
11142 &self,
11143 stream: &mut BitWriteStream<LittleEndian>,
11144 definition: &GameEventDefinition,
11145 ) -> Result<()> {
11146 for entry in &definition.entries {
11147 let value = self
11148 .get_field(entry)
11149 .unwrap_or_else(|_| entry.kind.default_value());
11150 stream.write(&value)?;
11151 }
11152 Ok(())
11153 }
11154}
11155#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11156#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11157pub struct PlayerHealedEvent {
11158 pub patient: u16,
11159 pub healer: u16,
11160 pub amount: u16,
11161}
11162impl PlayerHealedEvent {
11163 #[allow(unused_variables)]
11164 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11165 Ok(PlayerHealedEvent {
11166 patient: read_value::<u16>(
11167 stream,
11168 definition.get_entry(1896141292373524286u64),
11169 "patient",
11170 )?,
11171 healer: read_value::<u16>(
11172 stream,
11173 definition.get_entry(9195440821534910520u64),
11174 "healer",
11175 )?,
11176 amount: read_value::<u16>(
11177 stream,
11178 definition.get_entry(9301057475299076457u64),
11179 "amount",
11180 )?,
11181 })
11182 }
11183 #[allow(unused_variables)]
11184 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11185 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11186 match field.hash {
11187 1896141292373524286u64 => Ok(self.patient.clone().into()),
11188 9195440821534910520u64 => Ok(self.healer.clone().into()),
11189 9301057475299076457u64 => Ok(self.amount.clone().into()),
11190 _ => Err(ParseError::MissingGameEventValue {
11191 ty: "PlayerHealed",
11192 field: "todo".into(),
11193 }),
11194 }
11195 }
11196 #[allow(unused_variables)]
11197 fn write(
11198 &self,
11199 stream: &mut BitWriteStream<LittleEndian>,
11200 definition: &GameEventDefinition,
11201 ) -> Result<()> {
11202 for entry in &definition.entries {
11203 let value = self
11204 .get_field(entry)
11205 .unwrap_or_else(|_| entry.kind.default_value());
11206 stream.write(&value)?;
11207 }
11208 Ok(())
11209 }
11210}
11211#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11212#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11213pub struct BuildingHealedEvent {
11214 pub building: u16,
11215 pub healer: u16,
11216 pub amount: u16,
11217}
11218impl BuildingHealedEvent {
11219 #[allow(unused_variables)]
11220 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11221 Ok(BuildingHealedEvent {
11222 building: read_value::<u16>(
11223 stream,
11224 definition.get_entry(18077801548994995317u64),
11225 "building",
11226 )?,
11227 healer: read_value::<u16>(
11228 stream,
11229 definition.get_entry(9195440821534910520u64),
11230 "healer",
11231 )?,
11232 amount: read_value::<u16>(
11233 stream,
11234 definition.get_entry(9301057475299076457u64),
11235 "amount",
11236 )?,
11237 })
11238 }
11239 #[allow(unused_variables)]
11240 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11241 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11242 match field.hash {
11243 18077801548994995317u64 => Ok(self.building.clone().into()),
11244 9195440821534910520u64 => Ok(self.healer.clone().into()),
11245 9301057475299076457u64 => Ok(self.amount.clone().into()),
11246 _ => Err(ParseError::MissingGameEventValue {
11247 ty: "BuildingHealed",
11248 field: "todo".into(),
11249 }),
11250 }
11251 }
11252 #[allow(unused_variables)]
11253 fn write(
11254 &self,
11255 stream: &mut BitWriteStream<LittleEndian>,
11256 definition: &GameEventDefinition,
11257 ) -> Result<()> {
11258 for entry in &definition.entries {
11259 let value = self
11260 .get_field(entry)
11261 .unwrap_or_else(|_| entry.kind.default_value());
11262 stream.write(&value)?;
11263 }
11264 Ok(())
11265 }
11266}
11267#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11268#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11269pub struct ItemPickupEvent {
11270 pub user_id: u16,
11271 pub item: MaybeUtf8String,
11272}
11273impl ItemPickupEvent {
11274 #[allow(unused_variables)]
11275 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11276 Ok(ItemPickupEvent {
11277 user_id: read_value::<u16>(
11278 stream,
11279 definition.get_entry(17826443226371159423u64),
11280 "user_id",
11281 )?,
11282 item: read_value::<MaybeUtf8String>(
11283 stream,
11284 definition.get_entry(2900776405502981158u64),
11285 "item",
11286 )?,
11287 })
11288 }
11289 #[allow(unused_variables)]
11290 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11291 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11292 match field.hash {
11293 17826443226371159423u64 => Ok(self.user_id.clone().into()),
11294 2900776405502981158u64 => Ok(self.item.clone().into()),
11295 _ => Err(ParseError::MissingGameEventValue {
11296 ty: "ItemPickup",
11297 field: "todo".into(),
11298 }),
11299 }
11300 }
11301 #[allow(unused_variables)]
11302 fn write(
11303 &self,
11304 stream: &mut BitWriteStream<LittleEndian>,
11305 definition: &GameEventDefinition,
11306 ) -> Result<()> {
11307 for entry in &definition.entries {
11308 let value = self
11309 .get_field(entry)
11310 .unwrap_or_else(|_| entry.kind.default_value());
11311 stream.write(&value)?;
11312 }
11313 Ok(())
11314 }
11315}
11316#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11317#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11318pub struct DuelStatusEvent {
11319 pub killer: u16,
11320 pub score_type: u16,
11321 pub initiator: u16,
11322 pub target: u16,
11323 pub initiator_score: u16,
11324 pub target_score: u16,
11325}
11326impl DuelStatusEvent {
11327 #[allow(unused_variables)]
11328 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11329 Ok(DuelStatusEvent {
11330 killer: read_value::<u16>(
11331 stream,
11332 definition.get_entry(7927307102854403058u64),
11333 "killer",
11334 )?,
11335 score_type: read_value::<u16>(
11336 stream,
11337 definition.get_entry(5898901342300468638u64),
11338 "score_type",
11339 )?,
11340 initiator: read_value::<u16>(
11341 stream,
11342 definition.get_entry(7196121162372295066u64),
11343 "initiator",
11344 )?,
11345 target: read_value::<u16>(
11346 stream,
11347 definition.get_entry(1653916590517707752u64),
11348 "target",
11349 )?,
11350 initiator_score: read_value::<u16>(
11351 stream,
11352 definition.get_entry(3503682569462171123u64),
11353 "initiator_score",
11354 )?,
11355 target_score: read_value::<u16>(
11356 stream,
11357 definition.get_entry(3432502518358366373u64),
11358 "target_score",
11359 )?,
11360 })
11361 }
11362 #[allow(unused_variables)]
11363 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11364 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11365 match field.hash {
11366 7927307102854403058u64 => Ok(self.killer.clone().into()),
11367 5898901342300468638u64 => Ok(self.score_type.clone().into()),
11368 7196121162372295066u64 => Ok(self.initiator.clone().into()),
11369 1653916590517707752u64 => Ok(self.target.clone().into()),
11370 3503682569462171123u64 => Ok(self.initiator_score.clone().into()),
11371 3432502518358366373u64 => Ok(self.target_score.clone().into()),
11372 _ => Err(ParseError::MissingGameEventValue {
11373 ty: "DuelStatus",
11374 field: "todo".into(),
11375 }),
11376 }
11377 }
11378 #[allow(unused_variables)]
11379 fn write(
11380 &self,
11381 stream: &mut BitWriteStream<LittleEndian>,
11382 definition: &GameEventDefinition,
11383 ) -> Result<()> {
11384 for entry in &definition.entries {
11385 let value = self
11386 .get_field(entry)
11387 .unwrap_or_else(|_| entry.kind.default_value());
11388 stream.write(&value)?;
11389 }
11390 Ok(())
11391 }
11392}
11393#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11394#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11395pub struct FishNoticeEvent {
11396 pub user_id: u16,
11397 pub victim_ent_index: u32,
11398 pub inflictor_ent_index: u32,
11399 pub attacker: u16,
11400 pub weapon: MaybeUtf8String,
11401 pub weapon_id: u16,
11402 pub damage_bits: u32,
11403 pub custom_kill: u16,
11404 pub assister: u16,
11405 pub weapon_log_class_name: MaybeUtf8String,
11406 pub stun_flags: u16,
11407 pub death_flags: u16,
11408 pub silent_kill: bool,
11409 pub assister_fallback: MaybeUtf8String,
11410}
11411impl FishNoticeEvent {
11412 #[allow(unused_variables)]
11413 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11414 Ok(FishNoticeEvent {
11415 user_id: read_value::<u16>(
11416 stream,
11417 definition.get_entry(17826443226371159423u64),
11418 "user_id",
11419 )?,
11420 victim_ent_index: read_value::<u32>(
11421 stream,
11422 definition.get_entry(7608903543976233025u64),
11423 "victim_ent_index",
11424 )?,
11425 inflictor_ent_index: read_value::<u32>(
11426 stream,
11427 definition.get_entry(7862267791693534473u64),
11428 "inflictor_ent_index",
11429 )?,
11430 attacker: read_value::<u16>(
11431 stream,
11432 definition.get_entry(7198542740550218478u64),
11433 "attacker",
11434 )?,
11435 weapon: read_value::<MaybeUtf8String>(
11436 stream,
11437 definition.get_entry(11580461223051554305u64),
11438 "weapon",
11439 )?,
11440 weapon_id: read_value::<u16>(
11441 stream,
11442 definition.get_entry(5542695206485500884u64),
11443 "weapon_id",
11444 )?,
11445 damage_bits: read_value::<u32>(
11446 stream,
11447 definition.get_entry(2104626753992558984u64),
11448 "damage_bits",
11449 )?,
11450 custom_kill: read_value::<u16>(
11451 stream,
11452 definition.get_entry(9002408094759571186u64),
11453 "custom_kill",
11454 )?,
11455 assister: read_value::<u16>(
11456 stream,
11457 definition.get_entry(17978308754419261977u64),
11458 "assister",
11459 )?,
11460 weapon_log_class_name: read_value::<MaybeUtf8String>(
11461 stream,
11462 definition.get_entry(8214628514117900939u64),
11463 "weapon_log_class_name",
11464 )?,
11465 stun_flags: read_value::<u16>(
11466 stream,
11467 definition.get_entry(16746745151415897845u64),
11468 "stun_flags",
11469 )?,
11470 death_flags: read_value::<u16>(
11471 stream,
11472 definition.get_entry(210841622282264177u64),
11473 "death_flags",
11474 )?,
11475 silent_kill: read_value::<bool>(
11476 stream,
11477 definition.get_entry(5449831253309542421u64),
11478 "silent_kill",
11479 )?,
11480 assister_fallback: read_value::<MaybeUtf8String>(
11481 stream,
11482 definition.get_entry(2624120833319605424u64),
11483 "assister_fallback",
11484 )?,
11485 })
11486 }
11487 #[allow(unused_variables)]
11488 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11489 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11490 match field.hash {
11491 17826443226371159423u64 => Ok(self.user_id.clone().into()),
11492 7608903543976233025u64 => Ok(self.victim_ent_index.clone().into()),
11493 7862267791693534473u64 => Ok(self.inflictor_ent_index.clone().into()),
11494 7198542740550218478u64 => Ok(self.attacker.clone().into()),
11495 11580461223051554305u64 => Ok(self.weapon.clone().into()),
11496 5542695206485500884u64 => Ok(self.weapon_id.clone().into()),
11497 2104626753992558984u64 => Ok(self.damage_bits.clone().into()),
11498 9002408094759571186u64 => Ok(self.custom_kill.clone().into()),
11499 17978308754419261977u64 => Ok(self.assister.clone().into()),
11500 8214628514117900939u64 => Ok(self.weapon_log_class_name.clone().into()),
11501 16746745151415897845u64 => Ok(self.stun_flags.clone().into()),
11502 210841622282264177u64 => Ok(self.death_flags.clone().into()),
11503 5449831253309542421u64 => Ok(self.silent_kill.clone().into()),
11504 2624120833319605424u64 => Ok(self.assister_fallback.clone().into()),
11505 _ => Err(ParseError::MissingGameEventValue {
11506 ty: "FishNotice",
11507 field: "todo".into(),
11508 }),
11509 }
11510 }
11511 #[allow(unused_variables)]
11512 fn write(
11513 &self,
11514 stream: &mut BitWriteStream<LittleEndian>,
11515 definition: &GameEventDefinition,
11516 ) -> Result<()> {
11517 for entry in &definition.entries {
11518 let value = self
11519 .get_field(entry)
11520 .unwrap_or_else(|_| entry.kind.default_value());
11521 stream.write(&value)?;
11522 }
11523 Ok(())
11524 }
11525}
11526#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11527#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11528pub struct FishNoticeArmEvent {
11529 pub user_id: u16,
11530 pub victim_ent_index: u32,
11531 pub inflictor_ent_index: u32,
11532 pub attacker: u16,
11533 pub weapon: MaybeUtf8String,
11534 pub weapon_id: u16,
11535 pub damage_bits: u32,
11536 pub custom_kill: u16,
11537 pub assister: u16,
11538 pub weapon_log_class_name: MaybeUtf8String,
11539 pub stun_flags: u16,
11540 pub death_flags: u16,
11541 pub silent_kill: bool,
11542 pub assister_fallback: MaybeUtf8String,
11543}
11544impl FishNoticeArmEvent {
11545 #[allow(unused_variables)]
11546 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11547 Ok(FishNoticeArmEvent {
11548 user_id: read_value::<u16>(
11549 stream,
11550 definition.get_entry(17826443226371159423u64),
11551 "user_id",
11552 )?,
11553 victim_ent_index: read_value::<u32>(
11554 stream,
11555 definition.get_entry(7608903543976233025u64),
11556 "victim_ent_index",
11557 )?,
11558 inflictor_ent_index: read_value::<u32>(
11559 stream,
11560 definition.get_entry(7862267791693534473u64),
11561 "inflictor_ent_index",
11562 )?,
11563 attacker: read_value::<u16>(
11564 stream,
11565 definition.get_entry(7198542740550218478u64),
11566 "attacker",
11567 )?,
11568 weapon: read_value::<MaybeUtf8String>(
11569 stream,
11570 definition.get_entry(11580461223051554305u64),
11571 "weapon",
11572 )?,
11573 weapon_id: read_value::<u16>(
11574 stream,
11575 definition.get_entry(5542695206485500884u64),
11576 "weapon_id",
11577 )?,
11578 damage_bits: read_value::<u32>(
11579 stream,
11580 definition.get_entry(2104626753992558984u64),
11581 "damage_bits",
11582 )?,
11583 custom_kill: read_value::<u16>(
11584 stream,
11585 definition.get_entry(9002408094759571186u64),
11586 "custom_kill",
11587 )?,
11588 assister: read_value::<u16>(
11589 stream,
11590 definition.get_entry(17978308754419261977u64),
11591 "assister",
11592 )?,
11593 weapon_log_class_name: read_value::<MaybeUtf8String>(
11594 stream,
11595 definition.get_entry(8214628514117900939u64),
11596 "weapon_log_class_name",
11597 )?,
11598 stun_flags: read_value::<u16>(
11599 stream,
11600 definition.get_entry(16746745151415897845u64),
11601 "stun_flags",
11602 )?,
11603 death_flags: read_value::<u16>(
11604 stream,
11605 definition.get_entry(210841622282264177u64),
11606 "death_flags",
11607 )?,
11608 silent_kill: read_value::<bool>(
11609 stream,
11610 definition.get_entry(5449831253309542421u64),
11611 "silent_kill",
11612 )?,
11613 assister_fallback: read_value::<MaybeUtf8String>(
11614 stream,
11615 definition.get_entry(2624120833319605424u64),
11616 "assister_fallback",
11617 )?,
11618 })
11619 }
11620 #[allow(unused_variables)]
11621 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11622 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11623 match field.hash {
11624 17826443226371159423u64 => Ok(self.user_id.clone().into()),
11625 7608903543976233025u64 => Ok(self.victim_ent_index.clone().into()),
11626 7862267791693534473u64 => Ok(self.inflictor_ent_index.clone().into()),
11627 7198542740550218478u64 => Ok(self.attacker.clone().into()),
11628 11580461223051554305u64 => Ok(self.weapon.clone().into()),
11629 5542695206485500884u64 => Ok(self.weapon_id.clone().into()),
11630 2104626753992558984u64 => Ok(self.damage_bits.clone().into()),
11631 9002408094759571186u64 => Ok(self.custom_kill.clone().into()),
11632 17978308754419261977u64 => Ok(self.assister.clone().into()),
11633 8214628514117900939u64 => Ok(self.weapon_log_class_name.clone().into()),
11634 16746745151415897845u64 => Ok(self.stun_flags.clone().into()),
11635 210841622282264177u64 => Ok(self.death_flags.clone().into()),
11636 5449831253309542421u64 => Ok(self.silent_kill.clone().into()),
11637 2624120833319605424u64 => Ok(self.assister_fallback.clone().into()),
11638 _ => Err(ParseError::MissingGameEventValue {
11639 ty: "FishNoticeArm",
11640 field: "todo".into(),
11641 }),
11642 }
11643 }
11644 #[allow(unused_variables)]
11645 fn write(
11646 &self,
11647 stream: &mut BitWriteStream<LittleEndian>,
11648 definition: &GameEventDefinition,
11649 ) -> Result<()> {
11650 for entry in &definition.entries {
11651 let value = self
11652 .get_field(entry)
11653 .unwrap_or_else(|_| entry.kind.default_value());
11654 stream.write(&value)?;
11655 }
11656 Ok(())
11657 }
11658}
11659#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11660#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11661pub struct SlapNoticeEvent {
11662 pub user_id: u16,
11663 pub victim_ent_index: u32,
11664 pub inflictor_ent_index: u32,
11665 pub attacker: u16,
11666 pub weapon: MaybeUtf8String,
11667 pub weapon_id: u16,
11668 pub damage_bits: u32,
11669 pub custom_kill: u16,
11670 pub assister: u16,
11671 pub weapon_log_class_name: MaybeUtf8String,
11672 pub stun_flags: u16,
11673 pub death_flags: u16,
11674 pub silent_kill: bool,
11675 pub assister_fallback: MaybeUtf8String,
11676}
11677impl SlapNoticeEvent {
11678 #[allow(unused_variables)]
11679 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11680 Ok(SlapNoticeEvent {
11681 user_id: read_value::<u16>(
11682 stream,
11683 definition.get_entry(17826443226371159423u64),
11684 "user_id",
11685 )?,
11686 victim_ent_index: read_value::<u32>(
11687 stream,
11688 definition.get_entry(7608903543976233025u64),
11689 "victim_ent_index",
11690 )?,
11691 inflictor_ent_index: read_value::<u32>(
11692 stream,
11693 definition.get_entry(7862267791693534473u64),
11694 "inflictor_ent_index",
11695 )?,
11696 attacker: read_value::<u16>(
11697 stream,
11698 definition.get_entry(7198542740550218478u64),
11699 "attacker",
11700 )?,
11701 weapon: read_value::<MaybeUtf8String>(
11702 stream,
11703 definition.get_entry(11580461223051554305u64),
11704 "weapon",
11705 )?,
11706 weapon_id: read_value::<u16>(
11707 stream,
11708 definition.get_entry(5542695206485500884u64),
11709 "weapon_id",
11710 )?,
11711 damage_bits: read_value::<u32>(
11712 stream,
11713 definition.get_entry(2104626753992558984u64),
11714 "damage_bits",
11715 )?,
11716 custom_kill: read_value::<u16>(
11717 stream,
11718 definition.get_entry(9002408094759571186u64),
11719 "custom_kill",
11720 )?,
11721 assister: read_value::<u16>(
11722 stream,
11723 definition.get_entry(17978308754419261977u64),
11724 "assister",
11725 )?,
11726 weapon_log_class_name: read_value::<MaybeUtf8String>(
11727 stream,
11728 definition.get_entry(8214628514117900939u64),
11729 "weapon_log_class_name",
11730 )?,
11731 stun_flags: read_value::<u16>(
11732 stream,
11733 definition.get_entry(16746745151415897845u64),
11734 "stun_flags",
11735 )?,
11736 death_flags: read_value::<u16>(
11737 stream,
11738 definition.get_entry(210841622282264177u64),
11739 "death_flags",
11740 )?,
11741 silent_kill: read_value::<bool>(
11742 stream,
11743 definition.get_entry(5449831253309542421u64),
11744 "silent_kill",
11745 )?,
11746 assister_fallback: read_value::<MaybeUtf8String>(
11747 stream,
11748 definition.get_entry(2624120833319605424u64),
11749 "assister_fallback",
11750 )?,
11751 })
11752 }
11753 #[allow(unused_variables)]
11754 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11755 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11756 match field.hash {
11757 17826443226371159423u64 => Ok(self.user_id.clone().into()),
11758 7608903543976233025u64 => Ok(self.victim_ent_index.clone().into()),
11759 7862267791693534473u64 => Ok(self.inflictor_ent_index.clone().into()),
11760 7198542740550218478u64 => Ok(self.attacker.clone().into()),
11761 11580461223051554305u64 => Ok(self.weapon.clone().into()),
11762 5542695206485500884u64 => Ok(self.weapon_id.clone().into()),
11763 2104626753992558984u64 => Ok(self.damage_bits.clone().into()),
11764 9002408094759571186u64 => Ok(self.custom_kill.clone().into()),
11765 17978308754419261977u64 => Ok(self.assister.clone().into()),
11766 8214628514117900939u64 => Ok(self.weapon_log_class_name.clone().into()),
11767 16746745151415897845u64 => Ok(self.stun_flags.clone().into()),
11768 210841622282264177u64 => Ok(self.death_flags.clone().into()),
11769 5449831253309542421u64 => Ok(self.silent_kill.clone().into()),
11770 2624120833319605424u64 => Ok(self.assister_fallback.clone().into()),
11771 _ => Err(ParseError::MissingGameEventValue {
11772 ty: "SlapNotice",
11773 field: "todo".into(),
11774 }),
11775 }
11776 }
11777 #[allow(unused_variables)]
11778 fn write(
11779 &self,
11780 stream: &mut BitWriteStream<LittleEndian>,
11781 definition: &GameEventDefinition,
11782 ) -> Result<()> {
11783 for entry in &definition.entries {
11784 let value = self
11785 .get_field(entry)
11786 .unwrap_or_else(|_| entry.kind.default_value());
11787 stream.write(&value)?;
11788 }
11789 Ok(())
11790 }
11791}
11792#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11793#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11794pub struct ThrowableHitEvent {
11795 pub user_id: u16,
11796 pub victim_ent_index: u32,
11797 pub inflictor_ent_index: u32,
11798 pub attacker: u16,
11799 pub weapon: MaybeUtf8String,
11800 pub weapon_id: u16,
11801 pub damage_bits: u32,
11802 pub custom_kill: u16,
11803 pub assister: u16,
11804 pub weapon_log_class_name: MaybeUtf8String,
11805 pub stun_flags: u16,
11806 pub death_flags: u16,
11807 pub silent_kill: bool,
11808 pub assister_fallback: MaybeUtf8String,
11809 pub total_hits: u16,
11810}
11811impl ThrowableHitEvent {
11812 #[allow(unused_variables)]
11813 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11814 Ok(ThrowableHitEvent {
11815 user_id: read_value::<u16>(
11816 stream,
11817 definition.get_entry(17826443226371159423u64),
11818 "user_id",
11819 )?,
11820 victim_ent_index: read_value::<u32>(
11821 stream,
11822 definition.get_entry(7608903543976233025u64),
11823 "victim_ent_index",
11824 )?,
11825 inflictor_ent_index: read_value::<u32>(
11826 stream,
11827 definition.get_entry(7862267791693534473u64),
11828 "inflictor_ent_index",
11829 )?,
11830 attacker: read_value::<u16>(
11831 stream,
11832 definition.get_entry(7198542740550218478u64),
11833 "attacker",
11834 )?,
11835 weapon: read_value::<MaybeUtf8String>(
11836 stream,
11837 definition.get_entry(11580461223051554305u64),
11838 "weapon",
11839 )?,
11840 weapon_id: read_value::<u16>(
11841 stream,
11842 definition.get_entry(5542695206485500884u64),
11843 "weapon_id",
11844 )?,
11845 damage_bits: read_value::<u32>(
11846 stream,
11847 definition.get_entry(2104626753992558984u64),
11848 "damage_bits",
11849 )?,
11850 custom_kill: read_value::<u16>(
11851 stream,
11852 definition.get_entry(9002408094759571186u64),
11853 "custom_kill",
11854 )?,
11855 assister: read_value::<u16>(
11856 stream,
11857 definition.get_entry(17978308754419261977u64),
11858 "assister",
11859 )?,
11860 weapon_log_class_name: read_value::<MaybeUtf8String>(
11861 stream,
11862 definition.get_entry(8214628514117900939u64),
11863 "weapon_log_class_name",
11864 )?,
11865 stun_flags: read_value::<u16>(
11866 stream,
11867 definition.get_entry(16746745151415897845u64),
11868 "stun_flags",
11869 )?,
11870 death_flags: read_value::<u16>(
11871 stream,
11872 definition.get_entry(210841622282264177u64),
11873 "death_flags",
11874 )?,
11875 silent_kill: read_value::<bool>(
11876 stream,
11877 definition.get_entry(5449831253309542421u64),
11878 "silent_kill",
11879 )?,
11880 assister_fallback: read_value::<MaybeUtf8String>(
11881 stream,
11882 definition.get_entry(2624120833319605424u64),
11883 "assister_fallback",
11884 )?,
11885 total_hits: read_value::<u16>(
11886 stream,
11887 definition.get_entry(16097486085498709235u64),
11888 "total_hits",
11889 )?,
11890 })
11891 }
11892 #[allow(unused_variables)]
11893 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11894 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11895 match field.hash {
11896 17826443226371159423u64 => Ok(self.user_id.clone().into()),
11897 7608903543976233025u64 => Ok(self.victim_ent_index.clone().into()),
11898 7862267791693534473u64 => Ok(self.inflictor_ent_index.clone().into()),
11899 7198542740550218478u64 => Ok(self.attacker.clone().into()),
11900 11580461223051554305u64 => Ok(self.weapon.clone().into()),
11901 5542695206485500884u64 => Ok(self.weapon_id.clone().into()),
11902 2104626753992558984u64 => Ok(self.damage_bits.clone().into()),
11903 9002408094759571186u64 => Ok(self.custom_kill.clone().into()),
11904 17978308754419261977u64 => Ok(self.assister.clone().into()),
11905 8214628514117900939u64 => Ok(self.weapon_log_class_name.clone().into()),
11906 16746745151415897845u64 => Ok(self.stun_flags.clone().into()),
11907 210841622282264177u64 => Ok(self.death_flags.clone().into()),
11908 5449831253309542421u64 => Ok(self.silent_kill.clone().into()),
11909 2624120833319605424u64 => Ok(self.assister_fallback.clone().into()),
11910 16097486085498709235u64 => Ok(self.total_hits.clone().into()),
11911 _ => Err(ParseError::MissingGameEventValue {
11912 ty: "ThrowableHit",
11913 field: "todo".into(),
11914 }),
11915 }
11916 }
11917 #[allow(unused_variables)]
11918 fn write(
11919 &self,
11920 stream: &mut BitWriteStream<LittleEndian>,
11921 definition: &GameEventDefinition,
11922 ) -> Result<()> {
11923 for entry in &definition.entries {
11924 let value = self
11925 .get_field(entry)
11926 .unwrap_or_else(|_| entry.kind.default_value());
11927 stream.write(&value)?;
11928 }
11929 Ok(())
11930 }
11931}
11932#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11933#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11934pub struct PumpkinLordSummonedEvent {}
11935impl PumpkinLordSummonedEvent {
11936 #[allow(unused_variables)]
11937 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11938 Ok(PumpkinLordSummonedEvent {})
11939 }
11940 #[allow(unused_variables)]
11941 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11942 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11943 match field.hash {
11944 _ => Err(ParseError::MissingGameEventValue {
11945 ty: "PumpkinLordSummoned",
11946 field: "todo".into(),
11947 }),
11948 }
11949 }
11950 #[allow(unused_variables)]
11951 fn write(
11952 &self,
11953 stream: &mut BitWriteStream<LittleEndian>,
11954 definition: &GameEventDefinition,
11955 ) -> Result<()> {
11956 for entry in &definition.entries {
11957 let value = self
11958 .get_field(entry)
11959 .unwrap_or_else(|_| entry.kind.default_value());
11960 stream.write(&value)?;
11961 }
11962 Ok(())
11963 }
11964}
11965#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11966#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
11967pub struct PumpkinLordKilledEvent {}
11968impl PumpkinLordKilledEvent {
11969 #[allow(unused_variables)]
11970 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
11971 Ok(PumpkinLordKilledEvent {})
11972 }
11973 #[allow(unused_variables)]
11974 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
11975 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
11976 match field.hash {
11977 _ => Err(ParseError::MissingGameEventValue {
11978 ty: "PumpkinLordKilled",
11979 field: "todo".into(),
11980 }),
11981 }
11982 }
11983 #[allow(unused_variables)]
11984 fn write(
11985 &self,
11986 stream: &mut BitWriteStream<LittleEndian>,
11987 definition: &GameEventDefinition,
11988 ) -> Result<()> {
11989 for entry in &definition.entries {
11990 let value = self
11991 .get_field(entry)
11992 .unwrap_or_else(|_| entry.kind.default_value());
11993 stream.write(&value)?;
11994 }
11995 Ok(())
11996 }
11997}
11998#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11999#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12000pub struct MerasmusSummonedEvent {
12001 pub level: u16,
12002}
12003impl MerasmusSummonedEvent {
12004 #[allow(unused_variables)]
12005 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12006 Ok(MerasmusSummonedEvent {
12007 level: read_value::<u16>(
12008 stream,
12009 definition.get_entry(16779788834081370269u64),
12010 "level",
12011 )?,
12012 })
12013 }
12014 #[allow(unused_variables)]
12015 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12016 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12017 match field.hash {
12018 16779788834081370269u64 => Ok(self.level.clone().into()),
12019 _ => Err(ParseError::MissingGameEventValue {
12020 ty: "MerasmusSummoned",
12021 field: "todo".into(),
12022 }),
12023 }
12024 }
12025 #[allow(unused_variables)]
12026 fn write(
12027 &self,
12028 stream: &mut BitWriteStream<LittleEndian>,
12029 definition: &GameEventDefinition,
12030 ) -> Result<()> {
12031 for entry in &definition.entries {
12032 let value = self
12033 .get_field(entry)
12034 .unwrap_or_else(|_| entry.kind.default_value());
12035 stream.write(&value)?;
12036 }
12037 Ok(())
12038 }
12039}
12040#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12041#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12042pub struct MerasmusKilledEvent {
12043 pub level: u16,
12044}
12045impl MerasmusKilledEvent {
12046 #[allow(unused_variables)]
12047 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12048 Ok(MerasmusKilledEvent {
12049 level: read_value::<u16>(
12050 stream,
12051 definition.get_entry(16779788834081370269u64),
12052 "level",
12053 )?,
12054 })
12055 }
12056 #[allow(unused_variables)]
12057 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12058 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12059 match field.hash {
12060 16779788834081370269u64 => Ok(self.level.clone().into()),
12061 _ => Err(ParseError::MissingGameEventValue {
12062 ty: "MerasmusKilled",
12063 field: "todo".into(),
12064 }),
12065 }
12066 }
12067 #[allow(unused_variables)]
12068 fn write(
12069 &self,
12070 stream: &mut BitWriteStream<LittleEndian>,
12071 definition: &GameEventDefinition,
12072 ) -> Result<()> {
12073 for entry in &definition.entries {
12074 let value = self
12075 .get_field(entry)
12076 .unwrap_or_else(|_| entry.kind.default_value());
12077 stream.write(&value)?;
12078 }
12079 Ok(())
12080 }
12081}
12082#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12083#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12084pub struct MerasmusEscapeWarningEvent {
12085 pub level: u16,
12086 pub time_remaining: u8,
12087}
12088impl MerasmusEscapeWarningEvent {
12089 #[allow(unused_variables)]
12090 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12091 Ok(MerasmusEscapeWarningEvent {
12092 level: read_value::<u16>(
12093 stream,
12094 definition.get_entry(16779788834081370269u64),
12095 "level",
12096 )?,
12097 time_remaining: read_value::<u8>(
12098 stream,
12099 definition.get_entry(4322130481848759231u64),
12100 "time_remaining",
12101 )?,
12102 })
12103 }
12104 #[allow(unused_variables)]
12105 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12106 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12107 match field.hash {
12108 16779788834081370269u64 => Ok(self.level.clone().into()),
12109 4322130481848759231u64 => Ok(self.time_remaining.clone().into()),
12110 _ => Err(ParseError::MissingGameEventValue {
12111 ty: "MerasmusEscapeWarning",
12112 field: "todo".into(),
12113 }),
12114 }
12115 }
12116 #[allow(unused_variables)]
12117 fn write(
12118 &self,
12119 stream: &mut BitWriteStream<LittleEndian>,
12120 definition: &GameEventDefinition,
12121 ) -> Result<()> {
12122 for entry in &definition.entries {
12123 let value = self
12124 .get_field(entry)
12125 .unwrap_or_else(|_| entry.kind.default_value());
12126 stream.write(&value)?;
12127 }
12128 Ok(())
12129 }
12130}
12131#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12132#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12133pub struct MerasmusEscapedEvent {
12134 pub level: u16,
12135}
12136impl MerasmusEscapedEvent {
12137 #[allow(unused_variables)]
12138 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12139 Ok(MerasmusEscapedEvent {
12140 level: read_value::<u16>(
12141 stream,
12142 definition.get_entry(16779788834081370269u64),
12143 "level",
12144 )?,
12145 })
12146 }
12147 #[allow(unused_variables)]
12148 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12149 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12150 match field.hash {
12151 16779788834081370269u64 => Ok(self.level.clone().into()),
12152 _ => Err(ParseError::MissingGameEventValue {
12153 ty: "MerasmusEscaped",
12154 field: "todo".into(),
12155 }),
12156 }
12157 }
12158 #[allow(unused_variables)]
12159 fn write(
12160 &self,
12161 stream: &mut BitWriteStream<LittleEndian>,
12162 definition: &GameEventDefinition,
12163 ) -> Result<()> {
12164 for entry in &definition.entries {
12165 let value = self
12166 .get_field(entry)
12167 .unwrap_or_else(|_| entry.kind.default_value());
12168 stream.write(&value)?;
12169 }
12170 Ok(())
12171 }
12172}
12173#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12174#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12175pub struct EyeballBossSummonedEvent {
12176 pub level: u16,
12177}
12178impl EyeballBossSummonedEvent {
12179 #[allow(unused_variables)]
12180 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12181 Ok(EyeballBossSummonedEvent {
12182 level: read_value::<u16>(
12183 stream,
12184 definition.get_entry(16779788834081370269u64),
12185 "level",
12186 )?,
12187 })
12188 }
12189 #[allow(unused_variables)]
12190 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12191 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12192 match field.hash {
12193 16779788834081370269u64 => Ok(self.level.clone().into()),
12194 _ => Err(ParseError::MissingGameEventValue {
12195 ty: "EyeballBossSummoned",
12196 field: "todo".into(),
12197 }),
12198 }
12199 }
12200 #[allow(unused_variables)]
12201 fn write(
12202 &self,
12203 stream: &mut BitWriteStream<LittleEndian>,
12204 definition: &GameEventDefinition,
12205 ) -> Result<()> {
12206 for entry in &definition.entries {
12207 let value = self
12208 .get_field(entry)
12209 .unwrap_or_else(|_| entry.kind.default_value());
12210 stream.write(&value)?;
12211 }
12212 Ok(())
12213 }
12214}
12215#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12216#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12217pub struct EyeballBossStunnedEvent {
12218 pub level: u16,
12219 pub player_ent_index: u8,
12220}
12221impl EyeballBossStunnedEvent {
12222 #[allow(unused_variables)]
12223 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12224 Ok(EyeballBossStunnedEvent {
12225 level: read_value::<u16>(
12226 stream,
12227 definition.get_entry(16779788834081370269u64),
12228 "level",
12229 )?,
12230 player_ent_index: read_value::<u8>(
12231 stream,
12232 definition.get_entry(13724068420967497014u64),
12233 "player_ent_index",
12234 )?,
12235 })
12236 }
12237 #[allow(unused_variables)]
12238 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12239 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12240 match field.hash {
12241 16779788834081370269u64 => Ok(self.level.clone().into()),
12242 13724068420967497014u64 => Ok(self.player_ent_index.clone().into()),
12243 _ => Err(ParseError::MissingGameEventValue {
12244 ty: "EyeballBossStunned",
12245 field: "todo".into(),
12246 }),
12247 }
12248 }
12249 #[allow(unused_variables)]
12250 fn write(
12251 &self,
12252 stream: &mut BitWriteStream<LittleEndian>,
12253 definition: &GameEventDefinition,
12254 ) -> Result<()> {
12255 for entry in &definition.entries {
12256 let value = self
12257 .get_field(entry)
12258 .unwrap_or_else(|_| entry.kind.default_value());
12259 stream.write(&value)?;
12260 }
12261 Ok(())
12262 }
12263}
12264#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12265#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12266pub struct EyeballBossKilledEvent {
12267 pub level: u16,
12268}
12269impl EyeballBossKilledEvent {
12270 #[allow(unused_variables)]
12271 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12272 Ok(EyeballBossKilledEvent {
12273 level: read_value::<u16>(
12274 stream,
12275 definition.get_entry(16779788834081370269u64),
12276 "level",
12277 )?,
12278 })
12279 }
12280 #[allow(unused_variables)]
12281 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12282 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12283 match field.hash {
12284 16779788834081370269u64 => Ok(self.level.clone().into()),
12285 _ => Err(ParseError::MissingGameEventValue {
12286 ty: "EyeballBossKilled",
12287 field: "todo".into(),
12288 }),
12289 }
12290 }
12291 #[allow(unused_variables)]
12292 fn write(
12293 &self,
12294 stream: &mut BitWriteStream<LittleEndian>,
12295 definition: &GameEventDefinition,
12296 ) -> Result<()> {
12297 for entry in &definition.entries {
12298 let value = self
12299 .get_field(entry)
12300 .unwrap_or_else(|_| entry.kind.default_value());
12301 stream.write(&value)?;
12302 }
12303 Ok(())
12304 }
12305}
12306#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12307#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12308pub struct EyeballBossKillerEvent {
12309 pub level: u16,
12310 pub player_ent_index: u8,
12311}
12312impl EyeballBossKillerEvent {
12313 #[allow(unused_variables)]
12314 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12315 Ok(EyeballBossKillerEvent {
12316 level: read_value::<u16>(
12317 stream,
12318 definition.get_entry(16779788834081370269u64),
12319 "level",
12320 )?,
12321 player_ent_index: read_value::<u8>(
12322 stream,
12323 definition.get_entry(13724068420967497014u64),
12324 "player_ent_index",
12325 )?,
12326 })
12327 }
12328 #[allow(unused_variables)]
12329 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12330 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12331 match field.hash {
12332 16779788834081370269u64 => Ok(self.level.clone().into()),
12333 13724068420967497014u64 => Ok(self.player_ent_index.clone().into()),
12334 _ => Err(ParseError::MissingGameEventValue {
12335 ty: "EyeballBossKiller",
12336 field: "todo".into(),
12337 }),
12338 }
12339 }
12340 #[allow(unused_variables)]
12341 fn write(
12342 &self,
12343 stream: &mut BitWriteStream<LittleEndian>,
12344 definition: &GameEventDefinition,
12345 ) -> Result<()> {
12346 for entry in &definition.entries {
12347 let value = self
12348 .get_field(entry)
12349 .unwrap_or_else(|_| entry.kind.default_value());
12350 stream.write(&value)?;
12351 }
12352 Ok(())
12353 }
12354}
12355#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12356#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12357pub struct EyeballBossEscapeImminentEvent {
12358 pub level: u16,
12359 pub time_remaining: u8,
12360}
12361impl EyeballBossEscapeImminentEvent {
12362 #[allow(unused_variables)]
12363 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12364 Ok(EyeballBossEscapeImminentEvent {
12365 level: read_value::<u16>(
12366 stream,
12367 definition.get_entry(16779788834081370269u64),
12368 "level",
12369 )?,
12370 time_remaining: read_value::<u8>(
12371 stream,
12372 definition.get_entry(4322130481848759231u64),
12373 "time_remaining",
12374 )?,
12375 })
12376 }
12377 #[allow(unused_variables)]
12378 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12379 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12380 match field.hash {
12381 16779788834081370269u64 => Ok(self.level.clone().into()),
12382 4322130481848759231u64 => Ok(self.time_remaining.clone().into()),
12383 _ => Err(ParseError::MissingGameEventValue {
12384 ty: "EyeballBossEscapeImminent",
12385 field: "todo".into(),
12386 }),
12387 }
12388 }
12389 #[allow(unused_variables)]
12390 fn write(
12391 &self,
12392 stream: &mut BitWriteStream<LittleEndian>,
12393 definition: &GameEventDefinition,
12394 ) -> Result<()> {
12395 for entry in &definition.entries {
12396 let value = self
12397 .get_field(entry)
12398 .unwrap_or_else(|_| entry.kind.default_value());
12399 stream.write(&value)?;
12400 }
12401 Ok(())
12402 }
12403}
12404#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12405#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12406pub struct EyeballBossEscapedEvent {
12407 pub level: u16,
12408}
12409impl EyeballBossEscapedEvent {
12410 #[allow(unused_variables)]
12411 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12412 Ok(EyeballBossEscapedEvent {
12413 level: read_value::<u16>(
12414 stream,
12415 definition.get_entry(16779788834081370269u64),
12416 "level",
12417 )?,
12418 })
12419 }
12420 #[allow(unused_variables)]
12421 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12422 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12423 match field.hash {
12424 16779788834081370269u64 => Ok(self.level.clone().into()),
12425 _ => Err(ParseError::MissingGameEventValue {
12426 ty: "EyeballBossEscaped",
12427 field: "todo".into(),
12428 }),
12429 }
12430 }
12431 #[allow(unused_variables)]
12432 fn write(
12433 &self,
12434 stream: &mut BitWriteStream<LittleEndian>,
12435 definition: &GameEventDefinition,
12436 ) -> Result<()> {
12437 for entry in &definition.entries {
12438 let value = self
12439 .get_field(entry)
12440 .unwrap_or_else(|_| entry.kind.default_value());
12441 stream.write(&value)?;
12442 }
12443 Ok(())
12444 }
12445}
12446#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12447#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12448pub struct NpcHurtEvent {
12449 pub ent_index: u16,
12450 pub health: u16,
12451 pub attacker_player: u16,
12452 pub weapon_id: u16,
12453 pub damage_amount: u16,
12454 pub crit: bool,
12455 pub boss: u16,
12456}
12457impl NpcHurtEvent {
12458 #[allow(unused_variables)]
12459 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12460 Ok(NpcHurtEvent {
12461 ent_index: read_value::<u16>(
12462 stream,
12463 definition.get_entry(17554918082946193550u64),
12464 "ent_index",
12465 )?,
12466 health: read_value::<u16>(
12467 stream,
12468 definition.get_entry(9181103189905877455u64),
12469 "health",
12470 )?,
12471 attacker_player: read_value::<u16>(
12472 stream,
12473 definition.get_entry(7636913148849873330u64),
12474 "attacker_player",
12475 )?,
12476 weapon_id: read_value::<u16>(
12477 stream,
12478 definition.get_entry(5542695206485500884u64),
12479 "weapon_id",
12480 )?,
12481 damage_amount: read_value::<u16>(
12482 stream,
12483 definition.get_entry(7439038394412279612u64),
12484 "damage_amount",
12485 )?,
12486 crit: read_value::<bool>(stream, definition.get_entry(1324453635955533101u64), "crit")?,
12487 boss: read_value::<u16>(
12488 stream,
12489 definition.get_entry(14781339113128978092u64),
12490 "boss",
12491 )?,
12492 })
12493 }
12494 #[allow(unused_variables)]
12495 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12496 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12497 match field.hash {
12498 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
12499 9181103189905877455u64 => Ok(self.health.clone().into()),
12500 7636913148849873330u64 => Ok(self.attacker_player.clone().into()),
12501 5542695206485500884u64 => Ok(self.weapon_id.clone().into()),
12502 7439038394412279612u64 => Ok(self.damage_amount.clone().into()),
12503 1324453635955533101u64 => Ok(self.crit.clone().into()),
12504 14781339113128978092u64 => Ok(self.boss.clone().into()),
12505 _ => Err(ParseError::MissingGameEventValue {
12506 ty: "NpcHurt",
12507 field: "todo".into(),
12508 }),
12509 }
12510 }
12511 #[allow(unused_variables)]
12512 fn write(
12513 &self,
12514 stream: &mut BitWriteStream<LittleEndian>,
12515 definition: &GameEventDefinition,
12516 ) -> Result<()> {
12517 for entry in &definition.entries {
12518 let value = self
12519 .get_field(entry)
12520 .unwrap_or_else(|_| entry.kind.default_value());
12521 stream.write(&value)?;
12522 }
12523 Ok(())
12524 }
12525}
12526#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12527#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12528pub struct ControlPointTimerUpdatedEvent {
12529 pub index: u16,
12530 pub time: f32,
12531}
12532impl ControlPointTimerUpdatedEvent {
12533 #[allow(unused_variables)]
12534 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12535 Ok(ControlPointTimerUpdatedEvent {
12536 index: read_value::<u16>(
12537 stream,
12538 definition.get_entry(9497966886403524235u64),
12539 "index",
12540 )?,
12541 time: read_value::<f32>(stream, definition.get_entry(2185518981507421060u64), "time")?,
12542 })
12543 }
12544 #[allow(unused_variables)]
12545 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12546 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12547 match field.hash {
12548 9497966886403524235u64 => Ok(self.index.clone().into()),
12549 2185518981507421060u64 => Ok(self.time.clone().into()),
12550 _ => Err(ParseError::MissingGameEventValue {
12551 ty: "ControlPointTimerUpdated",
12552 field: "todo".into(),
12553 }),
12554 }
12555 }
12556 #[allow(unused_variables)]
12557 fn write(
12558 &self,
12559 stream: &mut BitWriteStream<LittleEndian>,
12560 definition: &GameEventDefinition,
12561 ) -> Result<()> {
12562 for entry in &definition.entries {
12563 let value = self
12564 .get_field(entry)
12565 .unwrap_or_else(|_| entry.kind.default_value());
12566 stream.write(&value)?;
12567 }
12568 Ok(())
12569 }
12570}
12571#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12572#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12573pub struct PlayerHighFiveStartEvent {
12574 pub ent_index: u8,
12575}
12576impl PlayerHighFiveStartEvent {
12577 #[allow(unused_variables)]
12578 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12579 Ok(PlayerHighFiveStartEvent {
12580 ent_index: read_value::<u8>(
12581 stream,
12582 definition.get_entry(17554918082946193550u64),
12583 "ent_index",
12584 )?,
12585 })
12586 }
12587 #[allow(unused_variables)]
12588 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12589 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12590 match field.hash {
12591 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
12592 _ => Err(ParseError::MissingGameEventValue {
12593 ty: "PlayerHighFiveStart",
12594 field: "todo".into(),
12595 }),
12596 }
12597 }
12598 #[allow(unused_variables)]
12599 fn write(
12600 &self,
12601 stream: &mut BitWriteStream<LittleEndian>,
12602 definition: &GameEventDefinition,
12603 ) -> Result<()> {
12604 for entry in &definition.entries {
12605 let value = self
12606 .get_field(entry)
12607 .unwrap_or_else(|_| entry.kind.default_value());
12608 stream.write(&value)?;
12609 }
12610 Ok(())
12611 }
12612}
12613#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12614#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12615pub struct PlayerHighFiveCancelEvent {
12616 pub ent_index: u8,
12617}
12618impl PlayerHighFiveCancelEvent {
12619 #[allow(unused_variables)]
12620 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12621 Ok(PlayerHighFiveCancelEvent {
12622 ent_index: read_value::<u8>(
12623 stream,
12624 definition.get_entry(17554918082946193550u64),
12625 "ent_index",
12626 )?,
12627 })
12628 }
12629 #[allow(unused_variables)]
12630 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12631 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12632 match field.hash {
12633 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
12634 _ => Err(ParseError::MissingGameEventValue {
12635 ty: "PlayerHighFiveCancel",
12636 field: "todo".into(),
12637 }),
12638 }
12639 }
12640 #[allow(unused_variables)]
12641 fn write(
12642 &self,
12643 stream: &mut BitWriteStream<LittleEndian>,
12644 definition: &GameEventDefinition,
12645 ) -> Result<()> {
12646 for entry in &definition.entries {
12647 let value = self
12648 .get_field(entry)
12649 .unwrap_or_else(|_| entry.kind.default_value());
12650 stream.write(&value)?;
12651 }
12652 Ok(())
12653 }
12654}
12655#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12656#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12657pub struct PlayerHighFiveSuccessEvent {
12658 pub initiator_ent_index: u8,
12659 pub partner_ent_index: u8,
12660}
12661impl PlayerHighFiveSuccessEvent {
12662 #[allow(unused_variables)]
12663 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12664 Ok(PlayerHighFiveSuccessEvent {
12665 initiator_ent_index: read_value::<u8>(
12666 stream,
12667 definition.get_entry(18349426944415386264u64),
12668 "initiator_ent_index",
12669 )?,
12670 partner_ent_index: read_value::<u8>(
12671 stream,
12672 definition.get_entry(6552235651321274101u64),
12673 "partner_ent_index",
12674 )?,
12675 })
12676 }
12677 #[allow(unused_variables)]
12678 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12679 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12680 match field.hash {
12681 18349426944415386264u64 => Ok(self.initiator_ent_index.clone().into()),
12682 6552235651321274101u64 => Ok(self.partner_ent_index.clone().into()),
12683 _ => Err(ParseError::MissingGameEventValue {
12684 ty: "PlayerHighFiveSuccess",
12685 field: "todo".into(),
12686 }),
12687 }
12688 }
12689 #[allow(unused_variables)]
12690 fn write(
12691 &self,
12692 stream: &mut BitWriteStream<LittleEndian>,
12693 definition: &GameEventDefinition,
12694 ) -> Result<()> {
12695 for entry in &definition.entries {
12696 let value = self
12697 .get_field(entry)
12698 .unwrap_or_else(|_| entry.kind.default_value());
12699 stream.write(&value)?;
12700 }
12701 Ok(())
12702 }
12703}
12704#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12705#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12706pub struct PlayerBonusPointsEvent {
12707 pub points: u16,
12708 pub player_ent_index: u16,
12709 pub source_ent_index: u16,
12710}
12711impl PlayerBonusPointsEvent {
12712 #[allow(unused_variables)]
12713 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12714 Ok(PlayerBonusPointsEvent {
12715 points: read_value::<u16>(
12716 stream,
12717 definition.get_entry(15925482014108518566u64),
12718 "points",
12719 )?,
12720 player_ent_index: read_value::<u16>(
12721 stream,
12722 definition.get_entry(13724068420967497014u64),
12723 "player_ent_index",
12724 )?,
12725 source_ent_index: read_value::<u16>(
12726 stream,
12727 definition.get_entry(7014721347321999598u64),
12728 "source_ent_index",
12729 )?,
12730 })
12731 }
12732 #[allow(unused_variables)]
12733 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12734 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12735 match field.hash {
12736 15925482014108518566u64 => Ok(self.points.clone().into()),
12737 13724068420967497014u64 => Ok(self.player_ent_index.clone().into()),
12738 7014721347321999598u64 => Ok(self.source_ent_index.clone().into()),
12739 _ => Err(ParseError::MissingGameEventValue {
12740 ty: "PlayerBonusPoints",
12741 field: "todo".into(),
12742 }),
12743 }
12744 }
12745 #[allow(unused_variables)]
12746 fn write(
12747 &self,
12748 stream: &mut BitWriteStream<LittleEndian>,
12749 definition: &GameEventDefinition,
12750 ) -> Result<()> {
12751 for entry in &definition.entries {
12752 let value = self
12753 .get_field(entry)
12754 .unwrap_or_else(|_| entry.kind.default_value());
12755 stream.write(&value)?;
12756 }
12757 Ok(())
12758 }
12759}
12760#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12761#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12762pub struct PlayerUpgradedEvent {}
12763impl PlayerUpgradedEvent {
12764 #[allow(unused_variables)]
12765 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12766 Ok(PlayerUpgradedEvent {})
12767 }
12768 #[allow(unused_variables)]
12769 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12770 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12771 match field.hash {
12772 _ => Err(ParseError::MissingGameEventValue {
12773 ty: "PlayerUpgraded",
12774 field: "todo".into(),
12775 }),
12776 }
12777 }
12778 #[allow(unused_variables)]
12779 fn write(
12780 &self,
12781 stream: &mut BitWriteStream<LittleEndian>,
12782 definition: &GameEventDefinition,
12783 ) -> Result<()> {
12784 for entry in &definition.entries {
12785 let value = self
12786 .get_field(entry)
12787 .unwrap_or_else(|_| entry.kind.default_value());
12788 stream.write(&value)?;
12789 }
12790 Ok(())
12791 }
12792}
12793#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12794#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12795pub struct PlayerBuybackEvent {
12796 pub player: u16,
12797 pub cost: u16,
12798}
12799impl PlayerBuybackEvent {
12800 #[allow(unused_variables)]
12801 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12802 Ok(PlayerBuybackEvent {
12803 player: read_value::<u16>(
12804 stream,
12805 definition.get_entry(5008278420455340480u64),
12806 "player",
12807 )?,
12808 cost: read_value::<u16>(stream, definition.get_entry(859913274118676344u64), "cost")?,
12809 })
12810 }
12811 #[allow(unused_variables)]
12812 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12813 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12814 match field.hash {
12815 5008278420455340480u64 => Ok(self.player.clone().into()),
12816 859913274118676344u64 => Ok(self.cost.clone().into()),
12817 _ => Err(ParseError::MissingGameEventValue {
12818 ty: "PlayerBuyback",
12819 field: "todo".into(),
12820 }),
12821 }
12822 }
12823 #[allow(unused_variables)]
12824 fn write(
12825 &self,
12826 stream: &mut BitWriteStream<LittleEndian>,
12827 definition: &GameEventDefinition,
12828 ) -> Result<()> {
12829 for entry in &definition.entries {
12830 let value = self
12831 .get_field(entry)
12832 .unwrap_or_else(|_| entry.kind.default_value());
12833 stream.write(&value)?;
12834 }
12835 Ok(())
12836 }
12837}
12838#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12839#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12840pub struct PlayerUsedPowerUpBottleEvent {
12841 pub player: u16,
12842 pub kind: u16,
12843 pub time: f32,
12844}
12845impl PlayerUsedPowerUpBottleEvent {
12846 #[allow(unused_variables)]
12847 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12848 Ok(PlayerUsedPowerUpBottleEvent {
12849 player: read_value::<u16>(
12850 stream,
12851 definition.get_entry(5008278420455340480u64),
12852 "player",
12853 )?,
12854 kind: read_value::<u16>(
12855 stream,
12856 definition.get_entry(12075340201627130925u64),
12857 "kind",
12858 )?,
12859 time: read_value::<f32>(stream, definition.get_entry(2185518981507421060u64), "time")?,
12860 })
12861 }
12862 #[allow(unused_variables)]
12863 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12864 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12865 match field.hash {
12866 5008278420455340480u64 => Ok(self.player.clone().into()),
12867 12075340201627130925u64 => Ok(self.kind.clone().into()),
12868 2185518981507421060u64 => Ok(self.time.clone().into()),
12869 _ => Err(ParseError::MissingGameEventValue {
12870 ty: "PlayerUsedPowerUpBottle",
12871 field: "todo".into(),
12872 }),
12873 }
12874 }
12875 #[allow(unused_variables)]
12876 fn write(
12877 &self,
12878 stream: &mut BitWriteStream<LittleEndian>,
12879 definition: &GameEventDefinition,
12880 ) -> Result<()> {
12881 for entry in &definition.entries {
12882 let value = self
12883 .get_field(entry)
12884 .unwrap_or_else(|_| entry.kind.default_value());
12885 stream.write(&value)?;
12886 }
12887 Ok(())
12888 }
12889}
12890#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12891#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12892pub struct ChristmasGiftGrabEvent {
12893 pub user_id: u16,
12894}
12895impl ChristmasGiftGrabEvent {
12896 #[allow(unused_variables)]
12897 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12898 Ok(ChristmasGiftGrabEvent {
12899 user_id: read_value::<u16>(
12900 stream,
12901 definition.get_entry(17826443226371159423u64),
12902 "user_id",
12903 )?,
12904 })
12905 }
12906 #[allow(unused_variables)]
12907 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12908 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12909 match field.hash {
12910 17826443226371159423u64 => Ok(self.user_id.clone().into()),
12911 _ => Err(ParseError::MissingGameEventValue {
12912 ty: "ChristmasGiftGrab",
12913 field: "todo".into(),
12914 }),
12915 }
12916 }
12917 #[allow(unused_variables)]
12918 fn write(
12919 &self,
12920 stream: &mut BitWriteStream<LittleEndian>,
12921 definition: &GameEventDefinition,
12922 ) -> Result<()> {
12923 for entry in &definition.entries {
12924 let value = self
12925 .get_field(entry)
12926 .unwrap_or_else(|_| entry.kind.default_value());
12927 stream.write(&value)?;
12928 }
12929 Ok(())
12930 }
12931}
12932#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12933#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12934pub struct PlayerKilledAchievementZoneEvent {
12935 pub attacker: u16,
12936 pub victim: u16,
12937 pub zone_id: u16,
12938}
12939impl PlayerKilledAchievementZoneEvent {
12940 #[allow(unused_variables)]
12941 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12942 Ok(PlayerKilledAchievementZoneEvent {
12943 attacker: read_value::<u16>(
12944 stream,
12945 definition.get_entry(7198542740550218478u64),
12946 "attacker",
12947 )?,
12948 victim: read_value::<u16>(
12949 stream,
12950 definition.get_entry(3120917251440744469u64),
12951 "victim",
12952 )?,
12953 zone_id: read_value::<u16>(
12954 stream,
12955 definition.get_entry(15583775021870447765u64),
12956 "zone_id",
12957 )?,
12958 })
12959 }
12960 #[allow(unused_variables)]
12961 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12962 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12963 match field.hash {
12964 7198542740550218478u64 => Ok(self.attacker.clone().into()),
12965 3120917251440744469u64 => Ok(self.victim.clone().into()),
12966 15583775021870447765u64 => Ok(self.zone_id.clone().into()),
12967 _ => Err(ParseError::MissingGameEventValue {
12968 ty: "PlayerKilledAchievementZone",
12969 field: "todo".into(),
12970 }),
12971 }
12972 }
12973 #[allow(unused_variables)]
12974 fn write(
12975 &self,
12976 stream: &mut BitWriteStream<LittleEndian>,
12977 definition: &GameEventDefinition,
12978 ) -> Result<()> {
12979 for entry in &definition.entries {
12980 let value = self
12981 .get_field(entry)
12982 .unwrap_or_else(|_| entry.kind.default_value());
12983 stream.write(&value)?;
12984 }
12985 Ok(())
12986 }
12987}
12988#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
12989#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
12990pub struct PartyUpdatedEvent {}
12991impl PartyUpdatedEvent {
12992 #[allow(unused_variables)]
12993 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
12994 Ok(PartyUpdatedEvent {})
12995 }
12996 #[allow(unused_variables)]
12997 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
12998 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
12999 match field.hash {
13000 _ => Err(ParseError::MissingGameEventValue {
13001 ty: "PartyUpdated",
13002 field: "todo".into(),
13003 }),
13004 }
13005 }
13006 #[allow(unused_variables)]
13007 fn write(
13008 &self,
13009 stream: &mut BitWriteStream<LittleEndian>,
13010 definition: &GameEventDefinition,
13011 ) -> Result<()> {
13012 for entry in &definition.entries {
13013 let value = self
13014 .get_field(entry)
13015 .unwrap_or_else(|_| entry.kind.default_value());
13016 stream.write(&value)?;
13017 }
13018 Ok(())
13019 }
13020}
13021#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13022#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13023pub struct PartyPrefChangedEvent {}
13024impl PartyPrefChangedEvent {
13025 #[allow(unused_variables)]
13026 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13027 Ok(PartyPrefChangedEvent {})
13028 }
13029 #[allow(unused_variables)]
13030 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13031 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13032 match field.hash {
13033 _ => Err(ParseError::MissingGameEventValue {
13034 ty: "PartyPrefChanged",
13035 field: "todo".into(),
13036 }),
13037 }
13038 }
13039 #[allow(unused_variables)]
13040 fn write(
13041 &self,
13042 stream: &mut BitWriteStream<LittleEndian>,
13043 definition: &GameEventDefinition,
13044 ) -> Result<()> {
13045 for entry in &definition.entries {
13046 let value = self
13047 .get_field(entry)
13048 .unwrap_or_else(|_| entry.kind.default_value());
13049 stream.write(&value)?;
13050 }
13051 Ok(())
13052 }
13053}
13054#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13055#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13056pub struct PartyCriteriaChangedEvent {}
13057impl PartyCriteriaChangedEvent {
13058 #[allow(unused_variables)]
13059 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13060 Ok(PartyCriteriaChangedEvent {})
13061 }
13062 #[allow(unused_variables)]
13063 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13064 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13065 match field.hash {
13066 _ => Err(ParseError::MissingGameEventValue {
13067 ty: "PartyCriteriaChanged",
13068 field: "todo".into(),
13069 }),
13070 }
13071 }
13072 #[allow(unused_variables)]
13073 fn write(
13074 &self,
13075 stream: &mut BitWriteStream<LittleEndian>,
13076 definition: &GameEventDefinition,
13077 ) -> Result<()> {
13078 for entry in &definition.entries {
13079 let value = self
13080 .get_field(entry)
13081 .unwrap_or_else(|_| entry.kind.default_value());
13082 stream.write(&value)?;
13083 }
13084 Ok(())
13085 }
13086}
13087#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13088#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13089pub struct PartyInvitesChangedEvent {}
13090impl PartyInvitesChangedEvent {
13091 #[allow(unused_variables)]
13092 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13093 Ok(PartyInvitesChangedEvent {})
13094 }
13095 #[allow(unused_variables)]
13096 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13097 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13098 match field.hash {
13099 _ => Err(ParseError::MissingGameEventValue {
13100 ty: "PartyInvitesChanged",
13101 field: "todo".into(),
13102 }),
13103 }
13104 }
13105 #[allow(unused_variables)]
13106 fn write(
13107 &self,
13108 stream: &mut BitWriteStream<LittleEndian>,
13109 definition: &GameEventDefinition,
13110 ) -> Result<()> {
13111 for entry in &definition.entries {
13112 let value = self
13113 .get_field(entry)
13114 .unwrap_or_else(|_| entry.kind.default_value());
13115 stream.write(&value)?;
13116 }
13117 Ok(())
13118 }
13119}
13120#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13121#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13122pub struct PartyQueueStateChangedEvent {
13123 pub match_group: u16,
13124}
13125impl PartyQueueStateChangedEvent {
13126 #[allow(unused_variables)]
13127 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13128 Ok(PartyQueueStateChangedEvent {
13129 match_group: read_value::<u16>(
13130 stream,
13131 definition.get_entry(932658807224826441u64),
13132 "match_group",
13133 )?,
13134 })
13135 }
13136 #[allow(unused_variables)]
13137 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13138 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13139 match field.hash {
13140 932658807224826441u64 => Ok(self.match_group.clone().into()),
13141 _ => Err(ParseError::MissingGameEventValue {
13142 ty: "PartyQueueStateChanged",
13143 field: "todo".into(),
13144 }),
13145 }
13146 }
13147 #[allow(unused_variables)]
13148 fn write(
13149 &self,
13150 stream: &mut BitWriteStream<LittleEndian>,
13151 definition: &GameEventDefinition,
13152 ) -> Result<()> {
13153 for entry in &definition.entries {
13154 let value = self
13155 .get_field(entry)
13156 .unwrap_or_else(|_| entry.kind.default_value());
13157 stream.write(&value)?;
13158 }
13159 Ok(())
13160 }
13161}
13162#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13163#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13164pub struct PartyChatEvent {
13165 pub steam_id: MaybeUtf8String,
13166 pub text: MaybeUtf8String,
13167 pub kind: u16,
13168}
13169impl PartyChatEvent {
13170 #[allow(unused_variables)]
13171 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13172 Ok(PartyChatEvent {
13173 steam_id: read_value::<MaybeUtf8String>(
13174 stream,
13175 definition.get_entry(2266437675922439198u64),
13176 "steam_id",
13177 )?,
13178 text: read_value::<MaybeUtf8String>(
13179 stream,
13180 definition.get_entry(18015793717152399486u64),
13181 "text",
13182 )?,
13183 kind: read_value::<u16>(
13184 stream,
13185 definition.get_entry(12075340201627130925u64),
13186 "kind",
13187 )?,
13188 })
13189 }
13190 #[allow(unused_variables)]
13191 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13192 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13193 match field.hash {
13194 2266437675922439198u64 => Ok(self.steam_id.clone().into()),
13195 18015793717152399486u64 => Ok(self.text.clone().into()),
13196 12075340201627130925u64 => Ok(self.kind.clone().into()),
13197 _ => Err(ParseError::MissingGameEventValue {
13198 ty: "PartyChat",
13199 field: "todo".into(),
13200 }),
13201 }
13202 }
13203 #[allow(unused_variables)]
13204 fn write(
13205 &self,
13206 stream: &mut BitWriteStream<LittleEndian>,
13207 definition: &GameEventDefinition,
13208 ) -> Result<()> {
13209 for entry in &definition.entries {
13210 let value = self
13211 .get_field(entry)
13212 .unwrap_or_else(|_| entry.kind.default_value());
13213 stream.write(&value)?;
13214 }
13215 Ok(())
13216 }
13217}
13218#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13219#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13220pub struct PartyMemberJoinEvent {
13221 pub steam_id: MaybeUtf8String,
13222}
13223impl PartyMemberJoinEvent {
13224 #[allow(unused_variables)]
13225 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13226 Ok(PartyMemberJoinEvent {
13227 steam_id: read_value::<MaybeUtf8String>(
13228 stream,
13229 definition.get_entry(2266437675922439198u64),
13230 "steam_id",
13231 )?,
13232 })
13233 }
13234 #[allow(unused_variables)]
13235 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13236 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13237 match field.hash {
13238 2266437675922439198u64 => Ok(self.steam_id.clone().into()),
13239 _ => Err(ParseError::MissingGameEventValue {
13240 ty: "PartyMemberJoin",
13241 field: "todo".into(),
13242 }),
13243 }
13244 }
13245 #[allow(unused_variables)]
13246 fn write(
13247 &self,
13248 stream: &mut BitWriteStream<LittleEndian>,
13249 definition: &GameEventDefinition,
13250 ) -> Result<()> {
13251 for entry in &definition.entries {
13252 let value = self
13253 .get_field(entry)
13254 .unwrap_or_else(|_| entry.kind.default_value());
13255 stream.write(&value)?;
13256 }
13257 Ok(())
13258 }
13259}
13260#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13261#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13262pub struct PartyMemberLeaveEvent {
13263 pub steam_id: MaybeUtf8String,
13264}
13265impl PartyMemberLeaveEvent {
13266 #[allow(unused_variables)]
13267 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13268 Ok(PartyMemberLeaveEvent {
13269 steam_id: read_value::<MaybeUtf8String>(
13270 stream,
13271 definition.get_entry(2266437675922439198u64),
13272 "steam_id",
13273 )?,
13274 })
13275 }
13276 #[allow(unused_variables)]
13277 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13278 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13279 match field.hash {
13280 2266437675922439198u64 => Ok(self.steam_id.clone().into()),
13281 _ => Err(ParseError::MissingGameEventValue {
13282 ty: "PartyMemberLeave",
13283 field: "todo".into(),
13284 }),
13285 }
13286 }
13287 #[allow(unused_variables)]
13288 fn write(
13289 &self,
13290 stream: &mut BitWriteStream<LittleEndian>,
13291 definition: &GameEventDefinition,
13292 ) -> Result<()> {
13293 for entry in &definition.entries {
13294 let value = self
13295 .get_field(entry)
13296 .unwrap_or_else(|_| entry.kind.default_value());
13297 stream.write(&value)?;
13298 }
13299 Ok(())
13300 }
13301}
13302#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13303#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13304pub struct MatchInvitesUpdatedEvent {}
13305impl MatchInvitesUpdatedEvent {
13306 #[allow(unused_variables)]
13307 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13308 Ok(MatchInvitesUpdatedEvent {})
13309 }
13310 #[allow(unused_variables)]
13311 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13312 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13313 match field.hash {
13314 _ => Err(ParseError::MissingGameEventValue {
13315 ty: "MatchInvitesUpdated",
13316 field: "todo".into(),
13317 }),
13318 }
13319 }
13320 #[allow(unused_variables)]
13321 fn write(
13322 &self,
13323 stream: &mut BitWriteStream<LittleEndian>,
13324 definition: &GameEventDefinition,
13325 ) -> Result<()> {
13326 for entry in &definition.entries {
13327 let value = self
13328 .get_field(entry)
13329 .unwrap_or_else(|_| entry.kind.default_value());
13330 stream.write(&value)?;
13331 }
13332 Ok(())
13333 }
13334}
13335#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13336#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13337pub struct LobbyUpdatedEvent {}
13338impl LobbyUpdatedEvent {
13339 #[allow(unused_variables)]
13340 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13341 Ok(LobbyUpdatedEvent {})
13342 }
13343 #[allow(unused_variables)]
13344 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13345 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13346 match field.hash {
13347 _ => Err(ParseError::MissingGameEventValue {
13348 ty: "LobbyUpdated",
13349 field: "todo".into(),
13350 }),
13351 }
13352 }
13353 #[allow(unused_variables)]
13354 fn write(
13355 &self,
13356 stream: &mut BitWriteStream<LittleEndian>,
13357 definition: &GameEventDefinition,
13358 ) -> Result<()> {
13359 for entry in &definition.entries {
13360 let value = self
13361 .get_field(entry)
13362 .unwrap_or_else(|_| entry.kind.default_value());
13363 stream.write(&value)?;
13364 }
13365 Ok(())
13366 }
13367}
13368#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13369#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13370pub struct MvmMissionUpdateEvent {
13371 pub class: u16,
13372 pub count: u16,
13373}
13374impl MvmMissionUpdateEvent {
13375 #[allow(unused_variables)]
13376 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13377 Ok(MvmMissionUpdateEvent {
13378 class: read_value::<u16>(
13379 stream,
13380 definition.get_entry(15066323702654938015u64),
13381 "class",
13382 )?,
13383 count: read_value::<u16>(
13384 stream,
13385 definition.get_entry(12818901015042040436u64),
13386 "count",
13387 )?,
13388 })
13389 }
13390 #[allow(unused_variables)]
13391 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13392 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13393 match field.hash {
13394 15066323702654938015u64 => Ok(self.class.clone().into()),
13395 12818901015042040436u64 => Ok(self.count.clone().into()),
13396 _ => Err(ParseError::MissingGameEventValue {
13397 ty: "MvmMissionUpdate",
13398 field: "todo".into(),
13399 }),
13400 }
13401 }
13402 #[allow(unused_variables)]
13403 fn write(
13404 &self,
13405 stream: &mut BitWriteStream<LittleEndian>,
13406 definition: &GameEventDefinition,
13407 ) -> Result<()> {
13408 for entry in &definition.entries {
13409 let value = self
13410 .get_field(entry)
13411 .unwrap_or_else(|_| entry.kind.default_value());
13412 stream.write(&value)?;
13413 }
13414 Ok(())
13415 }
13416}
13417#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13418#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13419pub struct RecalculateHolidaysEvent {}
13420impl RecalculateHolidaysEvent {
13421 #[allow(unused_variables)]
13422 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13423 Ok(RecalculateHolidaysEvent {})
13424 }
13425 #[allow(unused_variables)]
13426 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13427 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13428 match field.hash {
13429 _ => Err(ParseError::MissingGameEventValue {
13430 ty: "RecalculateHolidays",
13431 field: "todo".into(),
13432 }),
13433 }
13434 }
13435 #[allow(unused_variables)]
13436 fn write(
13437 &self,
13438 stream: &mut BitWriteStream<LittleEndian>,
13439 definition: &GameEventDefinition,
13440 ) -> Result<()> {
13441 for entry in &definition.entries {
13442 let value = self
13443 .get_field(entry)
13444 .unwrap_or_else(|_| entry.kind.default_value());
13445 stream.write(&value)?;
13446 }
13447 Ok(())
13448 }
13449}
13450#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13451#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13452pub struct PlayerCurrencyChangedEvent {
13453 pub currency: u16,
13454}
13455impl PlayerCurrencyChangedEvent {
13456 #[allow(unused_variables)]
13457 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13458 Ok(PlayerCurrencyChangedEvent {
13459 currency: read_value::<u16>(
13460 stream,
13461 definition.get_entry(8477458519032517654u64),
13462 "currency",
13463 )?,
13464 })
13465 }
13466 #[allow(unused_variables)]
13467 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13468 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13469 match field.hash {
13470 8477458519032517654u64 => Ok(self.currency.clone().into()),
13471 _ => Err(ParseError::MissingGameEventValue {
13472 ty: "PlayerCurrencyChanged",
13473 field: "todo".into(),
13474 }),
13475 }
13476 }
13477 #[allow(unused_variables)]
13478 fn write(
13479 &self,
13480 stream: &mut BitWriteStream<LittleEndian>,
13481 definition: &GameEventDefinition,
13482 ) -> Result<()> {
13483 for entry in &definition.entries {
13484 let value = self
13485 .get_field(entry)
13486 .unwrap_or_else(|_| entry.kind.default_value());
13487 stream.write(&value)?;
13488 }
13489 Ok(())
13490 }
13491}
13492#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13493#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13494pub struct DoomsdayRocketOpenEvent {
13495 pub team: u8,
13496}
13497impl DoomsdayRocketOpenEvent {
13498 #[allow(unused_variables)]
13499 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13500 Ok(DoomsdayRocketOpenEvent {
13501 team: read_value::<u8>(
13502 stream,
13503 definition.get_entry(18024489754618217260u64),
13504 "team",
13505 )?,
13506 })
13507 }
13508 #[allow(unused_variables)]
13509 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13510 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13511 match field.hash {
13512 18024489754618217260u64 => Ok(self.team.clone().into()),
13513 _ => Err(ParseError::MissingGameEventValue {
13514 ty: "DoomsdayRocketOpen",
13515 field: "todo".into(),
13516 }),
13517 }
13518 }
13519 #[allow(unused_variables)]
13520 fn write(
13521 &self,
13522 stream: &mut BitWriteStream<LittleEndian>,
13523 definition: &GameEventDefinition,
13524 ) -> Result<()> {
13525 for entry in &definition.entries {
13526 let value = self
13527 .get_field(entry)
13528 .unwrap_or_else(|_| entry.kind.default_value());
13529 stream.write(&value)?;
13530 }
13531 Ok(())
13532 }
13533}
13534#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13535#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13536pub struct RemoveNemesisRelationshipsEvent {
13537 pub player: u16,
13538}
13539impl RemoveNemesisRelationshipsEvent {
13540 #[allow(unused_variables)]
13541 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13542 Ok(RemoveNemesisRelationshipsEvent {
13543 player: read_value::<u16>(
13544 stream,
13545 definition.get_entry(5008278420455340480u64),
13546 "player",
13547 )?,
13548 })
13549 }
13550 #[allow(unused_variables)]
13551 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13552 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13553 match field.hash {
13554 5008278420455340480u64 => Ok(self.player.clone().into()),
13555 _ => Err(ParseError::MissingGameEventValue {
13556 ty: "RemoveNemesisRelationships",
13557 field: "todo".into(),
13558 }),
13559 }
13560 }
13561 #[allow(unused_variables)]
13562 fn write(
13563 &self,
13564 stream: &mut BitWriteStream<LittleEndian>,
13565 definition: &GameEventDefinition,
13566 ) -> Result<()> {
13567 for entry in &definition.entries {
13568 let value = self
13569 .get_field(entry)
13570 .unwrap_or_else(|_| entry.kind.default_value());
13571 stream.write(&value)?;
13572 }
13573 Ok(())
13574 }
13575}
13576#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13577#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13578pub struct MvmCreditBonusWaveEvent {}
13579impl MvmCreditBonusWaveEvent {
13580 #[allow(unused_variables)]
13581 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13582 Ok(MvmCreditBonusWaveEvent {})
13583 }
13584 #[allow(unused_variables)]
13585 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13586 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13587 match field.hash {
13588 _ => Err(ParseError::MissingGameEventValue {
13589 ty: "MvmCreditBonusWave",
13590 field: "todo".into(),
13591 }),
13592 }
13593 }
13594 #[allow(unused_variables)]
13595 fn write(
13596 &self,
13597 stream: &mut BitWriteStream<LittleEndian>,
13598 definition: &GameEventDefinition,
13599 ) -> Result<()> {
13600 for entry in &definition.entries {
13601 let value = self
13602 .get_field(entry)
13603 .unwrap_or_else(|_| entry.kind.default_value());
13604 stream.write(&value)?;
13605 }
13606 Ok(())
13607 }
13608}
13609#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13610#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13611pub struct MvmCreditBonusAllEvent {}
13612impl MvmCreditBonusAllEvent {
13613 #[allow(unused_variables)]
13614 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13615 Ok(MvmCreditBonusAllEvent {})
13616 }
13617 #[allow(unused_variables)]
13618 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13619 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13620 match field.hash {
13621 _ => Err(ParseError::MissingGameEventValue {
13622 ty: "MvmCreditBonusAll",
13623 field: "todo".into(),
13624 }),
13625 }
13626 }
13627 #[allow(unused_variables)]
13628 fn write(
13629 &self,
13630 stream: &mut BitWriteStream<LittleEndian>,
13631 definition: &GameEventDefinition,
13632 ) -> Result<()> {
13633 for entry in &definition.entries {
13634 let value = self
13635 .get_field(entry)
13636 .unwrap_or_else(|_| entry.kind.default_value());
13637 stream.write(&value)?;
13638 }
13639 Ok(())
13640 }
13641}
13642#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13643#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13644pub struct MvmCreditBonusAllAdvancedEvent {}
13645impl MvmCreditBonusAllAdvancedEvent {
13646 #[allow(unused_variables)]
13647 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13648 Ok(MvmCreditBonusAllAdvancedEvent {})
13649 }
13650 #[allow(unused_variables)]
13651 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13652 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13653 match field.hash {
13654 _ => Err(ParseError::MissingGameEventValue {
13655 ty: "MvmCreditBonusAllAdvanced",
13656 field: "todo".into(),
13657 }),
13658 }
13659 }
13660 #[allow(unused_variables)]
13661 fn write(
13662 &self,
13663 stream: &mut BitWriteStream<LittleEndian>,
13664 definition: &GameEventDefinition,
13665 ) -> Result<()> {
13666 for entry in &definition.entries {
13667 let value = self
13668 .get_field(entry)
13669 .unwrap_or_else(|_| entry.kind.default_value());
13670 stream.write(&value)?;
13671 }
13672 Ok(())
13673 }
13674}
13675#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13676#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13677pub struct MvmQuickSentryUpgradeEvent {
13678 pub player: u16,
13679}
13680impl MvmQuickSentryUpgradeEvent {
13681 #[allow(unused_variables)]
13682 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13683 Ok(MvmQuickSentryUpgradeEvent {
13684 player: read_value::<u16>(
13685 stream,
13686 definition.get_entry(5008278420455340480u64),
13687 "player",
13688 )?,
13689 })
13690 }
13691 #[allow(unused_variables)]
13692 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13693 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13694 match field.hash {
13695 5008278420455340480u64 => Ok(self.player.clone().into()),
13696 _ => Err(ParseError::MissingGameEventValue {
13697 ty: "MvmQuickSentryUpgrade",
13698 field: "todo".into(),
13699 }),
13700 }
13701 }
13702 #[allow(unused_variables)]
13703 fn write(
13704 &self,
13705 stream: &mut BitWriteStream<LittleEndian>,
13706 definition: &GameEventDefinition,
13707 ) -> Result<()> {
13708 for entry in &definition.entries {
13709 let value = self
13710 .get_field(entry)
13711 .unwrap_or_else(|_| entry.kind.default_value());
13712 stream.write(&value)?;
13713 }
13714 Ok(())
13715 }
13716}
13717#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13718#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13719pub struct MvmTankDestroyedByPlayersEvent {}
13720impl MvmTankDestroyedByPlayersEvent {
13721 #[allow(unused_variables)]
13722 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13723 Ok(MvmTankDestroyedByPlayersEvent {})
13724 }
13725 #[allow(unused_variables)]
13726 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13727 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13728 match field.hash {
13729 _ => Err(ParseError::MissingGameEventValue {
13730 ty: "MvmTankDestroyedByPlayers",
13731 field: "todo".into(),
13732 }),
13733 }
13734 }
13735 #[allow(unused_variables)]
13736 fn write(
13737 &self,
13738 stream: &mut BitWriteStream<LittleEndian>,
13739 definition: &GameEventDefinition,
13740 ) -> Result<()> {
13741 for entry in &definition.entries {
13742 let value = self
13743 .get_field(entry)
13744 .unwrap_or_else(|_| entry.kind.default_value());
13745 stream.write(&value)?;
13746 }
13747 Ok(())
13748 }
13749}
13750#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13751#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13752pub struct MvmKillRobotDeliveringBombEvent {
13753 pub player: u16,
13754}
13755impl MvmKillRobotDeliveringBombEvent {
13756 #[allow(unused_variables)]
13757 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13758 Ok(MvmKillRobotDeliveringBombEvent {
13759 player: read_value::<u16>(
13760 stream,
13761 definition.get_entry(5008278420455340480u64),
13762 "player",
13763 )?,
13764 })
13765 }
13766 #[allow(unused_variables)]
13767 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13768 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13769 match field.hash {
13770 5008278420455340480u64 => Ok(self.player.clone().into()),
13771 _ => Err(ParseError::MissingGameEventValue {
13772 ty: "MvmKillRobotDeliveringBomb",
13773 field: "todo".into(),
13774 }),
13775 }
13776 }
13777 #[allow(unused_variables)]
13778 fn write(
13779 &self,
13780 stream: &mut BitWriteStream<LittleEndian>,
13781 definition: &GameEventDefinition,
13782 ) -> Result<()> {
13783 for entry in &definition.entries {
13784 let value = self
13785 .get_field(entry)
13786 .unwrap_or_else(|_| entry.kind.default_value());
13787 stream.write(&value)?;
13788 }
13789 Ok(())
13790 }
13791}
13792#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13793#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13794pub struct MvmPickupCurrencyEvent {
13795 pub player: u16,
13796 pub currency: u16,
13797}
13798impl MvmPickupCurrencyEvent {
13799 #[allow(unused_variables)]
13800 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13801 Ok(MvmPickupCurrencyEvent {
13802 player: read_value::<u16>(
13803 stream,
13804 definition.get_entry(5008278420455340480u64),
13805 "player",
13806 )?,
13807 currency: read_value::<u16>(
13808 stream,
13809 definition.get_entry(8477458519032517654u64),
13810 "currency",
13811 )?,
13812 })
13813 }
13814 #[allow(unused_variables)]
13815 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13816 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13817 match field.hash {
13818 5008278420455340480u64 => Ok(self.player.clone().into()),
13819 8477458519032517654u64 => Ok(self.currency.clone().into()),
13820 _ => Err(ParseError::MissingGameEventValue {
13821 ty: "MvmPickupCurrency",
13822 field: "todo".into(),
13823 }),
13824 }
13825 }
13826 #[allow(unused_variables)]
13827 fn write(
13828 &self,
13829 stream: &mut BitWriteStream<LittleEndian>,
13830 definition: &GameEventDefinition,
13831 ) -> Result<()> {
13832 for entry in &definition.entries {
13833 let value = self
13834 .get_field(entry)
13835 .unwrap_or_else(|_| entry.kind.default_value());
13836 stream.write(&value)?;
13837 }
13838 Ok(())
13839 }
13840}
13841#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13842#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13843pub struct MvmBombCarrierKilledEvent {
13844 pub level: u16,
13845}
13846impl MvmBombCarrierKilledEvent {
13847 #[allow(unused_variables)]
13848 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13849 Ok(MvmBombCarrierKilledEvent {
13850 level: read_value::<u16>(
13851 stream,
13852 definition.get_entry(16779788834081370269u64),
13853 "level",
13854 )?,
13855 })
13856 }
13857 #[allow(unused_variables)]
13858 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13859 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13860 match field.hash {
13861 16779788834081370269u64 => Ok(self.level.clone().into()),
13862 _ => Err(ParseError::MissingGameEventValue {
13863 ty: "MvmBombCarrierKilled",
13864 field: "todo".into(),
13865 }),
13866 }
13867 }
13868 #[allow(unused_variables)]
13869 fn write(
13870 &self,
13871 stream: &mut BitWriteStream<LittleEndian>,
13872 definition: &GameEventDefinition,
13873 ) -> Result<()> {
13874 for entry in &definition.entries {
13875 let value = self
13876 .get_field(entry)
13877 .unwrap_or_else(|_| entry.kind.default_value());
13878 stream.write(&value)?;
13879 }
13880 Ok(())
13881 }
13882}
13883#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13884#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13885pub struct MvmSentryBusterDetonateEvent {
13886 pub player: u16,
13887 pub det_x: f32,
13888 pub det_y: f32,
13889 pub det_z: f32,
13890}
13891impl MvmSentryBusterDetonateEvent {
13892 #[allow(unused_variables)]
13893 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13894 Ok(MvmSentryBusterDetonateEvent {
13895 player: read_value::<u16>(
13896 stream,
13897 definition.get_entry(5008278420455340480u64),
13898 "player",
13899 )?,
13900 det_x: read_value::<f32>(
13901 stream,
13902 definition.get_entry(10880309079248206573u64),
13903 "det_x",
13904 )?,
13905 det_y: read_value::<f32>(
13906 stream,
13907 definition.get_entry(10880307979736578362u64),
13908 "det_y",
13909 )?,
13910 det_z: read_value::<f32>(
13911 stream,
13912 definition.get_entry(10880306880224950151u64),
13913 "det_z",
13914 )?,
13915 })
13916 }
13917 #[allow(unused_variables)]
13918 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13919 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13920 match field.hash {
13921 5008278420455340480u64 => Ok(self.player.clone().into()),
13922 10880309079248206573u64 => Ok(self.det_x.clone().into()),
13923 10880307979736578362u64 => Ok(self.det_y.clone().into()),
13924 10880306880224950151u64 => Ok(self.det_z.clone().into()),
13925 _ => Err(ParseError::MissingGameEventValue {
13926 ty: "MvmSentryBusterDetonate",
13927 field: "todo".into(),
13928 }),
13929 }
13930 }
13931 #[allow(unused_variables)]
13932 fn write(
13933 &self,
13934 stream: &mut BitWriteStream<LittleEndian>,
13935 definition: &GameEventDefinition,
13936 ) -> Result<()> {
13937 for entry in &definition.entries {
13938 let value = self
13939 .get_field(entry)
13940 .unwrap_or_else(|_| entry.kind.default_value());
13941 stream.write(&value)?;
13942 }
13943 Ok(())
13944 }
13945}
13946#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13947#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13948pub struct MvmScoutMarkedForDeathEvent {
13949 pub player: u16,
13950}
13951impl MvmScoutMarkedForDeathEvent {
13952 #[allow(unused_variables)]
13953 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13954 Ok(MvmScoutMarkedForDeathEvent {
13955 player: read_value::<u16>(
13956 stream,
13957 definition.get_entry(5008278420455340480u64),
13958 "player",
13959 )?,
13960 })
13961 }
13962 #[allow(unused_variables)]
13963 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
13964 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
13965 match field.hash {
13966 5008278420455340480u64 => Ok(self.player.clone().into()),
13967 _ => Err(ParseError::MissingGameEventValue {
13968 ty: "MvmScoutMarkedForDeath",
13969 field: "todo".into(),
13970 }),
13971 }
13972 }
13973 #[allow(unused_variables)]
13974 fn write(
13975 &self,
13976 stream: &mut BitWriteStream<LittleEndian>,
13977 definition: &GameEventDefinition,
13978 ) -> Result<()> {
13979 for entry in &definition.entries {
13980 let value = self
13981 .get_field(entry)
13982 .unwrap_or_else(|_| entry.kind.default_value());
13983 stream.write(&value)?;
13984 }
13985 Ok(())
13986 }
13987}
13988#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
13989#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
13990pub struct MvmMedicPowerUpSharedEvent {
13991 pub player: u16,
13992}
13993impl MvmMedicPowerUpSharedEvent {
13994 #[allow(unused_variables)]
13995 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
13996 Ok(MvmMedicPowerUpSharedEvent {
13997 player: read_value::<u16>(
13998 stream,
13999 definition.get_entry(5008278420455340480u64),
14000 "player",
14001 )?,
14002 })
14003 }
14004 #[allow(unused_variables)]
14005 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14006 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14007 match field.hash {
14008 5008278420455340480u64 => Ok(self.player.clone().into()),
14009 _ => Err(ParseError::MissingGameEventValue {
14010 ty: "MvmMedicPowerUpShared",
14011 field: "todo".into(),
14012 }),
14013 }
14014 }
14015 #[allow(unused_variables)]
14016 fn write(
14017 &self,
14018 stream: &mut BitWriteStream<LittleEndian>,
14019 definition: &GameEventDefinition,
14020 ) -> Result<()> {
14021 for entry in &definition.entries {
14022 let value = self
14023 .get_field(entry)
14024 .unwrap_or_else(|_| entry.kind.default_value());
14025 stream.write(&value)?;
14026 }
14027 Ok(())
14028 }
14029}
14030#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14031#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14032pub struct MvmBeginWaveEvent {
14033 pub wave_index: u16,
14034 pub max_waves: u16,
14035 pub advanced: u16,
14036}
14037impl MvmBeginWaveEvent {
14038 #[allow(unused_variables)]
14039 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14040 Ok(MvmBeginWaveEvent {
14041 wave_index: read_value::<u16>(
14042 stream,
14043 definition.get_entry(3508416600111464007u64),
14044 "wave_index",
14045 )?,
14046 max_waves: read_value::<u16>(
14047 stream,
14048 definition.get_entry(16186306532262586848u64),
14049 "max_waves",
14050 )?,
14051 advanced: read_value::<u16>(
14052 stream,
14053 definition.get_entry(2115851684636468731u64),
14054 "advanced",
14055 )?,
14056 })
14057 }
14058 #[allow(unused_variables)]
14059 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14060 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14061 match field.hash {
14062 3508416600111464007u64 => Ok(self.wave_index.clone().into()),
14063 16186306532262586848u64 => Ok(self.max_waves.clone().into()),
14064 2115851684636468731u64 => Ok(self.advanced.clone().into()),
14065 _ => Err(ParseError::MissingGameEventValue {
14066 ty: "MvmBeginWave",
14067 field: "todo".into(),
14068 }),
14069 }
14070 }
14071 #[allow(unused_variables)]
14072 fn write(
14073 &self,
14074 stream: &mut BitWriteStream<LittleEndian>,
14075 definition: &GameEventDefinition,
14076 ) -> Result<()> {
14077 for entry in &definition.entries {
14078 let value = self
14079 .get_field(entry)
14080 .unwrap_or_else(|_| entry.kind.default_value());
14081 stream.write(&value)?;
14082 }
14083 Ok(())
14084 }
14085}
14086#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14087#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14088pub struct MvmWaveCompleteEvent {
14089 pub advanced: bool,
14090}
14091impl MvmWaveCompleteEvent {
14092 #[allow(unused_variables)]
14093 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14094 Ok(MvmWaveCompleteEvent {
14095 advanced: read_value::<bool>(
14096 stream,
14097 definition.get_entry(2115851684636468731u64),
14098 "advanced",
14099 )?,
14100 })
14101 }
14102 #[allow(unused_variables)]
14103 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14104 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14105 match field.hash {
14106 2115851684636468731u64 => Ok(self.advanced.clone().into()),
14107 _ => Err(ParseError::MissingGameEventValue {
14108 ty: "MvmWaveComplete",
14109 field: "todo".into(),
14110 }),
14111 }
14112 }
14113 #[allow(unused_variables)]
14114 fn write(
14115 &self,
14116 stream: &mut BitWriteStream<LittleEndian>,
14117 definition: &GameEventDefinition,
14118 ) -> Result<()> {
14119 for entry in &definition.entries {
14120 let value = self
14121 .get_field(entry)
14122 .unwrap_or_else(|_| entry.kind.default_value());
14123 stream.write(&value)?;
14124 }
14125 Ok(())
14126 }
14127}
14128#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14129#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14130pub struct MvmMissionCompleteEvent {
14131 pub mission: MaybeUtf8String,
14132}
14133impl MvmMissionCompleteEvent {
14134 #[allow(unused_variables)]
14135 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14136 Ok(MvmMissionCompleteEvent {
14137 mission: read_value::<MaybeUtf8String>(
14138 stream,
14139 definition.get_entry(9969423424304279641u64),
14140 "mission",
14141 )?,
14142 })
14143 }
14144 #[allow(unused_variables)]
14145 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14146 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14147 match field.hash {
14148 9969423424304279641u64 => Ok(self.mission.clone().into()),
14149 _ => Err(ParseError::MissingGameEventValue {
14150 ty: "MvmMissionComplete",
14151 field: "todo".into(),
14152 }),
14153 }
14154 }
14155 #[allow(unused_variables)]
14156 fn write(
14157 &self,
14158 stream: &mut BitWriteStream<LittleEndian>,
14159 definition: &GameEventDefinition,
14160 ) -> Result<()> {
14161 for entry in &definition.entries {
14162 let value = self
14163 .get_field(entry)
14164 .unwrap_or_else(|_| entry.kind.default_value());
14165 stream.write(&value)?;
14166 }
14167 Ok(())
14168 }
14169}
14170#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14171#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14172pub struct MvmBombResetByPlayerEvent {
14173 pub player: u16,
14174}
14175impl MvmBombResetByPlayerEvent {
14176 #[allow(unused_variables)]
14177 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14178 Ok(MvmBombResetByPlayerEvent {
14179 player: read_value::<u16>(
14180 stream,
14181 definition.get_entry(5008278420455340480u64),
14182 "player",
14183 )?,
14184 })
14185 }
14186 #[allow(unused_variables)]
14187 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14188 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14189 match field.hash {
14190 5008278420455340480u64 => Ok(self.player.clone().into()),
14191 _ => Err(ParseError::MissingGameEventValue {
14192 ty: "MvmBombResetByPlayer",
14193 field: "todo".into(),
14194 }),
14195 }
14196 }
14197 #[allow(unused_variables)]
14198 fn write(
14199 &self,
14200 stream: &mut BitWriteStream<LittleEndian>,
14201 definition: &GameEventDefinition,
14202 ) -> Result<()> {
14203 for entry in &definition.entries {
14204 let value = self
14205 .get_field(entry)
14206 .unwrap_or_else(|_| entry.kind.default_value());
14207 stream.write(&value)?;
14208 }
14209 Ok(())
14210 }
14211}
14212#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14213#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14214pub struct MvmBombAlarmTriggeredEvent {}
14215impl MvmBombAlarmTriggeredEvent {
14216 #[allow(unused_variables)]
14217 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14218 Ok(MvmBombAlarmTriggeredEvent {})
14219 }
14220 #[allow(unused_variables)]
14221 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14222 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14223 match field.hash {
14224 _ => Err(ParseError::MissingGameEventValue {
14225 ty: "MvmBombAlarmTriggered",
14226 field: "todo".into(),
14227 }),
14228 }
14229 }
14230 #[allow(unused_variables)]
14231 fn write(
14232 &self,
14233 stream: &mut BitWriteStream<LittleEndian>,
14234 definition: &GameEventDefinition,
14235 ) -> Result<()> {
14236 for entry in &definition.entries {
14237 let value = self
14238 .get_field(entry)
14239 .unwrap_or_else(|_| entry.kind.default_value());
14240 stream.write(&value)?;
14241 }
14242 Ok(())
14243 }
14244}
14245#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14246#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14247pub struct MvmBombDeployResetByPlayerEvent {
14248 pub player: u16,
14249}
14250impl MvmBombDeployResetByPlayerEvent {
14251 #[allow(unused_variables)]
14252 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14253 Ok(MvmBombDeployResetByPlayerEvent {
14254 player: read_value::<u16>(
14255 stream,
14256 definition.get_entry(5008278420455340480u64),
14257 "player",
14258 )?,
14259 })
14260 }
14261 #[allow(unused_variables)]
14262 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14263 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14264 match field.hash {
14265 5008278420455340480u64 => Ok(self.player.clone().into()),
14266 _ => Err(ParseError::MissingGameEventValue {
14267 ty: "MvmBombDeployResetByPlayer",
14268 field: "todo".into(),
14269 }),
14270 }
14271 }
14272 #[allow(unused_variables)]
14273 fn write(
14274 &self,
14275 stream: &mut BitWriteStream<LittleEndian>,
14276 definition: &GameEventDefinition,
14277 ) -> Result<()> {
14278 for entry in &definition.entries {
14279 let value = self
14280 .get_field(entry)
14281 .unwrap_or_else(|_| entry.kind.default_value());
14282 stream.write(&value)?;
14283 }
14284 Ok(())
14285 }
14286}
14287#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14288#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14289pub struct MvmWaveFailedEvent {}
14290impl MvmWaveFailedEvent {
14291 #[allow(unused_variables)]
14292 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14293 Ok(MvmWaveFailedEvent {})
14294 }
14295 #[allow(unused_variables)]
14296 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14297 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14298 match field.hash {
14299 _ => Err(ParseError::MissingGameEventValue {
14300 ty: "MvmWaveFailed",
14301 field: "todo".into(),
14302 }),
14303 }
14304 }
14305 #[allow(unused_variables)]
14306 fn write(
14307 &self,
14308 stream: &mut BitWriteStream<LittleEndian>,
14309 definition: &GameEventDefinition,
14310 ) -> Result<()> {
14311 for entry in &definition.entries {
14312 let value = self
14313 .get_field(entry)
14314 .unwrap_or_else(|_| entry.kind.default_value());
14315 stream.write(&value)?;
14316 }
14317 Ok(())
14318 }
14319}
14320#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14321#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14322pub struct MvmResetStatsEvent {}
14323impl MvmResetStatsEvent {
14324 #[allow(unused_variables)]
14325 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14326 Ok(MvmResetStatsEvent {})
14327 }
14328 #[allow(unused_variables)]
14329 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14330 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14331 match field.hash {
14332 _ => Err(ParseError::MissingGameEventValue {
14333 ty: "MvmResetStats",
14334 field: "todo".into(),
14335 }),
14336 }
14337 }
14338 #[allow(unused_variables)]
14339 fn write(
14340 &self,
14341 stream: &mut BitWriteStream<LittleEndian>,
14342 definition: &GameEventDefinition,
14343 ) -> Result<()> {
14344 for entry in &definition.entries {
14345 let value = self
14346 .get_field(entry)
14347 .unwrap_or_else(|_| entry.kind.default_value());
14348 stream.write(&value)?;
14349 }
14350 Ok(())
14351 }
14352}
14353#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14354#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14355pub struct DamageResistedEvent {
14356 pub ent_index: u8,
14357}
14358impl DamageResistedEvent {
14359 #[allow(unused_variables)]
14360 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14361 Ok(DamageResistedEvent {
14362 ent_index: read_value::<u8>(
14363 stream,
14364 definition.get_entry(17554918082946193550u64),
14365 "ent_index",
14366 )?,
14367 })
14368 }
14369 #[allow(unused_variables)]
14370 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14371 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14372 match field.hash {
14373 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
14374 _ => Err(ParseError::MissingGameEventValue {
14375 ty: "DamageResisted",
14376 field: "todo".into(),
14377 }),
14378 }
14379 }
14380 #[allow(unused_variables)]
14381 fn write(
14382 &self,
14383 stream: &mut BitWriteStream<LittleEndian>,
14384 definition: &GameEventDefinition,
14385 ) -> Result<()> {
14386 for entry in &definition.entries {
14387 let value = self
14388 .get_field(entry)
14389 .unwrap_or_else(|_| entry.kind.default_value());
14390 stream.write(&value)?;
14391 }
14392 Ok(())
14393 }
14394}
14395#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14396#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14397pub struct RevivePlayerNotifyEvent {
14398 pub ent_index: u16,
14399 pub marker_ent_index: u16,
14400}
14401impl RevivePlayerNotifyEvent {
14402 #[allow(unused_variables)]
14403 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14404 Ok(RevivePlayerNotifyEvent {
14405 ent_index: read_value::<u16>(
14406 stream,
14407 definition.get_entry(17554918082946193550u64),
14408 "ent_index",
14409 )?,
14410 marker_ent_index: read_value::<u16>(
14411 stream,
14412 definition.get_entry(3793715953080702003u64),
14413 "marker_ent_index",
14414 )?,
14415 })
14416 }
14417 #[allow(unused_variables)]
14418 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14419 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14420 match field.hash {
14421 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
14422 3793715953080702003u64 => Ok(self.marker_ent_index.clone().into()),
14423 _ => Err(ParseError::MissingGameEventValue {
14424 ty: "RevivePlayerNotify",
14425 field: "todo".into(),
14426 }),
14427 }
14428 }
14429 #[allow(unused_variables)]
14430 fn write(
14431 &self,
14432 stream: &mut BitWriteStream<LittleEndian>,
14433 definition: &GameEventDefinition,
14434 ) -> Result<()> {
14435 for entry in &definition.entries {
14436 let value = self
14437 .get_field(entry)
14438 .unwrap_or_else(|_| entry.kind.default_value());
14439 stream.write(&value)?;
14440 }
14441 Ok(())
14442 }
14443}
14444#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14445#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14446pub struct RevivePlayerStoppedEvent {
14447 pub ent_index: u16,
14448}
14449impl RevivePlayerStoppedEvent {
14450 #[allow(unused_variables)]
14451 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14452 Ok(RevivePlayerStoppedEvent {
14453 ent_index: read_value::<u16>(
14454 stream,
14455 definition.get_entry(17554918082946193550u64),
14456 "ent_index",
14457 )?,
14458 })
14459 }
14460 #[allow(unused_variables)]
14461 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14462 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14463 match field.hash {
14464 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
14465 _ => Err(ParseError::MissingGameEventValue {
14466 ty: "RevivePlayerStopped",
14467 field: "todo".into(),
14468 }),
14469 }
14470 }
14471 #[allow(unused_variables)]
14472 fn write(
14473 &self,
14474 stream: &mut BitWriteStream<LittleEndian>,
14475 definition: &GameEventDefinition,
14476 ) -> Result<()> {
14477 for entry in &definition.entries {
14478 let value = self
14479 .get_field(entry)
14480 .unwrap_or_else(|_| entry.kind.default_value());
14481 stream.write(&value)?;
14482 }
14483 Ok(())
14484 }
14485}
14486#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14487#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14488pub struct RevivePlayerCompleteEvent {
14489 pub ent_index: u16,
14490}
14491impl RevivePlayerCompleteEvent {
14492 #[allow(unused_variables)]
14493 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14494 Ok(RevivePlayerCompleteEvent {
14495 ent_index: read_value::<u16>(
14496 stream,
14497 definition.get_entry(17554918082946193550u64),
14498 "ent_index",
14499 )?,
14500 })
14501 }
14502 #[allow(unused_variables)]
14503 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14504 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14505 match field.hash {
14506 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
14507 _ => Err(ParseError::MissingGameEventValue {
14508 ty: "RevivePlayerComplete",
14509 field: "todo".into(),
14510 }),
14511 }
14512 }
14513 #[allow(unused_variables)]
14514 fn write(
14515 &self,
14516 stream: &mut BitWriteStream<LittleEndian>,
14517 definition: &GameEventDefinition,
14518 ) -> Result<()> {
14519 for entry in &definition.entries {
14520 let value = self
14521 .get_field(entry)
14522 .unwrap_or_else(|_| entry.kind.default_value());
14523 stream.write(&value)?;
14524 }
14525 Ok(())
14526 }
14527}
14528#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14529#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14530pub struct PlayerTurnedToGhostEvent {
14531 pub user_id: u16,
14532}
14533impl PlayerTurnedToGhostEvent {
14534 #[allow(unused_variables)]
14535 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14536 Ok(PlayerTurnedToGhostEvent {
14537 user_id: read_value::<u16>(
14538 stream,
14539 definition.get_entry(17826443226371159423u64),
14540 "user_id",
14541 )?,
14542 })
14543 }
14544 #[allow(unused_variables)]
14545 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14546 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14547 match field.hash {
14548 17826443226371159423u64 => Ok(self.user_id.clone().into()),
14549 _ => Err(ParseError::MissingGameEventValue {
14550 ty: "PlayerTurnedToGhost",
14551 field: "todo".into(),
14552 }),
14553 }
14554 }
14555 #[allow(unused_variables)]
14556 fn write(
14557 &self,
14558 stream: &mut BitWriteStream<LittleEndian>,
14559 definition: &GameEventDefinition,
14560 ) -> Result<()> {
14561 for entry in &definition.entries {
14562 let value = self
14563 .get_field(entry)
14564 .unwrap_or_else(|_| entry.kind.default_value());
14565 stream.write(&value)?;
14566 }
14567 Ok(())
14568 }
14569}
14570#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14571#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14572pub struct MedigunShieldBlockedDamageEvent {
14573 pub user_id: u16,
14574 pub damage: f32,
14575}
14576impl MedigunShieldBlockedDamageEvent {
14577 #[allow(unused_variables)]
14578 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14579 Ok(MedigunShieldBlockedDamageEvent {
14580 user_id: read_value::<u16>(
14581 stream,
14582 definition.get_entry(17826443226371159423u64),
14583 "user_id",
14584 )?,
14585 damage: read_value::<f32>(
14586 stream,
14587 definition.get_entry(9179190079975030720u64),
14588 "damage",
14589 )?,
14590 })
14591 }
14592 #[allow(unused_variables)]
14593 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14594 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14595 match field.hash {
14596 17826443226371159423u64 => Ok(self.user_id.clone().into()),
14597 9179190079975030720u64 => Ok(self.damage.clone().into()),
14598 _ => Err(ParseError::MissingGameEventValue {
14599 ty: "MedigunShieldBlockedDamage",
14600 field: "todo".into(),
14601 }),
14602 }
14603 }
14604 #[allow(unused_variables)]
14605 fn write(
14606 &self,
14607 stream: &mut BitWriteStream<LittleEndian>,
14608 definition: &GameEventDefinition,
14609 ) -> Result<()> {
14610 for entry in &definition.entries {
14611 let value = self
14612 .get_field(entry)
14613 .unwrap_or_else(|_| entry.kind.default_value());
14614 stream.write(&value)?;
14615 }
14616 Ok(())
14617 }
14618}
14619#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14620#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14621pub struct MvmAdvWaveCompleteNoGatesEvent {
14622 pub index: u16,
14623}
14624impl MvmAdvWaveCompleteNoGatesEvent {
14625 #[allow(unused_variables)]
14626 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14627 Ok(MvmAdvWaveCompleteNoGatesEvent {
14628 index: read_value::<u16>(
14629 stream,
14630 definition.get_entry(9497966886403524235u64),
14631 "index",
14632 )?,
14633 })
14634 }
14635 #[allow(unused_variables)]
14636 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14637 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14638 match field.hash {
14639 9497966886403524235u64 => Ok(self.index.clone().into()),
14640 _ => Err(ParseError::MissingGameEventValue {
14641 ty: "MvmAdvWaveCompleteNoGates",
14642 field: "todo".into(),
14643 }),
14644 }
14645 }
14646 #[allow(unused_variables)]
14647 fn write(
14648 &self,
14649 stream: &mut BitWriteStream<LittleEndian>,
14650 definition: &GameEventDefinition,
14651 ) -> Result<()> {
14652 for entry in &definition.entries {
14653 let value = self
14654 .get_field(entry)
14655 .unwrap_or_else(|_| entry.kind.default_value());
14656 stream.write(&value)?;
14657 }
14658 Ok(())
14659 }
14660}
14661#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14662#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14663pub struct MvmSniperHeadshotCurrencyEvent {
14664 pub user_id: u16,
14665 pub currency: u16,
14666}
14667impl MvmSniperHeadshotCurrencyEvent {
14668 #[allow(unused_variables)]
14669 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14670 Ok(MvmSniperHeadshotCurrencyEvent {
14671 user_id: read_value::<u16>(
14672 stream,
14673 definition.get_entry(17826443226371159423u64),
14674 "user_id",
14675 )?,
14676 currency: read_value::<u16>(
14677 stream,
14678 definition.get_entry(8477458519032517654u64),
14679 "currency",
14680 )?,
14681 })
14682 }
14683 #[allow(unused_variables)]
14684 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14685 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14686 match field.hash {
14687 17826443226371159423u64 => Ok(self.user_id.clone().into()),
14688 8477458519032517654u64 => Ok(self.currency.clone().into()),
14689 _ => Err(ParseError::MissingGameEventValue {
14690 ty: "MvmSniperHeadshotCurrency",
14691 field: "todo".into(),
14692 }),
14693 }
14694 }
14695 #[allow(unused_variables)]
14696 fn write(
14697 &self,
14698 stream: &mut BitWriteStream<LittleEndian>,
14699 definition: &GameEventDefinition,
14700 ) -> Result<()> {
14701 for entry in &definition.entries {
14702 let value = self
14703 .get_field(entry)
14704 .unwrap_or_else(|_| entry.kind.default_value());
14705 stream.write(&value)?;
14706 }
14707 Ok(())
14708 }
14709}
14710#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14711#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14712pub struct MvmMannhattanPitEvent {}
14713impl MvmMannhattanPitEvent {
14714 #[allow(unused_variables)]
14715 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14716 Ok(MvmMannhattanPitEvent {})
14717 }
14718 #[allow(unused_variables)]
14719 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14720 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14721 match field.hash {
14722 _ => Err(ParseError::MissingGameEventValue {
14723 ty: "MvmMannhattanPit",
14724 field: "todo".into(),
14725 }),
14726 }
14727 }
14728 #[allow(unused_variables)]
14729 fn write(
14730 &self,
14731 stream: &mut BitWriteStream<LittleEndian>,
14732 definition: &GameEventDefinition,
14733 ) -> Result<()> {
14734 for entry in &definition.entries {
14735 let value = self
14736 .get_field(entry)
14737 .unwrap_or_else(|_| entry.kind.default_value());
14738 stream.write(&value)?;
14739 }
14740 Ok(())
14741 }
14742}
14743#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14744#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14745pub struct FlagCarriedInDetectionZoneEvent {}
14746impl FlagCarriedInDetectionZoneEvent {
14747 #[allow(unused_variables)]
14748 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14749 Ok(FlagCarriedInDetectionZoneEvent {})
14750 }
14751 #[allow(unused_variables)]
14752 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14753 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14754 match field.hash {
14755 _ => Err(ParseError::MissingGameEventValue {
14756 ty: "FlagCarriedInDetectionZone",
14757 field: "todo".into(),
14758 }),
14759 }
14760 }
14761 #[allow(unused_variables)]
14762 fn write(
14763 &self,
14764 stream: &mut BitWriteStream<LittleEndian>,
14765 definition: &GameEventDefinition,
14766 ) -> Result<()> {
14767 for entry in &definition.entries {
14768 let value = self
14769 .get_field(entry)
14770 .unwrap_or_else(|_| entry.kind.default_value());
14771 stream.write(&value)?;
14772 }
14773 Ok(())
14774 }
14775}
14776#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14777#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14778pub struct MvmAdvWaveKilledStunRadioEvent {}
14779impl MvmAdvWaveKilledStunRadioEvent {
14780 #[allow(unused_variables)]
14781 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14782 Ok(MvmAdvWaveKilledStunRadioEvent {})
14783 }
14784 #[allow(unused_variables)]
14785 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14786 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14787 match field.hash {
14788 _ => Err(ParseError::MissingGameEventValue {
14789 ty: "MvmAdvWaveKilledStunRadio",
14790 field: "todo".into(),
14791 }),
14792 }
14793 }
14794 #[allow(unused_variables)]
14795 fn write(
14796 &self,
14797 stream: &mut BitWriteStream<LittleEndian>,
14798 definition: &GameEventDefinition,
14799 ) -> Result<()> {
14800 for entry in &definition.entries {
14801 let value = self
14802 .get_field(entry)
14803 .unwrap_or_else(|_| entry.kind.default_value());
14804 stream.write(&value)?;
14805 }
14806 Ok(())
14807 }
14808}
14809#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14810#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14811pub struct PlayerDirectHitStunEvent {
14812 pub attacker: u16,
14813 pub victim: u16,
14814}
14815impl PlayerDirectHitStunEvent {
14816 #[allow(unused_variables)]
14817 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14818 Ok(PlayerDirectHitStunEvent {
14819 attacker: read_value::<u16>(
14820 stream,
14821 definition.get_entry(7198542740550218478u64),
14822 "attacker",
14823 )?,
14824 victim: read_value::<u16>(
14825 stream,
14826 definition.get_entry(3120917251440744469u64),
14827 "victim",
14828 )?,
14829 })
14830 }
14831 #[allow(unused_variables)]
14832 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14833 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14834 match field.hash {
14835 7198542740550218478u64 => Ok(self.attacker.clone().into()),
14836 3120917251440744469u64 => Ok(self.victim.clone().into()),
14837 _ => Err(ParseError::MissingGameEventValue {
14838 ty: "PlayerDirectHitStun",
14839 field: "todo".into(),
14840 }),
14841 }
14842 }
14843 #[allow(unused_variables)]
14844 fn write(
14845 &self,
14846 stream: &mut BitWriteStream<LittleEndian>,
14847 definition: &GameEventDefinition,
14848 ) -> Result<()> {
14849 for entry in &definition.entries {
14850 let value = self
14851 .get_field(entry)
14852 .unwrap_or_else(|_| entry.kind.default_value());
14853 stream.write(&value)?;
14854 }
14855 Ok(())
14856 }
14857}
14858#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14859#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14860pub struct MvmSentryBusterKilledEvent {
14861 pub sentry_buster: u16,
14862}
14863impl MvmSentryBusterKilledEvent {
14864 #[allow(unused_variables)]
14865 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14866 Ok(MvmSentryBusterKilledEvent {
14867 sentry_buster: read_value::<u16>(
14868 stream,
14869 definition.get_entry(7717696824740572250u64),
14870 "sentry_buster",
14871 )?,
14872 })
14873 }
14874 #[allow(unused_variables)]
14875 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14876 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14877 match field.hash {
14878 7717696824740572250u64 => Ok(self.sentry_buster.clone().into()),
14879 _ => Err(ParseError::MissingGameEventValue {
14880 ty: "MvmSentryBusterKilled",
14881 field: "todo".into(),
14882 }),
14883 }
14884 }
14885 #[allow(unused_variables)]
14886 fn write(
14887 &self,
14888 stream: &mut BitWriteStream<LittleEndian>,
14889 definition: &GameEventDefinition,
14890 ) -> Result<()> {
14891 for entry in &definition.entries {
14892 let value = self
14893 .get_field(entry)
14894 .unwrap_or_else(|_| entry.kind.default_value());
14895 stream.write(&value)?;
14896 }
14897 Ok(())
14898 }
14899}
14900#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14901#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14902pub struct UpgradesFileChangedEvent {
14903 pub path: MaybeUtf8String,
14904}
14905impl UpgradesFileChangedEvent {
14906 #[allow(unused_variables)]
14907 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14908 Ok(UpgradesFileChangedEvent {
14909 path: read_value::<MaybeUtf8String>(
14910 stream,
14911 definition.get_entry(271672890340345462u64),
14912 "path",
14913 )?,
14914 })
14915 }
14916 #[allow(unused_variables)]
14917 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14918 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14919 match field.hash {
14920 271672890340345462u64 => Ok(self.path.clone().into()),
14921 _ => Err(ParseError::MissingGameEventValue {
14922 ty: "UpgradesFileChanged",
14923 field: "todo".into(),
14924 }),
14925 }
14926 }
14927 #[allow(unused_variables)]
14928 fn write(
14929 &self,
14930 stream: &mut BitWriteStream<LittleEndian>,
14931 definition: &GameEventDefinition,
14932 ) -> Result<()> {
14933 for entry in &definition.entries {
14934 let value = self
14935 .get_field(entry)
14936 .unwrap_or_else(|_| entry.kind.default_value());
14937 stream.write(&value)?;
14938 }
14939 Ok(())
14940 }
14941}
14942#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14943#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
14944pub struct RdTeamPointsChangedEvent {
14945 pub points: u16,
14946 pub team: u8,
14947 pub method: u8,
14948}
14949impl RdTeamPointsChangedEvent {
14950 #[allow(unused_variables)]
14951 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
14952 Ok(RdTeamPointsChangedEvent {
14953 points: read_value::<u16>(
14954 stream,
14955 definition.get_entry(15925482014108518566u64),
14956 "points",
14957 )?,
14958 team: read_value::<u8>(
14959 stream,
14960 definition.get_entry(18024489754618217260u64),
14961 "team",
14962 )?,
14963 method: read_value::<u8>(
14964 stream,
14965 definition.get_entry(2525399976365011888u64),
14966 "method",
14967 )?,
14968 })
14969 }
14970 #[allow(unused_variables)]
14971 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
14972 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
14973 match field.hash {
14974 15925482014108518566u64 => Ok(self.points.clone().into()),
14975 18024489754618217260u64 => Ok(self.team.clone().into()),
14976 2525399976365011888u64 => Ok(self.method.clone().into()),
14977 _ => Err(ParseError::MissingGameEventValue {
14978 ty: "RdTeamPointsChanged",
14979 field: "todo".into(),
14980 }),
14981 }
14982 }
14983 #[allow(unused_variables)]
14984 fn write(
14985 &self,
14986 stream: &mut BitWriteStream<LittleEndian>,
14987 definition: &GameEventDefinition,
14988 ) -> Result<()> {
14989 for entry in &definition.entries {
14990 let value = self
14991 .get_field(entry)
14992 .unwrap_or_else(|_| entry.kind.default_value());
14993 stream.write(&value)?;
14994 }
14995 Ok(())
14996 }
14997}
14998#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
14999#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15000pub struct RdRulesStateChangedEvent {}
15001impl RdRulesStateChangedEvent {
15002 #[allow(unused_variables)]
15003 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15004 Ok(RdRulesStateChangedEvent {})
15005 }
15006 #[allow(unused_variables)]
15007 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15008 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15009 match field.hash {
15010 _ => Err(ParseError::MissingGameEventValue {
15011 ty: "RdRulesStateChanged",
15012 field: "todo".into(),
15013 }),
15014 }
15015 }
15016 #[allow(unused_variables)]
15017 fn write(
15018 &self,
15019 stream: &mut BitWriteStream<LittleEndian>,
15020 definition: &GameEventDefinition,
15021 ) -> Result<()> {
15022 for entry in &definition.entries {
15023 let value = self
15024 .get_field(entry)
15025 .unwrap_or_else(|_| entry.kind.default_value());
15026 stream.write(&value)?;
15027 }
15028 Ok(())
15029 }
15030}
15031#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15032#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15033pub struct RdRobotKilledEvent {
15034 pub user_id: u16,
15035 pub victim_ent_index: u32,
15036 pub inflictor_ent_index: u32,
15037 pub attacker: u16,
15038 pub weapon: MaybeUtf8String,
15039 pub weapon_id: u16,
15040 pub damage_bits: u32,
15041 pub custom_kill: u16,
15042 pub weapon_log_class_name: MaybeUtf8String,
15043}
15044impl RdRobotKilledEvent {
15045 #[allow(unused_variables)]
15046 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15047 Ok(RdRobotKilledEvent {
15048 user_id: read_value::<u16>(
15049 stream,
15050 definition.get_entry(17826443226371159423u64),
15051 "user_id",
15052 )?,
15053 victim_ent_index: read_value::<u32>(
15054 stream,
15055 definition.get_entry(7608903543976233025u64),
15056 "victim_ent_index",
15057 )?,
15058 inflictor_ent_index: read_value::<u32>(
15059 stream,
15060 definition.get_entry(7862267791693534473u64),
15061 "inflictor_ent_index",
15062 )?,
15063 attacker: read_value::<u16>(
15064 stream,
15065 definition.get_entry(7198542740550218478u64),
15066 "attacker",
15067 )?,
15068 weapon: read_value::<MaybeUtf8String>(
15069 stream,
15070 definition.get_entry(11580461223051554305u64),
15071 "weapon",
15072 )?,
15073 weapon_id: read_value::<u16>(
15074 stream,
15075 definition.get_entry(5542695206485500884u64),
15076 "weapon_id",
15077 )?,
15078 damage_bits: read_value::<u32>(
15079 stream,
15080 definition.get_entry(2104626753992558984u64),
15081 "damage_bits",
15082 )?,
15083 custom_kill: read_value::<u16>(
15084 stream,
15085 definition.get_entry(9002408094759571186u64),
15086 "custom_kill",
15087 )?,
15088 weapon_log_class_name: read_value::<MaybeUtf8String>(
15089 stream,
15090 definition.get_entry(8214628514117900939u64),
15091 "weapon_log_class_name",
15092 )?,
15093 })
15094 }
15095 #[allow(unused_variables)]
15096 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15097 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15098 match field.hash {
15099 17826443226371159423u64 => Ok(self.user_id.clone().into()),
15100 7608903543976233025u64 => Ok(self.victim_ent_index.clone().into()),
15101 7862267791693534473u64 => Ok(self.inflictor_ent_index.clone().into()),
15102 7198542740550218478u64 => Ok(self.attacker.clone().into()),
15103 11580461223051554305u64 => Ok(self.weapon.clone().into()),
15104 5542695206485500884u64 => Ok(self.weapon_id.clone().into()),
15105 2104626753992558984u64 => Ok(self.damage_bits.clone().into()),
15106 9002408094759571186u64 => Ok(self.custom_kill.clone().into()),
15107 8214628514117900939u64 => Ok(self.weapon_log_class_name.clone().into()),
15108 _ => Err(ParseError::MissingGameEventValue {
15109 ty: "RdRobotKilled",
15110 field: "todo".into(),
15111 }),
15112 }
15113 }
15114 #[allow(unused_variables)]
15115 fn write(
15116 &self,
15117 stream: &mut BitWriteStream<LittleEndian>,
15118 definition: &GameEventDefinition,
15119 ) -> Result<()> {
15120 for entry in &definition.entries {
15121 let value = self
15122 .get_field(entry)
15123 .unwrap_or_else(|_| entry.kind.default_value());
15124 stream.write(&value)?;
15125 }
15126 Ok(())
15127 }
15128}
15129#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15130#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15131pub struct RdRobotImpactEvent {
15132 pub ent_index: u16,
15133 pub impulse_x: f32,
15134 pub impulse_y: f32,
15135 pub impulse_z: f32,
15136}
15137impl RdRobotImpactEvent {
15138 #[allow(unused_variables)]
15139 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15140 Ok(RdRobotImpactEvent {
15141 ent_index: read_value::<u16>(
15142 stream,
15143 definition.get_entry(17554918082946193550u64),
15144 "ent_index",
15145 )?,
15146 impulse_x: read_value::<f32>(
15147 stream,
15148 definition.get_entry(2780540280585913547u64),
15149 "impulse_x",
15150 )?,
15151 impulse_y: read_value::<f32>(
15152 stream,
15153 definition.get_entry(2780539181074285336u64),
15154 "impulse_y",
15155 )?,
15156 impulse_z: read_value::<f32>(
15157 stream,
15158 definition.get_entry(2780542479609169969u64),
15159 "impulse_z",
15160 )?,
15161 })
15162 }
15163 #[allow(unused_variables)]
15164 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15165 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15166 match field.hash {
15167 17554918082946193550u64 => Ok(self.ent_index.clone().into()),
15168 2780540280585913547u64 => Ok(self.impulse_x.clone().into()),
15169 2780539181074285336u64 => Ok(self.impulse_y.clone().into()),
15170 2780542479609169969u64 => Ok(self.impulse_z.clone().into()),
15171 _ => Err(ParseError::MissingGameEventValue {
15172 ty: "RdRobotImpact",
15173 field: "todo".into(),
15174 }),
15175 }
15176 }
15177 #[allow(unused_variables)]
15178 fn write(
15179 &self,
15180 stream: &mut BitWriteStream<LittleEndian>,
15181 definition: &GameEventDefinition,
15182 ) -> Result<()> {
15183 for entry in &definition.entries {
15184 let value = self
15185 .get_field(entry)
15186 .unwrap_or_else(|_| entry.kind.default_value());
15187 stream.write(&value)?;
15188 }
15189 Ok(())
15190 }
15191}
15192#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15193#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15194pub struct TeamPlayPreRoundTimeLeftEvent {
15195 pub time: u16,
15196}
15197impl TeamPlayPreRoundTimeLeftEvent {
15198 #[allow(unused_variables)]
15199 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15200 Ok(TeamPlayPreRoundTimeLeftEvent {
15201 time: read_value::<u16>(stream, definition.get_entry(2185518981507421060u64), "time")?,
15202 })
15203 }
15204 #[allow(unused_variables)]
15205 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15206 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15207 match field.hash {
15208 2185518981507421060u64 => Ok(self.time.clone().into()),
15209 _ => Err(ParseError::MissingGameEventValue {
15210 ty: "TeamPlayPreRoundTimeLeft",
15211 field: "todo".into(),
15212 }),
15213 }
15214 }
15215 #[allow(unused_variables)]
15216 fn write(
15217 &self,
15218 stream: &mut BitWriteStream<LittleEndian>,
15219 definition: &GameEventDefinition,
15220 ) -> Result<()> {
15221 for entry in &definition.entries {
15222 let value = self
15223 .get_field(entry)
15224 .unwrap_or_else(|_| entry.kind.default_value());
15225 stream.write(&value)?;
15226 }
15227 Ok(())
15228 }
15229}
15230#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15231#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15232pub struct ParachuteDeployEvent {
15233 pub index: u16,
15234}
15235impl ParachuteDeployEvent {
15236 #[allow(unused_variables)]
15237 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15238 Ok(ParachuteDeployEvent {
15239 index: read_value::<u16>(
15240 stream,
15241 definition.get_entry(9497966886403524235u64),
15242 "index",
15243 )?,
15244 })
15245 }
15246 #[allow(unused_variables)]
15247 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15248 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15249 match field.hash {
15250 9497966886403524235u64 => Ok(self.index.clone().into()),
15251 _ => Err(ParseError::MissingGameEventValue {
15252 ty: "ParachuteDeploy",
15253 field: "todo".into(),
15254 }),
15255 }
15256 }
15257 #[allow(unused_variables)]
15258 fn write(
15259 &self,
15260 stream: &mut BitWriteStream<LittleEndian>,
15261 definition: &GameEventDefinition,
15262 ) -> Result<()> {
15263 for entry in &definition.entries {
15264 let value = self
15265 .get_field(entry)
15266 .unwrap_or_else(|_| entry.kind.default_value());
15267 stream.write(&value)?;
15268 }
15269 Ok(())
15270 }
15271}
15272#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15273#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15274pub struct ParachuteHolsterEvent {
15275 pub index: u16,
15276}
15277impl ParachuteHolsterEvent {
15278 #[allow(unused_variables)]
15279 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15280 Ok(ParachuteHolsterEvent {
15281 index: read_value::<u16>(
15282 stream,
15283 definition.get_entry(9497966886403524235u64),
15284 "index",
15285 )?,
15286 })
15287 }
15288 #[allow(unused_variables)]
15289 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15290 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15291 match field.hash {
15292 9497966886403524235u64 => Ok(self.index.clone().into()),
15293 _ => Err(ParseError::MissingGameEventValue {
15294 ty: "ParachuteHolster",
15295 field: "todo".into(),
15296 }),
15297 }
15298 }
15299 #[allow(unused_variables)]
15300 fn write(
15301 &self,
15302 stream: &mut BitWriteStream<LittleEndian>,
15303 definition: &GameEventDefinition,
15304 ) -> Result<()> {
15305 for entry in &definition.entries {
15306 let value = self
15307 .get_field(entry)
15308 .unwrap_or_else(|_| entry.kind.default_value());
15309 stream.write(&value)?;
15310 }
15311 Ok(())
15312 }
15313}
15314#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15315#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15316pub struct KillRefillsMeterEvent {
15317 pub index: u16,
15318}
15319impl KillRefillsMeterEvent {
15320 #[allow(unused_variables)]
15321 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15322 Ok(KillRefillsMeterEvent {
15323 index: read_value::<u16>(
15324 stream,
15325 definition.get_entry(9497966886403524235u64),
15326 "index",
15327 )?,
15328 })
15329 }
15330 #[allow(unused_variables)]
15331 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15332 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15333 match field.hash {
15334 9497966886403524235u64 => Ok(self.index.clone().into()),
15335 _ => Err(ParseError::MissingGameEventValue {
15336 ty: "KillRefillsMeter",
15337 field: "todo".into(),
15338 }),
15339 }
15340 }
15341 #[allow(unused_variables)]
15342 fn write(
15343 &self,
15344 stream: &mut BitWriteStream<LittleEndian>,
15345 definition: &GameEventDefinition,
15346 ) -> Result<()> {
15347 for entry in &definition.entries {
15348 let value = self
15349 .get_field(entry)
15350 .unwrap_or_else(|_| entry.kind.default_value());
15351 stream.write(&value)?;
15352 }
15353 Ok(())
15354 }
15355}
15356#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15357#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15358pub struct RpsTauntEventEvent {
15359 pub winner: u16,
15360 pub winner_rps: u8,
15361 pub loser: u16,
15362 pub loser_rps: u8,
15363}
15364impl RpsTauntEventEvent {
15365 #[allow(unused_variables)]
15366 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15367 Ok(RpsTauntEventEvent {
15368 winner: read_value::<u16>(
15369 stream,
15370 definition.get_entry(4337804175666422150u64),
15371 "winner",
15372 )?,
15373 winner_rps: read_value::<u8>(
15374 stream,
15375 definition.get_entry(10341772402923738934u64),
15376 "winner_rps",
15377 )?,
15378 loser: read_value::<u16>(
15379 stream,
15380 definition.get_entry(12743961777105763166u64),
15381 "loser",
15382 )?,
15383 loser_rps: read_value::<u8>(
15384 stream,
15385 definition.get_entry(7097735284409203870u64),
15386 "loser_rps",
15387 )?,
15388 })
15389 }
15390 #[allow(unused_variables)]
15391 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15392 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15393 match field.hash {
15394 4337804175666422150u64 => Ok(self.winner.clone().into()),
15395 10341772402923738934u64 => Ok(self.winner_rps.clone().into()),
15396 12743961777105763166u64 => Ok(self.loser.clone().into()),
15397 7097735284409203870u64 => Ok(self.loser_rps.clone().into()),
15398 _ => Err(ParseError::MissingGameEventValue {
15399 ty: "RpsTauntEvent",
15400 field: "todo".into(),
15401 }),
15402 }
15403 }
15404 #[allow(unused_variables)]
15405 fn write(
15406 &self,
15407 stream: &mut BitWriteStream<LittleEndian>,
15408 definition: &GameEventDefinition,
15409 ) -> Result<()> {
15410 for entry in &definition.entries {
15411 let value = self
15412 .get_field(entry)
15413 .unwrap_or_else(|_| entry.kind.default_value());
15414 stream.write(&value)?;
15415 }
15416 Ok(())
15417 }
15418}
15419#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15420#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15421pub struct CongaKillEvent {
15422 pub index: u16,
15423}
15424impl CongaKillEvent {
15425 #[allow(unused_variables)]
15426 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15427 Ok(CongaKillEvent {
15428 index: read_value::<u16>(
15429 stream,
15430 definition.get_entry(9497966886403524235u64),
15431 "index",
15432 )?,
15433 })
15434 }
15435 #[allow(unused_variables)]
15436 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15437 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15438 match field.hash {
15439 9497966886403524235u64 => Ok(self.index.clone().into()),
15440 _ => Err(ParseError::MissingGameEventValue {
15441 ty: "CongaKill",
15442 field: "todo".into(),
15443 }),
15444 }
15445 }
15446 #[allow(unused_variables)]
15447 fn write(
15448 &self,
15449 stream: &mut BitWriteStream<LittleEndian>,
15450 definition: &GameEventDefinition,
15451 ) -> Result<()> {
15452 for entry in &definition.entries {
15453 let value = self
15454 .get_field(entry)
15455 .unwrap_or_else(|_| entry.kind.default_value());
15456 stream.write(&value)?;
15457 }
15458 Ok(())
15459 }
15460}
15461#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15462#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15463pub struct PlayerInitialSpawnEvent {
15464 pub index: u16,
15465}
15466impl PlayerInitialSpawnEvent {
15467 #[allow(unused_variables)]
15468 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15469 Ok(PlayerInitialSpawnEvent {
15470 index: read_value::<u16>(
15471 stream,
15472 definition.get_entry(9497966886403524235u64),
15473 "index",
15474 )?,
15475 })
15476 }
15477 #[allow(unused_variables)]
15478 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15479 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15480 match field.hash {
15481 9497966886403524235u64 => Ok(self.index.clone().into()),
15482 _ => Err(ParseError::MissingGameEventValue {
15483 ty: "PlayerInitialSpawn",
15484 field: "todo".into(),
15485 }),
15486 }
15487 }
15488 #[allow(unused_variables)]
15489 fn write(
15490 &self,
15491 stream: &mut BitWriteStream<LittleEndian>,
15492 definition: &GameEventDefinition,
15493 ) -> Result<()> {
15494 for entry in &definition.entries {
15495 let value = self
15496 .get_field(entry)
15497 .unwrap_or_else(|_| entry.kind.default_value());
15498 stream.write(&value)?;
15499 }
15500 Ok(())
15501 }
15502}
15503#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15504#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15505pub struct CompetitiveVictoryEvent {}
15506impl CompetitiveVictoryEvent {
15507 #[allow(unused_variables)]
15508 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15509 Ok(CompetitiveVictoryEvent {})
15510 }
15511 #[allow(unused_variables)]
15512 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15513 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15514 match field.hash {
15515 _ => Err(ParseError::MissingGameEventValue {
15516 ty: "CompetitiveVictory",
15517 field: "todo".into(),
15518 }),
15519 }
15520 }
15521 #[allow(unused_variables)]
15522 fn write(
15523 &self,
15524 stream: &mut BitWriteStream<LittleEndian>,
15525 definition: &GameEventDefinition,
15526 ) -> Result<()> {
15527 for entry in &definition.entries {
15528 let value = self
15529 .get_field(entry)
15530 .unwrap_or_else(|_| entry.kind.default_value());
15531 stream.write(&value)?;
15532 }
15533 Ok(())
15534 }
15535}
15536#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15537#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15538pub struct CompetitiveStatsUpdateEvent {
15539 pub index: u16,
15540 pub kills_rank: u8,
15541 pub score_rank: u8,
15542 pub damage_rank: u8,
15543 pub healing_rank: u8,
15544 pub support_rank: u8,
15545}
15546impl CompetitiveStatsUpdateEvent {
15547 #[allow(unused_variables)]
15548 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15549 Ok(CompetitiveStatsUpdateEvent {
15550 index: read_value::<u16>(
15551 stream,
15552 definition.get_entry(9497966886403524235u64),
15553 "index",
15554 )?,
15555 kills_rank: read_value::<u8>(
15556 stream,
15557 definition.get_entry(1647429874780590553u64),
15558 "kills_rank",
15559 )?,
15560 score_rank: read_value::<u8>(
15561 stream,
15562 definition.get_entry(7011983216168462200u64),
15563 "score_rank",
15564 )?,
15565 damage_rank: read_value::<u8>(
15566 stream,
15567 definition.get_entry(1489671713798354735u64),
15568 "damage_rank",
15569 )?,
15570 healing_rank: read_value::<u8>(
15571 stream,
15572 definition.get_entry(4364771850637042816u64),
15573 "healing_rank",
15574 )?,
15575 support_rank: read_value::<u8>(
15576 stream,
15577 definition.get_entry(177739702519296055u64),
15578 "support_rank",
15579 )?,
15580 })
15581 }
15582 #[allow(unused_variables)]
15583 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15584 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15585 match field.hash {
15586 9497966886403524235u64 => Ok(self.index.clone().into()),
15587 1647429874780590553u64 => Ok(self.kills_rank.clone().into()),
15588 7011983216168462200u64 => Ok(self.score_rank.clone().into()),
15589 1489671713798354735u64 => Ok(self.damage_rank.clone().into()),
15590 4364771850637042816u64 => Ok(self.healing_rank.clone().into()),
15591 177739702519296055u64 => Ok(self.support_rank.clone().into()),
15592 _ => Err(ParseError::MissingGameEventValue {
15593 ty: "CompetitiveStatsUpdate",
15594 field: "todo".into(),
15595 }),
15596 }
15597 }
15598 #[allow(unused_variables)]
15599 fn write(
15600 &self,
15601 stream: &mut BitWriteStream<LittleEndian>,
15602 definition: &GameEventDefinition,
15603 ) -> Result<()> {
15604 for entry in &definition.entries {
15605 let value = self
15606 .get_field(entry)
15607 .unwrap_or_else(|_| entry.kind.default_value());
15608 stream.write(&value)?;
15609 }
15610 Ok(())
15611 }
15612}
15613#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15614#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15615pub struct MiniGameWinEvent {
15616 pub team: u8,
15617 pub kind: u8,
15618}
15619impl MiniGameWinEvent {
15620 #[allow(unused_variables)]
15621 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15622 Ok(MiniGameWinEvent {
15623 team: read_value::<u8>(
15624 stream,
15625 definition.get_entry(18024489754618217260u64),
15626 "team",
15627 )?,
15628 kind: read_value::<u8>(
15629 stream,
15630 definition.get_entry(12075340201627130925u64),
15631 "kind",
15632 )?,
15633 })
15634 }
15635 #[allow(unused_variables)]
15636 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15637 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15638 match field.hash {
15639 18024489754618217260u64 => Ok(self.team.clone().into()),
15640 12075340201627130925u64 => Ok(self.kind.clone().into()),
15641 _ => Err(ParseError::MissingGameEventValue {
15642 ty: "MiniGameWin",
15643 field: "todo".into(),
15644 }),
15645 }
15646 }
15647 #[allow(unused_variables)]
15648 fn write(
15649 &self,
15650 stream: &mut BitWriteStream<LittleEndian>,
15651 definition: &GameEventDefinition,
15652 ) -> Result<()> {
15653 for entry in &definition.entries {
15654 let value = self
15655 .get_field(entry)
15656 .unwrap_or_else(|_| entry.kind.default_value());
15657 stream.write(&value)?;
15658 }
15659 Ok(())
15660 }
15661}
15662#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15663#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15664pub struct SentryOnGoActiveEvent {
15665 pub index: u16,
15666}
15667impl SentryOnGoActiveEvent {
15668 #[allow(unused_variables)]
15669 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15670 Ok(SentryOnGoActiveEvent {
15671 index: read_value::<u16>(
15672 stream,
15673 definition.get_entry(9497966886403524235u64),
15674 "index",
15675 )?,
15676 })
15677 }
15678 #[allow(unused_variables)]
15679 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15680 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15681 match field.hash {
15682 9497966886403524235u64 => Ok(self.index.clone().into()),
15683 _ => Err(ParseError::MissingGameEventValue {
15684 ty: "SentryOnGoActive",
15685 field: "todo".into(),
15686 }),
15687 }
15688 }
15689 #[allow(unused_variables)]
15690 fn write(
15691 &self,
15692 stream: &mut BitWriteStream<LittleEndian>,
15693 definition: &GameEventDefinition,
15694 ) -> Result<()> {
15695 for entry in &definition.entries {
15696 let value = self
15697 .get_field(entry)
15698 .unwrap_or_else(|_| entry.kind.default_value());
15699 stream.write(&value)?;
15700 }
15701 Ok(())
15702 }
15703}
15704#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15705#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15706pub struct DuckXpLevelUpEvent {
15707 pub level: u16,
15708}
15709impl DuckXpLevelUpEvent {
15710 #[allow(unused_variables)]
15711 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15712 Ok(DuckXpLevelUpEvent {
15713 level: read_value::<u16>(
15714 stream,
15715 definition.get_entry(16779788834081370269u64),
15716 "level",
15717 )?,
15718 })
15719 }
15720 #[allow(unused_variables)]
15721 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15722 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15723 match field.hash {
15724 16779788834081370269u64 => Ok(self.level.clone().into()),
15725 _ => Err(ParseError::MissingGameEventValue {
15726 ty: "DuckXpLevelUp",
15727 field: "todo".into(),
15728 }),
15729 }
15730 }
15731 #[allow(unused_variables)]
15732 fn write(
15733 &self,
15734 stream: &mut BitWriteStream<LittleEndian>,
15735 definition: &GameEventDefinition,
15736 ) -> Result<()> {
15737 for entry in &definition.entries {
15738 let value = self
15739 .get_field(entry)
15740 .unwrap_or_else(|_| entry.kind.default_value());
15741 stream.write(&value)?;
15742 }
15743 Ok(())
15744 }
15745}
15746#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15747#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15748pub struct QuestLogOpenedEvent {}
15749impl QuestLogOpenedEvent {
15750 #[allow(unused_variables)]
15751 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15752 Ok(QuestLogOpenedEvent {})
15753 }
15754 #[allow(unused_variables)]
15755 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15756 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15757 match field.hash {
15758 _ => Err(ParseError::MissingGameEventValue {
15759 ty: "QuestLogOpened",
15760 field: "todo".into(),
15761 }),
15762 }
15763 }
15764 #[allow(unused_variables)]
15765 fn write(
15766 &self,
15767 stream: &mut BitWriteStream<LittleEndian>,
15768 definition: &GameEventDefinition,
15769 ) -> Result<()> {
15770 for entry in &definition.entries {
15771 let value = self
15772 .get_field(entry)
15773 .unwrap_or_else(|_| entry.kind.default_value());
15774 stream.write(&value)?;
15775 }
15776 Ok(())
15777 }
15778}
15779#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15780#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15781pub struct SchemaUpdatedEvent {}
15782impl SchemaUpdatedEvent {
15783 #[allow(unused_variables)]
15784 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15785 Ok(SchemaUpdatedEvent {})
15786 }
15787 #[allow(unused_variables)]
15788 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15789 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15790 match field.hash {
15791 _ => Err(ParseError::MissingGameEventValue {
15792 ty: "SchemaUpdated",
15793 field: "todo".into(),
15794 }),
15795 }
15796 }
15797 #[allow(unused_variables)]
15798 fn write(
15799 &self,
15800 stream: &mut BitWriteStream<LittleEndian>,
15801 definition: &GameEventDefinition,
15802 ) -> Result<()> {
15803 for entry in &definition.entries {
15804 let value = self
15805 .get_field(entry)
15806 .unwrap_or_else(|_| entry.kind.default_value());
15807 stream.write(&value)?;
15808 }
15809 Ok(())
15810 }
15811}
15812#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15813#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15814pub struct LocalPlayerPickupWeaponEvent {}
15815impl LocalPlayerPickupWeaponEvent {
15816 #[allow(unused_variables)]
15817 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15818 Ok(LocalPlayerPickupWeaponEvent {})
15819 }
15820 #[allow(unused_variables)]
15821 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15822 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15823 match field.hash {
15824 _ => Err(ParseError::MissingGameEventValue {
15825 ty: "LocalPlayerPickupWeapon",
15826 field: "todo".into(),
15827 }),
15828 }
15829 }
15830 #[allow(unused_variables)]
15831 fn write(
15832 &self,
15833 stream: &mut BitWriteStream<LittleEndian>,
15834 definition: &GameEventDefinition,
15835 ) -> Result<()> {
15836 for entry in &definition.entries {
15837 let value = self
15838 .get_field(entry)
15839 .unwrap_or_else(|_| entry.kind.default_value());
15840 stream.write(&value)?;
15841 }
15842 Ok(())
15843 }
15844}
15845#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15846#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15847pub struct RdPlayerScorePointsEvent {
15848 pub player: u16,
15849 pub method: u16,
15850 pub amount: u16,
15851}
15852impl RdPlayerScorePointsEvent {
15853 #[allow(unused_variables)]
15854 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15855 Ok(RdPlayerScorePointsEvent {
15856 player: read_value::<u16>(
15857 stream,
15858 definition.get_entry(5008278420455340480u64),
15859 "player",
15860 )?,
15861 method: read_value::<u16>(
15862 stream,
15863 definition.get_entry(2525399976365011888u64),
15864 "method",
15865 )?,
15866 amount: read_value::<u16>(
15867 stream,
15868 definition.get_entry(9301057475299076457u64),
15869 "amount",
15870 )?,
15871 })
15872 }
15873 #[allow(unused_variables)]
15874 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15875 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15876 match field.hash {
15877 5008278420455340480u64 => Ok(self.player.clone().into()),
15878 2525399976365011888u64 => Ok(self.method.clone().into()),
15879 9301057475299076457u64 => Ok(self.amount.clone().into()),
15880 _ => Err(ParseError::MissingGameEventValue {
15881 ty: "RdPlayerScorePoints",
15882 field: "todo".into(),
15883 }),
15884 }
15885 }
15886 #[allow(unused_variables)]
15887 fn write(
15888 &self,
15889 stream: &mut BitWriteStream<LittleEndian>,
15890 definition: &GameEventDefinition,
15891 ) -> Result<()> {
15892 for entry in &definition.entries {
15893 let value = self
15894 .get_field(entry)
15895 .unwrap_or_else(|_| entry.kind.default_value());
15896 stream.write(&value)?;
15897 }
15898 Ok(())
15899 }
15900}
15901#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15902#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15903pub struct DemomanDetStickiesEvent {
15904 pub player: u16,
15905}
15906impl DemomanDetStickiesEvent {
15907 #[allow(unused_variables)]
15908 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15909 Ok(DemomanDetStickiesEvent {
15910 player: read_value::<u16>(
15911 stream,
15912 definition.get_entry(5008278420455340480u64),
15913 "player",
15914 )?,
15915 })
15916 }
15917 #[allow(unused_variables)]
15918 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15919 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15920 match field.hash {
15921 5008278420455340480u64 => Ok(self.player.clone().into()),
15922 _ => Err(ParseError::MissingGameEventValue {
15923 ty: "DemomanDetStickies",
15924 field: "todo".into(),
15925 }),
15926 }
15927 }
15928 #[allow(unused_variables)]
15929 fn write(
15930 &self,
15931 stream: &mut BitWriteStream<LittleEndian>,
15932 definition: &GameEventDefinition,
15933 ) -> Result<()> {
15934 for entry in &definition.entries {
15935 let value = self
15936 .get_field(entry)
15937 .unwrap_or_else(|_| entry.kind.default_value());
15938 stream.write(&value)?;
15939 }
15940 Ok(())
15941 }
15942}
15943#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
15944#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15945pub struct QuestObjectiveCompletedEvent {
15946 pub quest_item_id_low: u32,
15947 pub quest_item_id_hi: u32,
15948 pub quest_objective_id: u32,
15949 pub scorer_user_id: u16,
15950}
15951impl QuestObjectiveCompletedEvent {
15952 #[allow(unused_variables)]
15953 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
15954 Ok(QuestObjectiveCompletedEvent {
15955 quest_item_id_low: read_value::<u32>(
15956 stream,
15957 definition.get_entry(6899404301657350854u64),
15958 "quest_item_id_low",
15959 )?,
15960 quest_item_id_hi: read_value::<u32>(
15961 stream,
15962 definition.get_entry(5919305845835660727u64),
15963 "quest_item_id_hi",
15964 )?,
15965 quest_objective_id: read_value::<u32>(
15966 stream,
15967 definition.get_entry(16538099295756322479u64),
15968 "quest_objective_id",
15969 )?,
15970 scorer_user_id: read_value::<u16>(
15971 stream,
15972 definition.get_entry(10733259024453182903u64),
15973 "scorer_user_id",
15974 )?,
15975 })
15976 }
15977 #[allow(unused_variables)]
15978 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
15979 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
15980 match field.hash {
15981 6899404301657350854u64 => Ok(self.quest_item_id_low.clone().into()),
15982 5919305845835660727u64 => Ok(self.quest_item_id_hi.clone().into()),
15983 16538099295756322479u64 => Ok(self.quest_objective_id.clone().into()),
15984 10733259024453182903u64 => Ok(self.scorer_user_id.clone().into()),
15985 _ => Err(ParseError::MissingGameEventValue {
15986 ty: "QuestObjectiveCompleted",
15987 field: "todo".into(),
15988 }),
15989 }
15990 }
15991 #[allow(unused_variables)]
15992 fn write(
15993 &self,
15994 stream: &mut BitWriteStream<LittleEndian>,
15995 definition: &GameEventDefinition,
15996 ) -> Result<()> {
15997 for entry in &definition.entries {
15998 let value = self
15999 .get_field(entry)
16000 .unwrap_or_else(|_| entry.kind.default_value());
16001 stream.write(&value)?;
16002 }
16003 Ok(())
16004 }
16005}
16006#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16007#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16008pub struct PlayerScoreChangedEvent {
16009 pub player: u8,
16010 pub delta: u16,
16011}
16012impl PlayerScoreChangedEvent {
16013 #[allow(unused_variables)]
16014 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16015 Ok(PlayerScoreChangedEvent {
16016 player: read_value::<u8>(
16017 stream,
16018 definition.get_entry(5008278420455340480u64),
16019 "player",
16020 )?,
16021 delta: read_value::<u16>(
16022 stream,
16023 definition.get_entry(5910805692604981441u64),
16024 "delta",
16025 )?,
16026 })
16027 }
16028 #[allow(unused_variables)]
16029 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16030 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16031 match field.hash {
16032 5008278420455340480u64 => Ok(self.player.clone().into()),
16033 5910805692604981441u64 => Ok(self.delta.clone().into()),
16034 _ => Err(ParseError::MissingGameEventValue {
16035 ty: "PlayerScoreChanged",
16036 field: "todo".into(),
16037 }),
16038 }
16039 }
16040 #[allow(unused_variables)]
16041 fn write(
16042 &self,
16043 stream: &mut BitWriteStream<LittleEndian>,
16044 definition: &GameEventDefinition,
16045 ) -> Result<()> {
16046 for entry in &definition.entries {
16047 let value = self
16048 .get_field(entry)
16049 .unwrap_or_else(|_| entry.kind.default_value());
16050 stream.write(&value)?;
16051 }
16052 Ok(())
16053 }
16054}
16055#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16056#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16057pub struct KilledCappingPlayerEvent {
16058 pub cp: u8,
16059 pub killer: u8,
16060 pub victim: u8,
16061 pub assister: u8,
16062}
16063impl KilledCappingPlayerEvent {
16064 #[allow(unused_variables)]
16065 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16066 Ok(KilledCappingPlayerEvent {
16067 cp: read_value::<u8>(stream, definition.get_entry(622127901357767142u64), "cp")?,
16068 killer: read_value::<u8>(
16069 stream,
16070 definition.get_entry(7927307102854403058u64),
16071 "killer",
16072 )?,
16073 victim: read_value::<u8>(
16074 stream,
16075 definition.get_entry(3120917251440744469u64),
16076 "victim",
16077 )?,
16078 assister: read_value::<u8>(
16079 stream,
16080 definition.get_entry(17978308754419261977u64),
16081 "assister",
16082 )?,
16083 })
16084 }
16085 #[allow(unused_variables)]
16086 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16087 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16088 match field.hash {
16089 622127901357767142u64 => Ok(self.cp.clone().into()),
16090 7927307102854403058u64 => Ok(self.killer.clone().into()),
16091 3120917251440744469u64 => Ok(self.victim.clone().into()),
16092 17978308754419261977u64 => Ok(self.assister.clone().into()),
16093 _ => Err(ParseError::MissingGameEventValue {
16094 ty: "KilledCappingPlayer",
16095 field: "todo".into(),
16096 }),
16097 }
16098 }
16099 #[allow(unused_variables)]
16100 fn write(
16101 &self,
16102 stream: &mut BitWriteStream<LittleEndian>,
16103 definition: &GameEventDefinition,
16104 ) -> Result<()> {
16105 for entry in &definition.entries {
16106 let value = self
16107 .get_field(entry)
16108 .unwrap_or_else(|_| entry.kind.default_value());
16109 stream.write(&value)?;
16110 }
16111 Ok(())
16112 }
16113}
16114#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16115#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16116pub struct EnvironmentalDeathEvent {
16117 pub killer: u8,
16118 pub victim: u8,
16119}
16120impl EnvironmentalDeathEvent {
16121 #[allow(unused_variables)]
16122 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16123 Ok(EnvironmentalDeathEvent {
16124 killer: read_value::<u8>(
16125 stream,
16126 definition.get_entry(7927307102854403058u64),
16127 "killer",
16128 )?,
16129 victim: read_value::<u8>(
16130 stream,
16131 definition.get_entry(3120917251440744469u64),
16132 "victim",
16133 )?,
16134 })
16135 }
16136 #[allow(unused_variables)]
16137 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16138 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16139 match field.hash {
16140 7927307102854403058u64 => Ok(self.killer.clone().into()),
16141 3120917251440744469u64 => Ok(self.victim.clone().into()),
16142 _ => Err(ParseError::MissingGameEventValue {
16143 ty: "EnvironmentalDeath",
16144 field: "todo".into(),
16145 }),
16146 }
16147 }
16148 #[allow(unused_variables)]
16149 fn write(
16150 &self,
16151 stream: &mut BitWriteStream<LittleEndian>,
16152 definition: &GameEventDefinition,
16153 ) -> Result<()> {
16154 for entry in &definition.entries {
16155 let value = self
16156 .get_field(entry)
16157 .unwrap_or_else(|_| entry.kind.default_value());
16158 stream.write(&value)?;
16159 }
16160 Ok(())
16161 }
16162}
16163#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16164#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16165pub struct ProjectileDirectHitEvent {
16166 pub attacker: u8,
16167 pub victim: u8,
16168 pub weapon_def_index: u32,
16169}
16170impl ProjectileDirectHitEvent {
16171 #[allow(unused_variables)]
16172 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16173 Ok(ProjectileDirectHitEvent {
16174 attacker: read_value::<u8>(
16175 stream,
16176 definition.get_entry(7198542740550218478u64),
16177 "attacker",
16178 )?,
16179 victim: read_value::<u8>(
16180 stream,
16181 definition.get_entry(3120917251440744469u64),
16182 "victim",
16183 )?,
16184 weapon_def_index: read_value::<u32>(
16185 stream,
16186 definition.get_entry(4132306594868589054u64),
16187 "weapon_def_index",
16188 )?,
16189 })
16190 }
16191 #[allow(unused_variables)]
16192 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16193 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16194 match field.hash {
16195 7198542740550218478u64 => Ok(self.attacker.clone().into()),
16196 3120917251440744469u64 => Ok(self.victim.clone().into()),
16197 4132306594868589054u64 => Ok(self.weapon_def_index.clone().into()),
16198 _ => Err(ParseError::MissingGameEventValue {
16199 ty: "ProjectileDirectHit",
16200 field: "todo".into(),
16201 }),
16202 }
16203 }
16204 #[allow(unused_variables)]
16205 fn write(
16206 &self,
16207 stream: &mut BitWriteStream<LittleEndian>,
16208 definition: &GameEventDefinition,
16209 ) -> Result<()> {
16210 for entry in &definition.entries {
16211 let value = self
16212 .get_field(entry)
16213 .unwrap_or_else(|_| entry.kind.default_value());
16214 stream.write(&value)?;
16215 }
16216 Ok(())
16217 }
16218}
16219#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16220#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16221pub struct PassGetEvent {
16222 pub owner: u16,
16223}
16224impl PassGetEvent {
16225 #[allow(unused_variables)]
16226 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16227 Ok(PassGetEvent {
16228 owner: read_value::<u16>(
16229 stream,
16230 definition.get_entry(12002927925776846068u64),
16231 "owner",
16232 )?,
16233 })
16234 }
16235 #[allow(unused_variables)]
16236 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16237 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16238 match field.hash {
16239 12002927925776846068u64 => Ok(self.owner.clone().into()),
16240 _ => Err(ParseError::MissingGameEventValue {
16241 ty: "PassGet",
16242 field: "todo".into(),
16243 }),
16244 }
16245 }
16246 #[allow(unused_variables)]
16247 fn write(
16248 &self,
16249 stream: &mut BitWriteStream<LittleEndian>,
16250 definition: &GameEventDefinition,
16251 ) -> Result<()> {
16252 for entry in &definition.entries {
16253 let value = self
16254 .get_field(entry)
16255 .unwrap_or_else(|_| entry.kind.default_value());
16256 stream.write(&value)?;
16257 }
16258 Ok(())
16259 }
16260}
16261#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16262#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16263pub struct PassScoreEvent {
16264 pub scorer: u16,
16265 pub assister: u16,
16266 pub points: u8,
16267}
16268impl PassScoreEvent {
16269 #[allow(unused_variables)]
16270 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16271 Ok(PassScoreEvent {
16272 scorer: read_value::<u16>(
16273 stream,
16274 definition.get_entry(114960585656897893u64),
16275 "scorer",
16276 )?,
16277 assister: read_value::<u16>(
16278 stream,
16279 definition.get_entry(17978308754419261977u64),
16280 "assister",
16281 )?,
16282 points: read_value::<u8>(
16283 stream,
16284 definition.get_entry(15925482014108518566u64),
16285 "points",
16286 )?,
16287 })
16288 }
16289 #[allow(unused_variables)]
16290 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16291 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16292 match field.hash {
16293 114960585656897893u64 => Ok(self.scorer.clone().into()),
16294 17978308754419261977u64 => Ok(self.assister.clone().into()),
16295 15925482014108518566u64 => Ok(self.points.clone().into()),
16296 _ => Err(ParseError::MissingGameEventValue {
16297 ty: "PassScore",
16298 field: "todo".into(),
16299 }),
16300 }
16301 }
16302 #[allow(unused_variables)]
16303 fn write(
16304 &self,
16305 stream: &mut BitWriteStream<LittleEndian>,
16306 definition: &GameEventDefinition,
16307 ) -> Result<()> {
16308 for entry in &definition.entries {
16309 let value = self
16310 .get_field(entry)
16311 .unwrap_or_else(|_| entry.kind.default_value());
16312 stream.write(&value)?;
16313 }
16314 Ok(())
16315 }
16316}
16317#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16318#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16319pub struct PassFreeEvent {
16320 pub owner: u16,
16321 pub attacker: u16,
16322}
16323impl PassFreeEvent {
16324 #[allow(unused_variables)]
16325 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16326 Ok(PassFreeEvent {
16327 owner: read_value::<u16>(
16328 stream,
16329 definition.get_entry(12002927925776846068u64),
16330 "owner",
16331 )?,
16332 attacker: read_value::<u16>(
16333 stream,
16334 definition.get_entry(7198542740550218478u64),
16335 "attacker",
16336 )?,
16337 })
16338 }
16339 #[allow(unused_variables)]
16340 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16341 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16342 match field.hash {
16343 12002927925776846068u64 => Ok(self.owner.clone().into()),
16344 7198542740550218478u64 => Ok(self.attacker.clone().into()),
16345 _ => Err(ParseError::MissingGameEventValue {
16346 ty: "PassFree",
16347 field: "todo".into(),
16348 }),
16349 }
16350 }
16351 #[allow(unused_variables)]
16352 fn write(
16353 &self,
16354 stream: &mut BitWriteStream<LittleEndian>,
16355 definition: &GameEventDefinition,
16356 ) -> Result<()> {
16357 for entry in &definition.entries {
16358 let value = self
16359 .get_field(entry)
16360 .unwrap_or_else(|_| entry.kind.default_value());
16361 stream.write(&value)?;
16362 }
16363 Ok(())
16364 }
16365}
16366#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16367#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16368pub struct PassPassCaughtEvent {
16369 pub passer: u16,
16370 pub catcher: u16,
16371 pub dist: f32,
16372 pub duration: f32,
16373}
16374impl PassPassCaughtEvent {
16375 #[allow(unused_variables)]
16376 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16377 Ok(PassPassCaughtEvent {
16378 passer: read_value::<u16>(
16379 stream,
16380 definition.get_entry(807676909013642383u64),
16381 "passer",
16382 )?,
16383 catcher: read_value::<u16>(
16384 stream,
16385 definition.get_entry(10052723730022137051u64),
16386 "catcher",
16387 )?,
16388 dist: read_value::<f32>(
16389 stream,
16390 definition.get_entry(14574961654905149033u64),
16391 "dist",
16392 )?,
16393 duration: read_value::<f32>(
16394 stream,
16395 definition.get_entry(10012068961515151501u64),
16396 "duration",
16397 )?,
16398 })
16399 }
16400 #[allow(unused_variables)]
16401 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16402 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16403 match field.hash {
16404 807676909013642383u64 => Ok(self.passer.clone().into()),
16405 10052723730022137051u64 => Ok(self.catcher.clone().into()),
16406 14574961654905149033u64 => Ok(self.dist.clone().into()),
16407 10012068961515151501u64 => Ok(self.duration.clone().into()),
16408 _ => Err(ParseError::MissingGameEventValue {
16409 ty: "PassPassCaught",
16410 field: "todo".into(),
16411 }),
16412 }
16413 }
16414 #[allow(unused_variables)]
16415 fn write(
16416 &self,
16417 stream: &mut BitWriteStream<LittleEndian>,
16418 definition: &GameEventDefinition,
16419 ) -> Result<()> {
16420 for entry in &definition.entries {
16421 let value = self
16422 .get_field(entry)
16423 .unwrap_or_else(|_| entry.kind.default_value());
16424 stream.write(&value)?;
16425 }
16426 Ok(())
16427 }
16428}
16429#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16430#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16431pub struct PassBallStolenEvent {
16432 pub victim: u16,
16433 pub attacker: u16,
16434}
16435impl PassBallStolenEvent {
16436 #[allow(unused_variables)]
16437 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16438 Ok(PassBallStolenEvent {
16439 victim: read_value::<u16>(
16440 stream,
16441 definition.get_entry(3120917251440744469u64),
16442 "victim",
16443 )?,
16444 attacker: read_value::<u16>(
16445 stream,
16446 definition.get_entry(7198542740550218478u64),
16447 "attacker",
16448 )?,
16449 })
16450 }
16451 #[allow(unused_variables)]
16452 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16453 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16454 match field.hash {
16455 3120917251440744469u64 => Ok(self.victim.clone().into()),
16456 7198542740550218478u64 => Ok(self.attacker.clone().into()),
16457 _ => Err(ParseError::MissingGameEventValue {
16458 ty: "PassBallStolen",
16459 field: "todo".into(),
16460 }),
16461 }
16462 }
16463 #[allow(unused_variables)]
16464 fn write(
16465 &self,
16466 stream: &mut BitWriteStream<LittleEndian>,
16467 definition: &GameEventDefinition,
16468 ) -> Result<()> {
16469 for entry in &definition.entries {
16470 let value = self
16471 .get_field(entry)
16472 .unwrap_or_else(|_| entry.kind.default_value());
16473 stream.write(&value)?;
16474 }
16475 Ok(())
16476 }
16477}
16478#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16479#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16480pub struct PassBallBlockedEvent {
16481 pub owner: u16,
16482 pub blocker: u16,
16483}
16484impl PassBallBlockedEvent {
16485 #[allow(unused_variables)]
16486 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16487 Ok(PassBallBlockedEvent {
16488 owner: read_value::<u16>(
16489 stream,
16490 definition.get_entry(12002927925776846068u64),
16491 "owner",
16492 )?,
16493 blocker: read_value::<u16>(
16494 stream,
16495 definition.get_entry(9150196623075249301u64),
16496 "blocker",
16497 )?,
16498 })
16499 }
16500 #[allow(unused_variables)]
16501 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16502 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16503 match field.hash {
16504 12002927925776846068u64 => Ok(self.owner.clone().into()),
16505 9150196623075249301u64 => Ok(self.blocker.clone().into()),
16506 _ => Err(ParseError::MissingGameEventValue {
16507 ty: "PassBallBlocked",
16508 field: "todo".into(),
16509 }),
16510 }
16511 }
16512 #[allow(unused_variables)]
16513 fn write(
16514 &self,
16515 stream: &mut BitWriteStream<LittleEndian>,
16516 definition: &GameEventDefinition,
16517 ) -> Result<()> {
16518 for entry in &definition.entries {
16519 let value = self
16520 .get_field(entry)
16521 .unwrap_or_else(|_| entry.kind.default_value());
16522 stream.write(&value)?;
16523 }
16524 Ok(())
16525 }
16526}
16527#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16528#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16529pub struct DamagePreventedEvent {
16530 pub preventor: u16,
16531 pub victim: u16,
16532 pub amount: u16,
16533 pub condition: u16,
16534}
16535impl DamagePreventedEvent {
16536 #[allow(unused_variables)]
16537 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16538 Ok(DamagePreventedEvent {
16539 preventor: read_value::<u16>(
16540 stream,
16541 definition.get_entry(4517367470558074628u64),
16542 "preventor",
16543 )?,
16544 victim: read_value::<u16>(
16545 stream,
16546 definition.get_entry(3120917251440744469u64),
16547 "victim",
16548 )?,
16549 amount: read_value::<u16>(
16550 stream,
16551 definition.get_entry(9301057475299076457u64),
16552 "amount",
16553 )?,
16554 condition: read_value::<u16>(
16555 stream,
16556 definition.get_entry(15296338085916210270u64),
16557 "condition",
16558 )?,
16559 })
16560 }
16561 #[allow(unused_variables)]
16562 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16563 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16564 match field.hash {
16565 4517367470558074628u64 => Ok(self.preventor.clone().into()),
16566 3120917251440744469u64 => Ok(self.victim.clone().into()),
16567 9301057475299076457u64 => Ok(self.amount.clone().into()),
16568 15296338085916210270u64 => Ok(self.condition.clone().into()),
16569 _ => Err(ParseError::MissingGameEventValue {
16570 ty: "DamagePrevented",
16571 field: "todo".into(),
16572 }),
16573 }
16574 }
16575 #[allow(unused_variables)]
16576 fn write(
16577 &self,
16578 stream: &mut BitWriteStream<LittleEndian>,
16579 definition: &GameEventDefinition,
16580 ) -> Result<()> {
16581 for entry in &definition.entries {
16582 let value = self
16583 .get_field(entry)
16584 .unwrap_or_else(|_| entry.kind.default_value());
16585 stream.write(&value)?;
16586 }
16587 Ok(())
16588 }
16589}
16590#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16591#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16592pub struct HalloweenBossKilledEvent {
16593 pub boss: u16,
16594 pub killer: u16,
16595}
16596impl HalloweenBossKilledEvent {
16597 #[allow(unused_variables)]
16598 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16599 Ok(HalloweenBossKilledEvent {
16600 boss: read_value::<u16>(
16601 stream,
16602 definition.get_entry(14781339113128978092u64),
16603 "boss",
16604 )?,
16605 killer: read_value::<u16>(
16606 stream,
16607 definition.get_entry(7927307102854403058u64),
16608 "killer",
16609 )?,
16610 })
16611 }
16612 #[allow(unused_variables)]
16613 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16614 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16615 match field.hash {
16616 14781339113128978092u64 => Ok(self.boss.clone().into()),
16617 7927307102854403058u64 => Ok(self.killer.clone().into()),
16618 _ => Err(ParseError::MissingGameEventValue {
16619 ty: "HalloweenBossKilled",
16620 field: "todo".into(),
16621 }),
16622 }
16623 }
16624 #[allow(unused_variables)]
16625 fn write(
16626 &self,
16627 stream: &mut BitWriteStream<LittleEndian>,
16628 definition: &GameEventDefinition,
16629 ) -> Result<()> {
16630 for entry in &definition.entries {
16631 let value = self
16632 .get_field(entry)
16633 .unwrap_or_else(|_| entry.kind.default_value());
16634 stream.write(&value)?;
16635 }
16636 Ok(())
16637 }
16638}
16639#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16640#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16641pub struct EscapedLootIslandEvent {
16642 pub player: u16,
16643}
16644impl EscapedLootIslandEvent {
16645 #[allow(unused_variables)]
16646 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16647 Ok(EscapedLootIslandEvent {
16648 player: read_value::<u16>(
16649 stream,
16650 definition.get_entry(5008278420455340480u64),
16651 "player",
16652 )?,
16653 })
16654 }
16655 #[allow(unused_variables)]
16656 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16657 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16658 match field.hash {
16659 5008278420455340480u64 => Ok(self.player.clone().into()),
16660 _ => Err(ParseError::MissingGameEventValue {
16661 ty: "EscapedLootIsland",
16662 field: "todo".into(),
16663 }),
16664 }
16665 }
16666 #[allow(unused_variables)]
16667 fn write(
16668 &self,
16669 stream: &mut BitWriteStream<LittleEndian>,
16670 definition: &GameEventDefinition,
16671 ) -> Result<()> {
16672 for entry in &definition.entries {
16673 let value = self
16674 .get_field(entry)
16675 .unwrap_or_else(|_| entry.kind.default_value());
16676 stream.write(&value)?;
16677 }
16678 Ok(())
16679 }
16680}
16681#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16682#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16683pub struct TaggedPlayerAsItEvent {
16684 pub player: u16,
16685}
16686impl TaggedPlayerAsItEvent {
16687 #[allow(unused_variables)]
16688 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16689 Ok(TaggedPlayerAsItEvent {
16690 player: read_value::<u16>(
16691 stream,
16692 definition.get_entry(5008278420455340480u64),
16693 "player",
16694 )?,
16695 })
16696 }
16697 #[allow(unused_variables)]
16698 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16699 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16700 match field.hash {
16701 5008278420455340480u64 => Ok(self.player.clone().into()),
16702 _ => Err(ParseError::MissingGameEventValue {
16703 ty: "TaggedPlayerAsIt",
16704 field: "todo".into(),
16705 }),
16706 }
16707 }
16708 #[allow(unused_variables)]
16709 fn write(
16710 &self,
16711 stream: &mut BitWriteStream<LittleEndian>,
16712 definition: &GameEventDefinition,
16713 ) -> Result<()> {
16714 for entry in &definition.entries {
16715 let value = self
16716 .get_field(entry)
16717 .unwrap_or_else(|_| entry.kind.default_value());
16718 stream.write(&value)?;
16719 }
16720 Ok(())
16721 }
16722}
16723#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16724#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16725pub struct MerasmusStunnedEvent {
16726 pub player: u16,
16727}
16728impl MerasmusStunnedEvent {
16729 #[allow(unused_variables)]
16730 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16731 Ok(MerasmusStunnedEvent {
16732 player: read_value::<u16>(
16733 stream,
16734 definition.get_entry(5008278420455340480u64),
16735 "player",
16736 )?,
16737 })
16738 }
16739 #[allow(unused_variables)]
16740 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16741 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16742 match field.hash {
16743 5008278420455340480u64 => Ok(self.player.clone().into()),
16744 _ => Err(ParseError::MissingGameEventValue {
16745 ty: "MerasmusStunned",
16746 field: "todo".into(),
16747 }),
16748 }
16749 }
16750 #[allow(unused_variables)]
16751 fn write(
16752 &self,
16753 stream: &mut BitWriteStream<LittleEndian>,
16754 definition: &GameEventDefinition,
16755 ) -> Result<()> {
16756 for entry in &definition.entries {
16757 let value = self
16758 .get_field(entry)
16759 .unwrap_or_else(|_| entry.kind.default_value());
16760 stream.write(&value)?;
16761 }
16762 Ok(())
16763 }
16764}
16765#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16766#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16767pub struct MerasmusPropFoundEvent {
16768 pub player: u16,
16769}
16770impl MerasmusPropFoundEvent {
16771 #[allow(unused_variables)]
16772 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16773 Ok(MerasmusPropFoundEvent {
16774 player: read_value::<u16>(
16775 stream,
16776 definition.get_entry(5008278420455340480u64),
16777 "player",
16778 )?,
16779 })
16780 }
16781 #[allow(unused_variables)]
16782 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16783 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16784 match field.hash {
16785 5008278420455340480u64 => Ok(self.player.clone().into()),
16786 _ => Err(ParseError::MissingGameEventValue {
16787 ty: "MerasmusPropFound",
16788 field: "todo".into(),
16789 }),
16790 }
16791 }
16792 #[allow(unused_variables)]
16793 fn write(
16794 &self,
16795 stream: &mut BitWriteStream<LittleEndian>,
16796 definition: &GameEventDefinition,
16797 ) -> Result<()> {
16798 for entry in &definition.entries {
16799 let value = self
16800 .get_field(entry)
16801 .unwrap_or_else(|_| entry.kind.default_value());
16802 stream.write(&value)?;
16803 }
16804 Ok(())
16805 }
16806}
16807#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16808#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16809pub struct HalloweenSkeletonKilledEvent {
16810 pub player: u16,
16811}
16812impl HalloweenSkeletonKilledEvent {
16813 #[allow(unused_variables)]
16814 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16815 Ok(HalloweenSkeletonKilledEvent {
16816 player: read_value::<u16>(
16817 stream,
16818 definition.get_entry(5008278420455340480u64),
16819 "player",
16820 )?,
16821 })
16822 }
16823 #[allow(unused_variables)]
16824 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16825 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16826 match field.hash {
16827 5008278420455340480u64 => Ok(self.player.clone().into()),
16828 _ => Err(ParseError::MissingGameEventValue {
16829 ty: "HalloweenSkeletonKilled",
16830 field: "todo".into(),
16831 }),
16832 }
16833 }
16834 #[allow(unused_variables)]
16835 fn write(
16836 &self,
16837 stream: &mut BitWriteStream<LittleEndian>,
16838 definition: &GameEventDefinition,
16839 ) -> Result<()> {
16840 for entry in &definition.entries {
16841 let value = self
16842 .get_field(entry)
16843 .unwrap_or_else(|_| entry.kind.default_value());
16844 stream.write(&value)?;
16845 }
16846 Ok(())
16847 }
16848}
16849#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16850#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16851pub struct SkeletonKilledQuestEvent {
16852 pub player: u16,
16853}
16854impl SkeletonKilledQuestEvent {
16855 #[allow(unused_variables)]
16856 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16857 Ok(SkeletonKilledQuestEvent {
16858 player: read_value::<u16>(
16859 stream,
16860 definition.get_entry(5008278420455340480u64),
16861 "player",
16862 )?,
16863 })
16864 }
16865 #[allow(unused_variables)]
16866 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16867 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16868 match field.hash {
16869 5008278420455340480u64 => Ok(self.player.clone().into()),
16870 _ => Err(ParseError::MissingGameEventValue {
16871 ty: "SkeletonKilledQuest",
16872 field: "todo".into(),
16873 }),
16874 }
16875 }
16876 #[allow(unused_variables)]
16877 fn write(
16878 &self,
16879 stream: &mut BitWriteStream<LittleEndian>,
16880 definition: &GameEventDefinition,
16881 ) -> Result<()> {
16882 for entry in &definition.entries {
16883 let value = self
16884 .get_field(entry)
16885 .unwrap_or_else(|_| entry.kind.default_value());
16886 stream.write(&value)?;
16887 }
16888 Ok(())
16889 }
16890}
16891#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16892#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16893pub struct SkeletonKingKilledQuestEvent {
16894 pub player: u16,
16895}
16896impl SkeletonKingKilledQuestEvent {
16897 #[allow(unused_variables)]
16898 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16899 Ok(SkeletonKingKilledQuestEvent {
16900 player: read_value::<u16>(
16901 stream,
16902 definition.get_entry(5008278420455340480u64),
16903 "player",
16904 )?,
16905 })
16906 }
16907 #[allow(unused_variables)]
16908 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16909 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16910 match field.hash {
16911 5008278420455340480u64 => Ok(self.player.clone().into()),
16912 _ => Err(ParseError::MissingGameEventValue {
16913 ty: "SkeletonKingKilledQuest",
16914 field: "todo".into(),
16915 }),
16916 }
16917 }
16918 #[allow(unused_variables)]
16919 fn write(
16920 &self,
16921 stream: &mut BitWriteStream<LittleEndian>,
16922 definition: &GameEventDefinition,
16923 ) -> Result<()> {
16924 for entry in &definition.entries {
16925 let value = self
16926 .get_field(entry)
16927 .unwrap_or_else(|_| entry.kind.default_value());
16928 stream.write(&value)?;
16929 }
16930 Ok(())
16931 }
16932}
16933#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16934#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16935pub struct EscapeHellEvent {
16936 pub player: u16,
16937}
16938impl EscapeHellEvent {
16939 #[allow(unused_variables)]
16940 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16941 Ok(EscapeHellEvent {
16942 player: read_value::<u16>(
16943 stream,
16944 definition.get_entry(5008278420455340480u64),
16945 "player",
16946 )?,
16947 })
16948 }
16949 #[allow(unused_variables)]
16950 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16951 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16952 match field.hash {
16953 5008278420455340480u64 => Ok(self.player.clone().into()),
16954 _ => Err(ParseError::MissingGameEventValue {
16955 ty: "EscapeHell",
16956 field: "todo".into(),
16957 }),
16958 }
16959 }
16960 #[allow(unused_variables)]
16961 fn write(
16962 &self,
16963 stream: &mut BitWriteStream<LittleEndian>,
16964 definition: &GameEventDefinition,
16965 ) -> Result<()> {
16966 for entry in &definition.entries {
16967 let value = self
16968 .get_field(entry)
16969 .unwrap_or_else(|_| entry.kind.default_value());
16970 stream.write(&value)?;
16971 }
16972 Ok(())
16973 }
16974}
16975#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
16976#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
16977pub struct CrossSpectralBridgeEvent {
16978 pub player: u16,
16979}
16980impl CrossSpectralBridgeEvent {
16981 #[allow(unused_variables)]
16982 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
16983 Ok(CrossSpectralBridgeEvent {
16984 player: read_value::<u16>(
16985 stream,
16986 definition.get_entry(5008278420455340480u64),
16987 "player",
16988 )?,
16989 })
16990 }
16991 #[allow(unused_variables)]
16992 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
16993 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
16994 match field.hash {
16995 5008278420455340480u64 => Ok(self.player.clone().into()),
16996 _ => Err(ParseError::MissingGameEventValue {
16997 ty: "CrossSpectralBridge",
16998 field: "todo".into(),
16999 }),
17000 }
17001 }
17002 #[allow(unused_variables)]
17003 fn write(
17004 &self,
17005 stream: &mut BitWriteStream<LittleEndian>,
17006 definition: &GameEventDefinition,
17007 ) -> Result<()> {
17008 for entry in &definition.entries {
17009 let value = self
17010 .get_field(entry)
17011 .unwrap_or_else(|_| entry.kind.default_value());
17012 stream.write(&value)?;
17013 }
17014 Ok(())
17015 }
17016}
17017#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17018#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17019pub struct MiniGameWonEvent {
17020 pub player: u16,
17021 pub game: u16,
17022}
17023impl MiniGameWonEvent {
17024 #[allow(unused_variables)]
17025 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17026 Ok(MiniGameWonEvent {
17027 player: read_value::<u16>(
17028 stream,
17029 definition.get_entry(5008278420455340480u64),
17030 "player",
17031 )?,
17032 game: read_value::<u16>(
17033 stream,
17034 definition.get_entry(10005491431272162599u64),
17035 "game",
17036 )?,
17037 })
17038 }
17039 #[allow(unused_variables)]
17040 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17041 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17042 match field.hash {
17043 5008278420455340480u64 => Ok(self.player.clone().into()),
17044 10005491431272162599u64 => Ok(self.game.clone().into()),
17045 _ => Err(ParseError::MissingGameEventValue {
17046 ty: "MiniGameWon",
17047 field: "todo".into(),
17048 }),
17049 }
17050 }
17051 #[allow(unused_variables)]
17052 fn write(
17053 &self,
17054 stream: &mut BitWriteStream<LittleEndian>,
17055 definition: &GameEventDefinition,
17056 ) -> Result<()> {
17057 for entry in &definition.entries {
17058 let value = self
17059 .get_field(entry)
17060 .unwrap_or_else(|_| entry.kind.default_value());
17061 stream.write(&value)?;
17062 }
17063 Ok(())
17064 }
17065}
17066#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17067#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17068pub struct RespawnGhostEvent {
17069 pub reviver: u16,
17070 pub ghost: u16,
17071}
17072impl RespawnGhostEvent {
17073 #[allow(unused_variables)]
17074 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17075 Ok(RespawnGhostEvent {
17076 reviver: read_value::<u16>(
17077 stream,
17078 definition.get_entry(12335255211204103206u64),
17079 "reviver",
17080 )?,
17081 ghost: read_value::<u16>(
17082 stream,
17083 definition.get_entry(7564851073369177808u64),
17084 "ghost",
17085 )?,
17086 })
17087 }
17088 #[allow(unused_variables)]
17089 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17090 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17091 match field.hash {
17092 12335255211204103206u64 => Ok(self.reviver.clone().into()),
17093 7564851073369177808u64 => Ok(self.ghost.clone().into()),
17094 _ => Err(ParseError::MissingGameEventValue {
17095 ty: "RespawnGhost",
17096 field: "todo".into(),
17097 }),
17098 }
17099 }
17100 #[allow(unused_variables)]
17101 fn write(
17102 &self,
17103 stream: &mut BitWriteStream<LittleEndian>,
17104 definition: &GameEventDefinition,
17105 ) -> Result<()> {
17106 for entry in &definition.entries {
17107 let value = self
17108 .get_field(entry)
17109 .unwrap_or_else(|_| entry.kind.default_value());
17110 stream.write(&value)?;
17111 }
17112 Ok(())
17113 }
17114}
17115#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17116#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17117pub struct KillInHellEvent {
17118 pub killer: u16,
17119 pub victim: u16,
17120}
17121impl KillInHellEvent {
17122 #[allow(unused_variables)]
17123 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17124 Ok(KillInHellEvent {
17125 killer: read_value::<u16>(
17126 stream,
17127 definition.get_entry(7927307102854403058u64),
17128 "killer",
17129 )?,
17130 victim: read_value::<u16>(
17131 stream,
17132 definition.get_entry(3120917251440744469u64),
17133 "victim",
17134 )?,
17135 })
17136 }
17137 #[allow(unused_variables)]
17138 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17139 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17140 match field.hash {
17141 7927307102854403058u64 => Ok(self.killer.clone().into()),
17142 3120917251440744469u64 => Ok(self.victim.clone().into()),
17143 _ => Err(ParseError::MissingGameEventValue {
17144 ty: "KillInHell",
17145 field: "todo".into(),
17146 }),
17147 }
17148 }
17149 #[allow(unused_variables)]
17150 fn write(
17151 &self,
17152 stream: &mut BitWriteStream<LittleEndian>,
17153 definition: &GameEventDefinition,
17154 ) -> Result<()> {
17155 for entry in &definition.entries {
17156 let value = self
17157 .get_field(entry)
17158 .unwrap_or_else(|_| entry.kind.default_value());
17159 stream.write(&value)?;
17160 }
17161 Ok(())
17162 }
17163}
17164#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17165#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17166pub struct HalloweenDuckCollectedEvent {
17167 pub collector: u16,
17168}
17169impl HalloweenDuckCollectedEvent {
17170 #[allow(unused_variables)]
17171 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17172 Ok(HalloweenDuckCollectedEvent {
17173 collector: read_value::<u16>(
17174 stream,
17175 definition.get_entry(10138905367994436056u64),
17176 "collector",
17177 )?,
17178 })
17179 }
17180 #[allow(unused_variables)]
17181 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17182 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17183 match field.hash {
17184 10138905367994436056u64 => Ok(self.collector.clone().into()),
17185 _ => Err(ParseError::MissingGameEventValue {
17186 ty: "HalloweenDuckCollected",
17187 field: "todo".into(),
17188 }),
17189 }
17190 }
17191 #[allow(unused_variables)]
17192 fn write(
17193 &self,
17194 stream: &mut BitWriteStream<LittleEndian>,
17195 definition: &GameEventDefinition,
17196 ) -> Result<()> {
17197 for entry in &definition.entries {
17198 let value = self
17199 .get_field(entry)
17200 .unwrap_or_else(|_| entry.kind.default_value());
17201 stream.write(&value)?;
17202 }
17203 Ok(())
17204 }
17205}
17206#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17207#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17208pub struct SpecialScoreEvent {
17209 pub player: u8,
17210}
17211impl SpecialScoreEvent {
17212 #[allow(unused_variables)]
17213 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17214 Ok(SpecialScoreEvent {
17215 player: read_value::<u8>(
17216 stream,
17217 definition.get_entry(5008278420455340480u64),
17218 "player",
17219 )?,
17220 })
17221 }
17222 #[allow(unused_variables)]
17223 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17224 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17225 match field.hash {
17226 5008278420455340480u64 => Ok(self.player.clone().into()),
17227 _ => Err(ParseError::MissingGameEventValue {
17228 ty: "SpecialScore",
17229 field: "todo".into(),
17230 }),
17231 }
17232 }
17233 #[allow(unused_variables)]
17234 fn write(
17235 &self,
17236 stream: &mut BitWriteStream<LittleEndian>,
17237 definition: &GameEventDefinition,
17238 ) -> Result<()> {
17239 for entry in &definition.entries {
17240 let value = self
17241 .get_field(entry)
17242 .unwrap_or_else(|_| entry.kind.default_value());
17243 stream.write(&value)?;
17244 }
17245 Ok(())
17246 }
17247}
17248#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17249#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17250pub struct TeamLeaderKilledEvent {
17251 pub killer: u8,
17252 pub victim: u8,
17253}
17254impl TeamLeaderKilledEvent {
17255 #[allow(unused_variables)]
17256 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17257 Ok(TeamLeaderKilledEvent {
17258 killer: read_value::<u8>(
17259 stream,
17260 definition.get_entry(7927307102854403058u64),
17261 "killer",
17262 )?,
17263 victim: read_value::<u8>(
17264 stream,
17265 definition.get_entry(3120917251440744469u64),
17266 "victim",
17267 )?,
17268 })
17269 }
17270 #[allow(unused_variables)]
17271 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17272 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17273 match field.hash {
17274 7927307102854403058u64 => Ok(self.killer.clone().into()),
17275 3120917251440744469u64 => Ok(self.victim.clone().into()),
17276 _ => Err(ParseError::MissingGameEventValue {
17277 ty: "TeamLeaderKilled",
17278 field: "todo".into(),
17279 }),
17280 }
17281 }
17282 #[allow(unused_variables)]
17283 fn write(
17284 &self,
17285 stream: &mut BitWriteStream<LittleEndian>,
17286 definition: &GameEventDefinition,
17287 ) -> Result<()> {
17288 for entry in &definition.entries {
17289 let value = self
17290 .get_field(entry)
17291 .unwrap_or_else(|_| entry.kind.default_value());
17292 stream.write(&value)?;
17293 }
17294 Ok(())
17295 }
17296}
17297#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17298#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17299pub struct HalloweenSoulCollectedEvent {
17300 pub intended_target: u8,
17301 pub collecting_player: u8,
17302 pub soul_count: u8,
17303}
17304impl HalloweenSoulCollectedEvent {
17305 #[allow(unused_variables)]
17306 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17307 Ok(HalloweenSoulCollectedEvent {
17308 intended_target: read_value::<u8>(
17309 stream,
17310 definition.get_entry(6824378530660796482u64),
17311 "intended_target",
17312 )?,
17313 collecting_player: read_value::<u8>(
17314 stream,
17315 definition.get_entry(12517516231050690021u64),
17316 "collecting_player",
17317 )?,
17318 soul_count: read_value::<u8>(
17319 stream,
17320 definition.get_entry(715456465272287634u64),
17321 "soul_count",
17322 )?,
17323 })
17324 }
17325 #[allow(unused_variables)]
17326 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17327 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17328 match field.hash {
17329 6824378530660796482u64 => Ok(self.intended_target.clone().into()),
17330 12517516231050690021u64 => Ok(self.collecting_player.clone().into()),
17331 715456465272287634u64 => Ok(self.soul_count.clone().into()),
17332 _ => Err(ParseError::MissingGameEventValue {
17333 ty: "HalloweenSoulCollected",
17334 field: "todo".into(),
17335 }),
17336 }
17337 }
17338 #[allow(unused_variables)]
17339 fn write(
17340 &self,
17341 stream: &mut BitWriteStream<LittleEndian>,
17342 definition: &GameEventDefinition,
17343 ) -> Result<()> {
17344 for entry in &definition.entries {
17345 let value = self
17346 .get_field(entry)
17347 .unwrap_or_else(|_| entry.kind.default_value());
17348 stream.write(&value)?;
17349 }
17350 Ok(())
17351 }
17352}
17353#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17354#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17355pub struct RecalculateTruceEvent {}
17356impl RecalculateTruceEvent {
17357 #[allow(unused_variables)]
17358 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17359 Ok(RecalculateTruceEvent {})
17360 }
17361 #[allow(unused_variables)]
17362 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17363 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17364 match field.hash {
17365 _ => Err(ParseError::MissingGameEventValue {
17366 ty: "RecalculateTruce",
17367 field: "todo".into(),
17368 }),
17369 }
17370 }
17371 #[allow(unused_variables)]
17372 fn write(
17373 &self,
17374 stream: &mut BitWriteStream<LittleEndian>,
17375 definition: &GameEventDefinition,
17376 ) -> Result<()> {
17377 for entry in &definition.entries {
17378 let value = self
17379 .get_field(entry)
17380 .unwrap_or_else(|_| entry.kind.default_value());
17381 stream.write(&value)?;
17382 }
17383 Ok(())
17384 }
17385}
17386#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17387#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17388pub struct DeadRingerCheatDeathEvent {
17389 pub spy: u8,
17390 pub attacker: u8,
17391}
17392impl DeadRingerCheatDeathEvent {
17393 #[allow(unused_variables)]
17394 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17395 Ok(DeadRingerCheatDeathEvent {
17396 spy: read_value::<u8>(stream, definition.get_entry(9394673858373567453u64), "spy")?,
17397 attacker: read_value::<u8>(
17398 stream,
17399 definition.get_entry(7198542740550218478u64),
17400 "attacker",
17401 )?,
17402 })
17403 }
17404 #[allow(unused_variables)]
17405 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17406 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17407 match field.hash {
17408 9394673858373567453u64 => Ok(self.spy.clone().into()),
17409 7198542740550218478u64 => Ok(self.attacker.clone().into()),
17410 _ => Err(ParseError::MissingGameEventValue {
17411 ty: "DeadRingerCheatDeath",
17412 field: "todo".into(),
17413 }),
17414 }
17415 }
17416 #[allow(unused_variables)]
17417 fn write(
17418 &self,
17419 stream: &mut BitWriteStream<LittleEndian>,
17420 definition: &GameEventDefinition,
17421 ) -> Result<()> {
17422 for entry in &definition.entries {
17423 let value = self
17424 .get_field(entry)
17425 .unwrap_or_else(|_| entry.kind.default_value());
17426 stream.write(&value)?;
17427 }
17428 Ok(())
17429 }
17430}
17431#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17432#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17433pub struct CrossbowHealEvent {
17434 pub healer: u8,
17435 pub target: u8,
17436 pub amount: u16,
17437}
17438impl CrossbowHealEvent {
17439 #[allow(unused_variables)]
17440 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17441 Ok(CrossbowHealEvent {
17442 healer: read_value::<u8>(
17443 stream,
17444 definition.get_entry(9195440821534910520u64),
17445 "healer",
17446 )?,
17447 target: read_value::<u8>(
17448 stream,
17449 definition.get_entry(1653916590517707752u64),
17450 "target",
17451 )?,
17452 amount: read_value::<u16>(
17453 stream,
17454 definition.get_entry(9301057475299076457u64),
17455 "amount",
17456 )?,
17457 })
17458 }
17459 #[allow(unused_variables)]
17460 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17461 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17462 match field.hash {
17463 9195440821534910520u64 => Ok(self.healer.clone().into()),
17464 1653916590517707752u64 => Ok(self.target.clone().into()),
17465 9301057475299076457u64 => Ok(self.amount.clone().into()),
17466 _ => Err(ParseError::MissingGameEventValue {
17467 ty: "CrossbowHeal",
17468 field: "todo".into(),
17469 }),
17470 }
17471 }
17472 #[allow(unused_variables)]
17473 fn write(
17474 &self,
17475 stream: &mut BitWriteStream<LittleEndian>,
17476 definition: &GameEventDefinition,
17477 ) -> Result<()> {
17478 for entry in &definition.entries {
17479 let value = self
17480 .get_field(entry)
17481 .unwrap_or_else(|_| entry.kind.default_value());
17482 stream.write(&value)?;
17483 }
17484 Ok(())
17485 }
17486}
17487#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17488#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17489pub struct DamageMitigatedEvent {
17490 pub mitigator: u8,
17491 pub damaged: u8,
17492 pub amount: u16,
17493 pub item_definition_index: u16,
17494}
17495impl DamageMitigatedEvent {
17496 #[allow(unused_variables)]
17497 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17498 Ok(DamageMitigatedEvent {
17499 mitigator: read_value::<u8>(
17500 stream,
17501 definition.get_entry(6131810397813237369u64),
17502 "mitigator",
17503 )?,
17504 damaged: read_value::<u8>(
17505 stream,
17506 definition.get_entry(2938457768903959468u64),
17507 "damaged",
17508 )?,
17509 amount: read_value::<u16>(
17510 stream,
17511 definition.get_entry(9301057475299076457u64),
17512 "amount",
17513 )?,
17514 item_definition_index: read_value::<u16>(
17515 stream,
17516 definition.get_entry(4926523576391011283u64),
17517 "item_definition_index",
17518 )?,
17519 })
17520 }
17521 #[allow(unused_variables)]
17522 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17523 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17524 match field.hash {
17525 6131810397813237369u64 => Ok(self.mitigator.clone().into()),
17526 2938457768903959468u64 => Ok(self.damaged.clone().into()),
17527 9301057475299076457u64 => Ok(self.amount.clone().into()),
17528 4926523576391011283u64 => Ok(self.item_definition_index.clone().into()),
17529 _ => Err(ParseError::MissingGameEventValue {
17530 ty: "DamageMitigated",
17531 field: "todo".into(),
17532 }),
17533 }
17534 }
17535 #[allow(unused_variables)]
17536 fn write(
17537 &self,
17538 stream: &mut BitWriteStream<LittleEndian>,
17539 definition: &GameEventDefinition,
17540 ) -> Result<()> {
17541 for entry in &definition.entries {
17542 let value = self
17543 .get_field(entry)
17544 .unwrap_or_else(|_| entry.kind.default_value());
17545 stream.write(&value)?;
17546 }
17547 Ok(())
17548 }
17549}
17550#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17551#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17552pub struct PayloadPushedEvent {
17553 pub pusher: u8,
17554 pub distance: u16,
17555}
17556impl PayloadPushedEvent {
17557 #[allow(unused_variables)]
17558 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17559 Ok(PayloadPushedEvent {
17560 pusher: read_value::<u8>(
17561 stream,
17562 definition.get_entry(16364632941784438830u64),
17563 "pusher",
17564 )?,
17565 distance: read_value::<u16>(
17566 stream,
17567 definition.get_entry(15956180055569954882u64),
17568 "distance",
17569 )?,
17570 })
17571 }
17572 #[allow(unused_variables)]
17573 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17574 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17575 match field.hash {
17576 16364632941784438830u64 => Ok(self.pusher.clone().into()),
17577 15956180055569954882u64 => Ok(self.distance.clone().into()),
17578 _ => Err(ParseError::MissingGameEventValue {
17579 ty: "PayloadPushed",
17580 field: "todo".into(),
17581 }),
17582 }
17583 }
17584 #[allow(unused_variables)]
17585 fn write(
17586 &self,
17587 stream: &mut BitWriteStream<LittleEndian>,
17588 definition: &GameEventDefinition,
17589 ) -> Result<()> {
17590 for entry in &definition.entries {
17591 let value = self
17592 .get_field(entry)
17593 .unwrap_or_else(|_| entry.kind.default_value());
17594 stream.write(&value)?;
17595 }
17596 Ok(())
17597 }
17598}
17599#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17600#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17601pub struct PlayerAbandonedMatchEvent {
17602 pub game_over: bool,
17603}
17604impl PlayerAbandonedMatchEvent {
17605 #[allow(unused_variables)]
17606 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17607 Ok(PlayerAbandonedMatchEvent {
17608 game_over: read_value::<bool>(
17609 stream,
17610 definition.get_entry(17040732377939006530u64),
17611 "game_over",
17612 )?,
17613 })
17614 }
17615 #[allow(unused_variables)]
17616 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17617 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17618 match field.hash {
17619 17040732377939006530u64 => Ok(self.game_over.clone().into()),
17620 _ => Err(ParseError::MissingGameEventValue {
17621 ty: "PlayerAbandonedMatch",
17622 field: "todo".into(),
17623 }),
17624 }
17625 }
17626 #[allow(unused_variables)]
17627 fn write(
17628 &self,
17629 stream: &mut BitWriteStream<LittleEndian>,
17630 definition: &GameEventDefinition,
17631 ) -> Result<()> {
17632 for entry in &definition.entries {
17633 let value = self
17634 .get_field(entry)
17635 .unwrap_or_else(|_| entry.kind.default_value());
17636 stream.write(&value)?;
17637 }
17638 Ok(())
17639 }
17640}
17641#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17642#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17643pub struct ClDrawlineEvent {
17644 pub player: u8,
17645 pub panel: u8,
17646 pub line: u8,
17647 pub x: f32,
17648 pub y: f32,
17649}
17650impl ClDrawlineEvent {
17651 #[allow(unused_variables)]
17652 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17653 Ok(ClDrawlineEvent {
17654 player: read_value::<u8>(
17655 stream,
17656 definition.get_entry(5008278420455340480u64),
17657 "player",
17658 )?,
17659 panel: read_value::<u8>(
17660 stream,
17661 definition.get_entry(6829252156396663685u64),
17662 "panel",
17663 )?,
17664 line: read_value::<u8>(
17665 stream,
17666 definition.get_entry(13784293248712268039u64),
17667 "line",
17668 )?,
17669 x: read_value::<f32>(stream, definition.get_entry(12638214688346347271u64), "x")?,
17670 y: read_value::<f32>(stream, definition.get_entry(12638213588834719060u64), "y")?,
17671 })
17672 }
17673 #[allow(unused_variables)]
17674 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17675 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17676 match field.hash {
17677 5008278420455340480u64 => Ok(self.player.clone().into()),
17678 6829252156396663685u64 => Ok(self.panel.clone().into()),
17679 13784293248712268039u64 => Ok(self.line.clone().into()),
17680 12638214688346347271u64 => Ok(self.x.clone().into()),
17681 12638213588834719060u64 => Ok(self.y.clone().into()),
17682 _ => Err(ParseError::MissingGameEventValue {
17683 ty: "ClDrawline",
17684 field: "todo".into(),
17685 }),
17686 }
17687 }
17688 #[allow(unused_variables)]
17689 fn write(
17690 &self,
17691 stream: &mut BitWriteStream<LittleEndian>,
17692 definition: &GameEventDefinition,
17693 ) -> Result<()> {
17694 for entry in &definition.entries {
17695 let value = self
17696 .get_field(entry)
17697 .unwrap_or_else(|_| entry.kind.default_value());
17698 stream.write(&value)?;
17699 }
17700 Ok(())
17701 }
17702}
17703#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17704#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17705pub struct RestartTimerTimeEvent {
17706 pub time: u8,
17707}
17708impl RestartTimerTimeEvent {
17709 #[allow(unused_variables)]
17710 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17711 Ok(RestartTimerTimeEvent {
17712 time: read_value::<u8>(stream, definition.get_entry(2185518981507421060u64), "time")?,
17713 })
17714 }
17715 #[allow(unused_variables)]
17716 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17717 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17718 match field.hash {
17719 2185518981507421060u64 => Ok(self.time.clone().into()),
17720 _ => Err(ParseError::MissingGameEventValue {
17721 ty: "RestartTimerTime",
17722 field: "todo".into(),
17723 }),
17724 }
17725 }
17726 #[allow(unused_variables)]
17727 fn write(
17728 &self,
17729 stream: &mut BitWriteStream<LittleEndian>,
17730 definition: &GameEventDefinition,
17731 ) -> Result<()> {
17732 for entry in &definition.entries {
17733 let value = self
17734 .get_field(entry)
17735 .unwrap_or_else(|_| entry.kind.default_value());
17736 stream.write(&value)?;
17737 }
17738 Ok(())
17739 }
17740}
17741#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17742#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17743pub struct WinLimitChangedEvent {}
17744impl WinLimitChangedEvent {
17745 #[allow(unused_variables)]
17746 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17747 Ok(WinLimitChangedEvent {})
17748 }
17749 #[allow(unused_variables)]
17750 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17751 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17752 match field.hash {
17753 _ => Err(ParseError::MissingGameEventValue {
17754 ty: "WinLimitChanged",
17755 field: "todo".into(),
17756 }),
17757 }
17758 }
17759 #[allow(unused_variables)]
17760 fn write(
17761 &self,
17762 stream: &mut BitWriteStream<LittleEndian>,
17763 definition: &GameEventDefinition,
17764 ) -> Result<()> {
17765 for entry in &definition.entries {
17766 let value = self
17767 .get_field(entry)
17768 .unwrap_or_else(|_| entry.kind.default_value());
17769 stream.write(&value)?;
17770 }
17771 Ok(())
17772 }
17773}
17774#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17775#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17776pub struct WinPanelShowScoresEvent {}
17777impl WinPanelShowScoresEvent {
17778 #[allow(unused_variables)]
17779 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17780 Ok(WinPanelShowScoresEvent {})
17781 }
17782 #[allow(unused_variables)]
17783 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17784 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17785 match field.hash {
17786 _ => Err(ParseError::MissingGameEventValue {
17787 ty: "WinPanelShowScores",
17788 field: "todo".into(),
17789 }),
17790 }
17791 }
17792 #[allow(unused_variables)]
17793 fn write(
17794 &self,
17795 stream: &mut BitWriteStream<LittleEndian>,
17796 definition: &GameEventDefinition,
17797 ) -> Result<()> {
17798 for entry in &definition.entries {
17799 let value = self
17800 .get_field(entry)
17801 .unwrap_or_else(|_| entry.kind.default_value());
17802 stream.write(&value)?;
17803 }
17804 Ok(())
17805 }
17806}
17807#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17808#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17809pub struct TopStreamsRequestFinishedEvent {}
17810impl TopStreamsRequestFinishedEvent {
17811 #[allow(unused_variables)]
17812 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17813 Ok(TopStreamsRequestFinishedEvent {})
17814 }
17815 #[allow(unused_variables)]
17816 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17817 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17818 match field.hash {
17819 _ => Err(ParseError::MissingGameEventValue {
17820 ty: "TopStreamsRequestFinished",
17821 field: "todo".into(),
17822 }),
17823 }
17824 }
17825 #[allow(unused_variables)]
17826 fn write(
17827 &self,
17828 stream: &mut BitWriteStream<LittleEndian>,
17829 definition: &GameEventDefinition,
17830 ) -> Result<()> {
17831 for entry in &definition.entries {
17832 let value = self
17833 .get_field(entry)
17834 .unwrap_or_else(|_| entry.kind.default_value());
17835 stream.write(&value)?;
17836 }
17837 Ok(())
17838 }
17839}
17840#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17841#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17842pub struct CompetitiveStateChangedEvent {}
17843impl CompetitiveStateChangedEvent {
17844 #[allow(unused_variables)]
17845 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17846 Ok(CompetitiveStateChangedEvent {})
17847 }
17848 #[allow(unused_variables)]
17849 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17850 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17851 match field.hash {
17852 _ => Err(ParseError::MissingGameEventValue {
17853 ty: "CompetitiveStateChanged",
17854 field: "todo".into(),
17855 }),
17856 }
17857 }
17858 #[allow(unused_variables)]
17859 fn write(
17860 &self,
17861 stream: &mut BitWriteStream<LittleEndian>,
17862 definition: &GameEventDefinition,
17863 ) -> Result<()> {
17864 for entry in &definition.entries {
17865 let value = self
17866 .get_field(entry)
17867 .unwrap_or_else(|_| entry.kind.default_value());
17868 stream.write(&value)?;
17869 }
17870 Ok(())
17871 }
17872}
17873#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17874#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17875pub struct GlobalWarDataUpdatedEvent {}
17876impl GlobalWarDataUpdatedEvent {
17877 #[allow(unused_variables)]
17878 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17879 Ok(GlobalWarDataUpdatedEvent {})
17880 }
17881 #[allow(unused_variables)]
17882 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17883 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17884 match field.hash {
17885 _ => Err(ParseError::MissingGameEventValue {
17886 ty: "GlobalWarDataUpdated",
17887 field: "todo".into(),
17888 }),
17889 }
17890 }
17891 #[allow(unused_variables)]
17892 fn write(
17893 &self,
17894 stream: &mut BitWriteStream<LittleEndian>,
17895 definition: &GameEventDefinition,
17896 ) -> Result<()> {
17897 for entry in &definition.entries {
17898 let value = self
17899 .get_field(entry)
17900 .unwrap_or_else(|_| entry.kind.default_value());
17901 stream.write(&value)?;
17902 }
17903 Ok(())
17904 }
17905}
17906#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17907#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17908pub struct StopWatchChangedEvent {}
17909impl StopWatchChangedEvent {
17910 #[allow(unused_variables)]
17911 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17912 Ok(StopWatchChangedEvent {})
17913 }
17914 #[allow(unused_variables)]
17915 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17916 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17917 match field.hash {
17918 _ => Err(ParseError::MissingGameEventValue {
17919 ty: "StopWatchChanged",
17920 field: "todo".into(),
17921 }),
17922 }
17923 }
17924 #[allow(unused_variables)]
17925 fn write(
17926 &self,
17927 stream: &mut BitWriteStream<LittleEndian>,
17928 definition: &GameEventDefinition,
17929 ) -> Result<()> {
17930 for entry in &definition.entries {
17931 let value = self
17932 .get_field(entry)
17933 .unwrap_or_else(|_| entry.kind.default_value());
17934 stream.write(&value)?;
17935 }
17936 Ok(())
17937 }
17938}
17939#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17940#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17941pub struct DsStopEvent {}
17942impl DsStopEvent {
17943 #[allow(unused_variables)]
17944 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17945 Ok(DsStopEvent {})
17946 }
17947 #[allow(unused_variables)]
17948 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17949 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17950 match field.hash {
17951 _ => Err(ParseError::MissingGameEventValue {
17952 ty: "DsStop",
17953 field: "todo".into(),
17954 }),
17955 }
17956 }
17957 #[allow(unused_variables)]
17958 fn write(
17959 &self,
17960 stream: &mut BitWriteStream<LittleEndian>,
17961 definition: &GameEventDefinition,
17962 ) -> Result<()> {
17963 for entry in &definition.entries {
17964 let value = self
17965 .get_field(entry)
17966 .unwrap_or_else(|_| entry.kind.default_value());
17967 stream.write(&value)?;
17968 }
17969 Ok(())
17970 }
17971}
17972#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
17973#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
17974pub struct DsScreenshotEvent {
17975 pub delay: f32,
17976}
17977impl DsScreenshotEvent {
17978 #[allow(unused_variables)]
17979 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
17980 Ok(DsScreenshotEvent {
17981 delay: read_value::<f32>(
17982 stream,
17983 definition.get_entry(5892760507766377784u64),
17984 "delay",
17985 )?,
17986 })
17987 }
17988 #[allow(unused_variables)]
17989 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
17990 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
17991 match field.hash {
17992 5892760507766377784u64 => Ok(self.delay.clone().into()),
17993 _ => Err(ParseError::MissingGameEventValue {
17994 ty: "DsScreenshot",
17995 field: "todo".into(),
17996 }),
17997 }
17998 }
17999 #[allow(unused_variables)]
18000 fn write(
18001 &self,
18002 stream: &mut BitWriteStream<LittleEndian>,
18003 definition: &GameEventDefinition,
18004 ) -> Result<()> {
18005 for entry in &definition.entries {
18006 let value = self
18007 .get_field(entry)
18008 .unwrap_or_else(|_| entry.kind.default_value());
18009 stream.write(&value)?;
18010 }
18011 Ok(())
18012 }
18013}
18014#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18015#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18016pub struct ShowMatchSummaryEvent {}
18017impl ShowMatchSummaryEvent {
18018 #[allow(unused_variables)]
18019 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18020 Ok(ShowMatchSummaryEvent {})
18021 }
18022 #[allow(unused_variables)]
18023 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18024 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18025 match field.hash {
18026 _ => Err(ParseError::MissingGameEventValue {
18027 ty: "ShowMatchSummary",
18028 field: "todo".into(),
18029 }),
18030 }
18031 }
18032 #[allow(unused_variables)]
18033 fn write(
18034 &self,
18035 stream: &mut BitWriteStream<LittleEndian>,
18036 definition: &GameEventDefinition,
18037 ) -> Result<()> {
18038 for entry in &definition.entries {
18039 let value = self
18040 .get_field(entry)
18041 .unwrap_or_else(|_| entry.kind.default_value());
18042 stream.write(&value)?;
18043 }
18044 Ok(())
18045 }
18046}
18047#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18048#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18049pub struct ExperienceChangedEvent {}
18050impl ExperienceChangedEvent {
18051 #[allow(unused_variables)]
18052 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18053 Ok(ExperienceChangedEvent {})
18054 }
18055 #[allow(unused_variables)]
18056 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18057 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18058 match field.hash {
18059 _ => Err(ParseError::MissingGameEventValue {
18060 ty: "ExperienceChanged",
18061 field: "todo".into(),
18062 }),
18063 }
18064 }
18065 #[allow(unused_variables)]
18066 fn write(
18067 &self,
18068 stream: &mut BitWriteStream<LittleEndian>,
18069 definition: &GameEventDefinition,
18070 ) -> Result<()> {
18071 for entry in &definition.entries {
18072 let value = self
18073 .get_field(entry)
18074 .unwrap_or_else(|_| entry.kind.default_value());
18075 stream.write(&value)?;
18076 }
18077 Ok(())
18078 }
18079}
18080#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18081#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18082pub struct BeginXpLerpEvent {}
18083impl BeginXpLerpEvent {
18084 #[allow(unused_variables)]
18085 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18086 Ok(BeginXpLerpEvent {})
18087 }
18088 #[allow(unused_variables)]
18089 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18090 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18091 match field.hash {
18092 _ => Err(ParseError::MissingGameEventValue {
18093 ty: "BeginXpLerp",
18094 field: "todo".into(),
18095 }),
18096 }
18097 }
18098 #[allow(unused_variables)]
18099 fn write(
18100 &self,
18101 stream: &mut BitWriteStream<LittleEndian>,
18102 definition: &GameEventDefinition,
18103 ) -> Result<()> {
18104 for entry in &definition.entries {
18105 let value = self
18106 .get_field(entry)
18107 .unwrap_or_else(|_| entry.kind.default_value());
18108 stream.write(&value)?;
18109 }
18110 Ok(())
18111 }
18112}
18113#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18114#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18115pub struct MatchmakerStatsUpdatedEvent {}
18116impl MatchmakerStatsUpdatedEvent {
18117 #[allow(unused_variables)]
18118 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18119 Ok(MatchmakerStatsUpdatedEvent {})
18120 }
18121 #[allow(unused_variables)]
18122 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18123 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18124 match field.hash {
18125 _ => Err(ParseError::MissingGameEventValue {
18126 ty: "MatchmakerStatsUpdated",
18127 field: "todo".into(),
18128 }),
18129 }
18130 }
18131 #[allow(unused_variables)]
18132 fn write(
18133 &self,
18134 stream: &mut BitWriteStream<LittleEndian>,
18135 definition: &GameEventDefinition,
18136 ) -> Result<()> {
18137 for entry in &definition.entries {
18138 let value = self
18139 .get_field(entry)
18140 .unwrap_or_else(|_| entry.kind.default_value());
18141 stream.write(&value)?;
18142 }
18143 Ok(())
18144 }
18145}
18146#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18147#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18148pub struct RematchVotePeriodOverEvent {
18149 pub success: bool,
18150}
18151impl RematchVotePeriodOverEvent {
18152 #[allow(unused_variables)]
18153 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18154 Ok(RematchVotePeriodOverEvent {
18155 success: read_value::<bool>(
18156 stream,
18157 definition.get_entry(1872942068143117264u64),
18158 "success",
18159 )?,
18160 })
18161 }
18162 #[allow(unused_variables)]
18163 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18164 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18165 match field.hash {
18166 1872942068143117264u64 => Ok(self.success.clone().into()),
18167 _ => Err(ParseError::MissingGameEventValue {
18168 ty: "RematchVotePeriodOver",
18169 field: "todo".into(),
18170 }),
18171 }
18172 }
18173 #[allow(unused_variables)]
18174 fn write(
18175 &self,
18176 stream: &mut BitWriteStream<LittleEndian>,
18177 definition: &GameEventDefinition,
18178 ) -> Result<()> {
18179 for entry in &definition.entries {
18180 let value = self
18181 .get_field(entry)
18182 .unwrap_or_else(|_| entry.kind.default_value());
18183 stream.write(&value)?;
18184 }
18185 Ok(())
18186 }
18187}
18188#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18189#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18190pub struct RematchFailedToCreateEvent {}
18191impl RematchFailedToCreateEvent {
18192 #[allow(unused_variables)]
18193 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18194 Ok(RematchFailedToCreateEvent {})
18195 }
18196 #[allow(unused_variables)]
18197 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18198 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18199 match field.hash {
18200 _ => Err(ParseError::MissingGameEventValue {
18201 ty: "RematchFailedToCreate",
18202 field: "todo".into(),
18203 }),
18204 }
18205 }
18206 #[allow(unused_variables)]
18207 fn write(
18208 &self,
18209 stream: &mut BitWriteStream<LittleEndian>,
18210 definition: &GameEventDefinition,
18211 ) -> Result<()> {
18212 for entry in &definition.entries {
18213 let value = self
18214 .get_field(entry)
18215 .unwrap_or_else(|_| entry.kind.default_value());
18216 stream.write(&value)?;
18217 }
18218 Ok(())
18219 }
18220}
18221#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18222#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18223pub struct PlayerRematchChangeEvent {}
18224impl PlayerRematchChangeEvent {
18225 #[allow(unused_variables)]
18226 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18227 Ok(PlayerRematchChangeEvent {})
18228 }
18229 #[allow(unused_variables)]
18230 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18231 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18232 match field.hash {
18233 _ => Err(ParseError::MissingGameEventValue {
18234 ty: "PlayerRematchChange",
18235 field: "todo".into(),
18236 }),
18237 }
18238 }
18239 #[allow(unused_variables)]
18240 fn write(
18241 &self,
18242 stream: &mut BitWriteStream<LittleEndian>,
18243 definition: &GameEventDefinition,
18244 ) -> Result<()> {
18245 for entry in &definition.entries {
18246 let value = self
18247 .get_field(entry)
18248 .unwrap_or_else(|_| entry.kind.default_value());
18249 stream.write(&value)?;
18250 }
18251 Ok(())
18252 }
18253}
18254#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18255#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18256pub struct PingUpdatedEvent {}
18257impl PingUpdatedEvent {
18258 #[allow(unused_variables)]
18259 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18260 Ok(PingUpdatedEvent {})
18261 }
18262 #[allow(unused_variables)]
18263 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18264 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18265 match field.hash {
18266 _ => Err(ParseError::MissingGameEventValue {
18267 ty: "PingUpdated",
18268 field: "todo".into(),
18269 }),
18270 }
18271 }
18272 #[allow(unused_variables)]
18273 fn write(
18274 &self,
18275 stream: &mut BitWriteStream<LittleEndian>,
18276 definition: &GameEventDefinition,
18277 ) -> Result<()> {
18278 for entry in &definition.entries {
18279 let value = self
18280 .get_field(entry)
18281 .unwrap_or_else(|_| entry.kind.default_value());
18282 stream.write(&value)?;
18283 }
18284 Ok(())
18285 }
18286}
18287#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18288#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18289pub struct MMStatsUpdatedEvent {}
18290impl MMStatsUpdatedEvent {
18291 #[allow(unused_variables)]
18292 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18293 Ok(MMStatsUpdatedEvent {})
18294 }
18295 #[allow(unused_variables)]
18296 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18297 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18298 match field.hash {
18299 _ => Err(ParseError::MissingGameEventValue {
18300 ty: "MMStatsUpdated",
18301 field: "todo".into(),
18302 }),
18303 }
18304 }
18305 #[allow(unused_variables)]
18306 fn write(
18307 &self,
18308 stream: &mut BitWriteStream<LittleEndian>,
18309 definition: &GameEventDefinition,
18310 ) -> Result<()> {
18311 for entry in &definition.entries {
18312 let value = self
18313 .get_field(entry)
18314 .unwrap_or_else(|_| entry.kind.default_value());
18315 stream.write(&value)?;
18316 }
18317 Ok(())
18318 }
18319}
18320#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18321#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18322pub struct PlayerNextMapVoteChangeEvent {
18323 pub map_index: u8,
18324 pub vote: u8,
18325}
18326impl PlayerNextMapVoteChangeEvent {
18327 #[allow(unused_variables)]
18328 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18329 Ok(PlayerNextMapVoteChangeEvent {
18330 map_index: read_value::<u8>(
18331 stream,
18332 definition.get_entry(14809078982718236190u64),
18333 "map_index",
18334 )?,
18335 vote: read_value::<u8>(stream, definition.get_entry(3543466495390456501u64), "vote")?,
18336 })
18337 }
18338 #[allow(unused_variables)]
18339 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18340 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18341 match field.hash {
18342 14809078982718236190u64 => Ok(self.map_index.clone().into()),
18343 3543466495390456501u64 => Ok(self.vote.clone().into()),
18344 _ => Err(ParseError::MissingGameEventValue {
18345 ty: "PlayerNextMapVoteChange",
18346 field: "todo".into(),
18347 }),
18348 }
18349 }
18350 #[allow(unused_variables)]
18351 fn write(
18352 &self,
18353 stream: &mut BitWriteStream<LittleEndian>,
18354 definition: &GameEventDefinition,
18355 ) -> Result<()> {
18356 for entry in &definition.entries {
18357 let value = self
18358 .get_field(entry)
18359 .unwrap_or_else(|_| entry.kind.default_value());
18360 stream.write(&value)?;
18361 }
18362 Ok(())
18363 }
18364}
18365#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18366#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18367pub struct VoteMapsChangedEvent {}
18368impl VoteMapsChangedEvent {
18369 #[allow(unused_variables)]
18370 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18371 Ok(VoteMapsChangedEvent {})
18372 }
18373 #[allow(unused_variables)]
18374 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18375 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18376 match field.hash {
18377 _ => Err(ParseError::MissingGameEventValue {
18378 ty: "VoteMapsChanged",
18379 field: "todo".into(),
18380 }),
18381 }
18382 }
18383 #[allow(unused_variables)]
18384 fn write(
18385 &self,
18386 stream: &mut BitWriteStream<LittleEndian>,
18387 definition: &GameEventDefinition,
18388 ) -> Result<()> {
18389 for entry in &definition.entries {
18390 let value = self
18391 .get_field(entry)
18392 .unwrap_or_else(|_| entry.kind.default_value());
18393 stream.write(&value)?;
18394 }
18395 Ok(())
18396 }
18397}
18398#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18399#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18400pub struct ProtoDefChangedEvent {
18401 pub kind: u8,
18402 pub definition_index: u32,
18403 pub created: bool,
18404 pub deleted: bool,
18405 pub erase_history: bool,
18406}
18407impl ProtoDefChangedEvent {
18408 #[allow(unused_variables)]
18409 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18410 Ok(ProtoDefChangedEvent {
18411 kind: read_value::<u8>(
18412 stream,
18413 definition.get_entry(12075340201627130925u64),
18414 "kind",
18415 )?,
18416 definition_index: read_value::<u32>(
18417 stream,
18418 definition.get_entry(13641141875887813064u64),
18419 "definition_index",
18420 )?,
18421 created: read_value::<bool>(
18422 stream,
18423 definition.get_entry(16258158586571091195u64),
18424 "created",
18425 )?,
18426 deleted: read_value::<bool>(
18427 stream,
18428 definition.get_entry(2244448350166952426u64),
18429 "deleted",
18430 )?,
18431 erase_history: read_value::<bool>(
18432 stream,
18433 definition.get_entry(7145567783783222582u64),
18434 "erase_history",
18435 )?,
18436 })
18437 }
18438 #[allow(unused_variables)]
18439 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18440 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18441 match field.hash {
18442 12075340201627130925u64 => Ok(self.kind.clone().into()),
18443 13641141875887813064u64 => Ok(self.definition_index.clone().into()),
18444 16258158586571091195u64 => Ok(self.created.clone().into()),
18445 2244448350166952426u64 => Ok(self.deleted.clone().into()),
18446 7145567783783222582u64 => Ok(self.erase_history.clone().into()),
18447 _ => Err(ParseError::MissingGameEventValue {
18448 ty: "ProtoDefChanged",
18449 field: "todo".into(),
18450 }),
18451 }
18452 }
18453 #[allow(unused_variables)]
18454 fn write(
18455 &self,
18456 stream: &mut BitWriteStream<LittleEndian>,
18457 definition: &GameEventDefinition,
18458 ) -> Result<()> {
18459 for entry in &definition.entries {
18460 let value = self
18461 .get_field(entry)
18462 .unwrap_or_else(|_| entry.kind.default_value());
18463 stream.write(&value)?;
18464 }
18465 Ok(())
18466 }
18467}
18468#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18469#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18470pub struct PlayerDominationEvent {
18471 pub dominator: u16,
18472 pub dominated: u16,
18473 pub dominations: u16,
18474}
18475impl PlayerDominationEvent {
18476 #[allow(unused_variables)]
18477 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18478 Ok(PlayerDominationEvent {
18479 dominator: read_value::<u16>(
18480 stream,
18481 definition.get_entry(738416687693650492u64),
18482 "dominator",
18483 )?,
18484 dominated: read_value::<u16>(
18485 stream,
18486 definition.get_entry(744074774531288948u64),
18487 "dominated",
18488 )?,
18489 dominations: read_value::<u16>(
18490 stream,
18491 definition.get_entry(14151598225611438354u64),
18492 "dominations",
18493 )?,
18494 })
18495 }
18496 #[allow(unused_variables)]
18497 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18498 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18499 match field.hash {
18500 738416687693650492u64 => Ok(self.dominator.clone().into()),
18501 744074774531288948u64 => Ok(self.dominated.clone().into()),
18502 14151598225611438354u64 => Ok(self.dominations.clone().into()),
18503 _ => Err(ParseError::MissingGameEventValue {
18504 ty: "PlayerDomination",
18505 field: "todo".into(),
18506 }),
18507 }
18508 }
18509 #[allow(unused_variables)]
18510 fn write(
18511 &self,
18512 stream: &mut BitWriteStream<LittleEndian>,
18513 definition: &GameEventDefinition,
18514 ) -> Result<()> {
18515 for entry in &definition.entries {
18516 let value = self
18517 .get_field(entry)
18518 .unwrap_or_else(|_| entry.kind.default_value());
18519 stream.write(&value)?;
18520 }
18521 Ok(())
18522 }
18523}
18524#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18525#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18526pub struct PlayerRocketPackPushedEvent {
18527 pub pusher: u16,
18528 pub pushed: u16,
18529}
18530impl PlayerRocketPackPushedEvent {
18531 #[allow(unused_variables)]
18532 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18533 Ok(PlayerRocketPackPushedEvent {
18534 pusher: read_value::<u16>(
18535 stream,
18536 definition.get_entry(16364632941784438830u64),
18537 "pusher",
18538 )?,
18539 pushed: read_value::<u16>(
18540 stream,
18541 definition.get_entry(16364617548621643876u64),
18542 "pushed",
18543 )?,
18544 })
18545 }
18546 #[allow(unused_variables)]
18547 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18548 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18549 match field.hash {
18550 16364632941784438830u64 => Ok(self.pusher.clone().into()),
18551 16364617548621643876u64 => Ok(self.pushed.clone().into()),
18552 _ => Err(ParseError::MissingGameEventValue {
18553 ty: "PlayerRocketPackPushed",
18554 field: "todo".into(),
18555 }),
18556 }
18557 }
18558 #[allow(unused_variables)]
18559 fn write(
18560 &self,
18561 stream: &mut BitWriteStream<LittleEndian>,
18562 definition: &GameEventDefinition,
18563 ) -> Result<()> {
18564 for entry in &definition.entries {
18565 let value = self
18566 .get_field(entry)
18567 .unwrap_or_else(|_| entry.kind.default_value());
18568 stream.write(&value)?;
18569 }
18570 Ok(())
18571 }
18572}
18573#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18574#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18575pub struct QuestRequestEvent {
18576 pub request: u32,
18577 pub msg: MaybeUtf8String,
18578}
18579impl QuestRequestEvent {
18580 #[allow(unused_variables)]
18581 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18582 Ok(QuestRequestEvent {
18583 request: read_value::<u32>(
18584 stream,
18585 definition.get_entry(8018452122269601458u64),
18586 "request",
18587 )?,
18588 msg: read_value::<MaybeUtf8String>(
18589 stream,
18590 definition.get_entry(567552616859811458u64),
18591 "msg",
18592 )?,
18593 })
18594 }
18595 #[allow(unused_variables)]
18596 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18597 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18598 match field.hash {
18599 8018452122269601458u64 => Ok(self.request.clone().into()),
18600 567552616859811458u64 => Ok(self.msg.clone().into()),
18601 _ => Err(ParseError::MissingGameEventValue {
18602 ty: "QuestRequest",
18603 field: "todo".into(),
18604 }),
18605 }
18606 }
18607 #[allow(unused_variables)]
18608 fn write(
18609 &self,
18610 stream: &mut BitWriteStream<LittleEndian>,
18611 definition: &GameEventDefinition,
18612 ) -> Result<()> {
18613 for entry in &definition.entries {
18614 let value = self
18615 .get_field(entry)
18616 .unwrap_or_else(|_| entry.kind.default_value());
18617 stream.write(&value)?;
18618 }
18619 Ok(())
18620 }
18621}
18622#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18623#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18624pub struct QuestResponseEvent {
18625 pub request: u32,
18626 pub success: bool,
18627 pub msg: MaybeUtf8String,
18628}
18629impl QuestResponseEvent {
18630 #[allow(unused_variables)]
18631 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18632 Ok(QuestResponseEvent {
18633 request: read_value::<u32>(
18634 stream,
18635 definition.get_entry(8018452122269601458u64),
18636 "request",
18637 )?,
18638 success: read_value::<bool>(
18639 stream,
18640 definition.get_entry(1872942068143117264u64),
18641 "success",
18642 )?,
18643 msg: read_value::<MaybeUtf8String>(
18644 stream,
18645 definition.get_entry(567552616859811458u64),
18646 "msg",
18647 )?,
18648 })
18649 }
18650 #[allow(unused_variables)]
18651 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18652 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18653 match field.hash {
18654 8018452122269601458u64 => Ok(self.request.clone().into()),
18655 1872942068143117264u64 => Ok(self.success.clone().into()),
18656 567552616859811458u64 => Ok(self.msg.clone().into()),
18657 _ => Err(ParseError::MissingGameEventValue {
18658 ty: "QuestResponse",
18659 field: "todo".into(),
18660 }),
18661 }
18662 }
18663 #[allow(unused_variables)]
18664 fn write(
18665 &self,
18666 stream: &mut BitWriteStream<LittleEndian>,
18667 definition: &GameEventDefinition,
18668 ) -> Result<()> {
18669 for entry in &definition.entries {
18670 let value = self
18671 .get_field(entry)
18672 .unwrap_or_else(|_| entry.kind.default_value());
18673 stream.write(&value)?;
18674 }
18675 Ok(())
18676 }
18677}
18678#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18679#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18680pub struct QuestProgressEvent {
18681 pub owner: u16,
18682 pub scorer: u16,
18683 pub kind: u8,
18684 pub completed: bool,
18685 pub quest_definition_index: u32,
18686}
18687impl QuestProgressEvent {
18688 #[allow(unused_variables)]
18689 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18690 Ok(QuestProgressEvent {
18691 owner: read_value::<u16>(
18692 stream,
18693 definition.get_entry(12002927925776846068u64),
18694 "owner",
18695 )?,
18696 scorer: read_value::<u16>(
18697 stream,
18698 definition.get_entry(114960585656897893u64),
18699 "scorer",
18700 )?,
18701 kind: read_value::<u8>(
18702 stream,
18703 definition.get_entry(12075340201627130925u64),
18704 "kind",
18705 )?,
18706 completed: read_value::<bool>(
18707 stream,
18708 definition.get_entry(18293112347497300626u64),
18709 "completed",
18710 )?,
18711 quest_definition_index: read_value::<u32>(
18712 stream,
18713 definition.get_entry(16190323556600580467u64),
18714 "quest_definition_index",
18715 )?,
18716 })
18717 }
18718 #[allow(unused_variables)]
18719 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18720 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18721 match field.hash {
18722 12002927925776846068u64 => Ok(self.owner.clone().into()),
18723 114960585656897893u64 => Ok(self.scorer.clone().into()),
18724 12075340201627130925u64 => Ok(self.kind.clone().into()),
18725 18293112347497300626u64 => Ok(self.completed.clone().into()),
18726 16190323556600580467u64 => Ok(self.quest_definition_index.clone().into()),
18727 _ => Err(ParseError::MissingGameEventValue {
18728 ty: "QuestProgress",
18729 field: "todo".into(),
18730 }),
18731 }
18732 }
18733 #[allow(unused_variables)]
18734 fn write(
18735 &self,
18736 stream: &mut BitWriteStream<LittleEndian>,
18737 definition: &GameEventDefinition,
18738 ) -> Result<()> {
18739 for entry in &definition.entries {
18740 let value = self
18741 .get_field(entry)
18742 .unwrap_or_else(|_| entry.kind.default_value());
18743 stream.write(&value)?;
18744 }
18745 Ok(())
18746 }
18747}
18748#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18749#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18750pub struct ProjectileRemovedEvent {
18751 pub attacker: u8,
18752 pub weapon_def_index: u32,
18753 pub num_hit: u8,
18754 pub num_direct_hit: u8,
18755}
18756impl ProjectileRemovedEvent {
18757 #[allow(unused_variables)]
18758 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18759 Ok(ProjectileRemovedEvent {
18760 attacker: read_value::<u8>(
18761 stream,
18762 definition.get_entry(7198542740550218478u64),
18763 "attacker",
18764 )?,
18765 weapon_def_index: read_value::<u32>(
18766 stream,
18767 definition.get_entry(4132306594868589054u64),
18768 "weapon_def_index",
18769 )?,
18770 num_hit: read_value::<u8>(
18771 stream,
18772 definition.get_entry(12553580167082885753u64),
18773 "num_hit",
18774 )?,
18775 num_direct_hit: read_value::<u8>(
18776 stream,
18777 definition.get_entry(8604189910367298615u64),
18778 "num_direct_hit",
18779 )?,
18780 })
18781 }
18782 #[allow(unused_variables)]
18783 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18784 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18785 match field.hash {
18786 7198542740550218478u64 => Ok(self.attacker.clone().into()),
18787 4132306594868589054u64 => Ok(self.weapon_def_index.clone().into()),
18788 12553580167082885753u64 => Ok(self.num_hit.clone().into()),
18789 8604189910367298615u64 => Ok(self.num_direct_hit.clone().into()),
18790 _ => Err(ParseError::MissingGameEventValue {
18791 ty: "ProjectileRemoved",
18792 field: "todo".into(),
18793 }),
18794 }
18795 }
18796 #[allow(unused_variables)]
18797 fn write(
18798 &self,
18799 stream: &mut BitWriteStream<LittleEndian>,
18800 definition: &GameEventDefinition,
18801 ) -> Result<()> {
18802 for entry in &definition.entries {
18803 let value = self
18804 .get_field(entry)
18805 .unwrap_or_else(|_| entry.kind.default_value());
18806 stream.write(&value)?;
18807 }
18808 Ok(())
18809 }
18810}
18811#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18812#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18813pub struct QuestMapDataChangedEvent {}
18814impl QuestMapDataChangedEvent {
18815 #[allow(unused_variables)]
18816 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18817 Ok(QuestMapDataChangedEvent {})
18818 }
18819 #[allow(unused_variables)]
18820 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18821 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18822 match field.hash {
18823 _ => Err(ParseError::MissingGameEventValue {
18824 ty: "QuestMapDataChanged",
18825 field: "todo".into(),
18826 }),
18827 }
18828 }
18829 #[allow(unused_variables)]
18830 fn write(
18831 &self,
18832 stream: &mut BitWriteStream<LittleEndian>,
18833 definition: &GameEventDefinition,
18834 ) -> Result<()> {
18835 for entry in &definition.entries {
18836 let value = self
18837 .get_field(entry)
18838 .unwrap_or_else(|_| entry.kind.default_value());
18839 stream.write(&value)?;
18840 }
18841 Ok(())
18842 }
18843}
18844#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18845#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18846pub struct GasDousedPlayerIgnitedEvent {
18847 pub igniter: u16,
18848 pub douser: u16,
18849 pub victim: u16,
18850}
18851impl GasDousedPlayerIgnitedEvent {
18852 #[allow(unused_variables)]
18853 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18854 Ok(GasDousedPlayerIgnitedEvent {
18855 igniter: read_value::<u16>(
18856 stream,
18857 definition.get_entry(9421640134696329943u64),
18858 "igniter",
18859 )?,
18860 douser: read_value::<u16>(
18861 stream,
18862 definition.get_entry(888696338692993559u64),
18863 "douser",
18864 )?,
18865 victim: read_value::<u16>(
18866 stream,
18867 definition.get_entry(3120917251440744469u64),
18868 "victim",
18869 )?,
18870 })
18871 }
18872 #[allow(unused_variables)]
18873 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18874 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18875 match field.hash {
18876 9421640134696329943u64 => Ok(self.igniter.clone().into()),
18877 888696338692993559u64 => Ok(self.douser.clone().into()),
18878 3120917251440744469u64 => Ok(self.victim.clone().into()),
18879 _ => Err(ParseError::MissingGameEventValue {
18880 ty: "GasDousedPlayerIgnited",
18881 field: "todo".into(),
18882 }),
18883 }
18884 }
18885 #[allow(unused_variables)]
18886 fn write(
18887 &self,
18888 stream: &mut BitWriteStream<LittleEndian>,
18889 definition: &GameEventDefinition,
18890 ) -> Result<()> {
18891 for entry in &definition.entries {
18892 let value = self
18893 .get_field(entry)
18894 .unwrap_or_else(|_| entry.kind.default_value());
18895 stream.write(&value)?;
18896 }
18897 Ok(())
18898 }
18899}
18900#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18901#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18902pub struct QuestTurnInStateEvent {
18903 pub state: u16,
18904}
18905impl QuestTurnInStateEvent {
18906 #[allow(unused_variables)]
18907 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18908 Ok(QuestTurnInStateEvent {
18909 state: read_value::<u16>(
18910 stream,
18911 definition.get_entry(17177761064896540950u64),
18912 "state",
18913 )?,
18914 })
18915 }
18916 #[allow(unused_variables)]
18917 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18918 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18919 match field.hash {
18920 17177761064896540950u64 => Ok(self.state.clone().into()),
18921 _ => Err(ParseError::MissingGameEventValue {
18922 ty: "QuestTurnInState",
18923 field: "todo".into(),
18924 }),
18925 }
18926 }
18927 #[allow(unused_variables)]
18928 fn write(
18929 &self,
18930 stream: &mut BitWriteStream<LittleEndian>,
18931 definition: &GameEventDefinition,
18932 ) -> Result<()> {
18933 for entry in &definition.entries {
18934 let value = self
18935 .get_field(entry)
18936 .unwrap_or_else(|_| entry.kind.default_value());
18937 stream.write(&value)?;
18938 }
18939 Ok(())
18940 }
18941}
18942#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18943#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18944pub struct ItemsAcknowledgedEvent {}
18945impl ItemsAcknowledgedEvent {
18946 #[allow(unused_variables)]
18947 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18948 Ok(ItemsAcknowledgedEvent {})
18949 }
18950 #[allow(unused_variables)]
18951 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18952 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
18953 match field.hash {
18954 _ => Err(ParseError::MissingGameEventValue {
18955 ty: "ItemsAcknowledged",
18956 field: "todo".into(),
18957 }),
18958 }
18959 }
18960 #[allow(unused_variables)]
18961 fn write(
18962 &self,
18963 stream: &mut BitWriteStream<LittleEndian>,
18964 definition: &GameEventDefinition,
18965 ) -> Result<()> {
18966 for entry in &definition.entries {
18967 let value = self
18968 .get_field(entry)
18969 .unwrap_or_else(|_| entry.kind.default_value());
18970 stream.write(&value)?;
18971 }
18972 Ok(())
18973 }
18974}
18975#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
18976#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
18977pub struct CapperKilledEvent {
18978 pub blocker: u16,
18979 pub victim: u16,
18980}
18981impl CapperKilledEvent {
18982 #[allow(unused_variables)]
18983 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
18984 Ok(CapperKilledEvent {
18985 blocker: read_value::<u16>(
18986 stream,
18987 definition.get_entry(9150196623075249301u64),
18988 "blocker",
18989 )?,
18990 victim: read_value::<u16>(
18991 stream,
18992 definition.get_entry(3120917251440744469u64),
18993 "victim",
18994 )?,
18995 })
18996 }
18997 #[allow(unused_variables)]
18998 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
18999 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19000 match field.hash {
19001 9150196623075249301u64 => Ok(self.blocker.clone().into()),
19002 3120917251440744469u64 => Ok(self.victim.clone().into()),
19003 _ => Err(ParseError::MissingGameEventValue {
19004 ty: "CapperKilled",
19005 field: "todo".into(),
19006 }),
19007 }
19008 }
19009 #[allow(unused_variables)]
19010 fn write(
19011 &self,
19012 stream: &mut BitWriteStream<LittleEndian>,
19013 definition: &GameEventDefinition,
19014 ) -> Result<()> {
19015 for entry in &definition.entries {
19016 let value = self
19017 .get_field(entry)
19018 .unwrap_or_else(|_| entry.kind.default_value());
19019 stream.write(&value)?;
19020 }
19021 Ok(())
19022 }
19023}
19024#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19025#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19026pub struct MainMenuStabilizedEvent {}
19027impl MainMenuStabilizedEvent {
19028 #[allow(unused_variables)]
19029 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19030 Ok(MainMenuStabilizedEvent {})
19031 }
19032 #[allow(unused_variables)]
19033 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19034 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19035 match field.hash {
19036 _ => Err(ParseError::MissingGameEventValue {
19037 ty: "MainMenuStabilized",
19038 field: "todo".into(),
19039 }),
19040 }
19041 }
19042 #[allow(unused_variables)]
19043 fn write(
19044 &self,
19045 stream: &mut BitWriteStream<LittleEndian>,
19046 definition: &GameEventDefinition,
19047 ) -> Result<()> {
19048 for entry in &definition.entries {
19049 let value = self
19050 .get_field(entry)
19051 .unwrap_or_else(|_| entry.kind.default_value());
19052 stream.write(&value)?;
19053 }
19054 Ok(())
19055 }
19056}
19057#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19058#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19059pub struct WorldStatusChangedEvent {}
19060impl WorldStatusChangedEvent {
19061 #[allow(unused_variables)]
19062 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19063 Ok(WorldStatusChangedEvent {})
19064 }
19065 #[allow(unused_variables)]
19066 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19067 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19068 match field.hash {
19069 _ => Err(ParseError::MissingGameEventValue {
19070 ty: "WorldStatusChanged",
19071 field: "todo".into(),
19072 }),
19073 }
19074 }
19075 #[allow(unused_variables)]
19076 fn write(
19077 &self,
19078 stream: &mut BitWriteStream<LittleEndian>,
19079 definition: &GameEventDefinition,
19080 ) -> Result<()> {
19081 for entry in &definition.entries {
19082 let value = self
19083 .get_field(entry)
19084 .unwrap_or_else(|_| entry.kind.default_value());
19085 stream.write(&value)?;
19086 }
19087 Ok(())
19088 }
19089}
19090#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19091#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19092pub struct HLTVStatusEvent {
19093 pub clients: u32,
19094 pub slots: u32,
19095 pub proxies: u16,
19096 pub master: MaybeUtf8String,
19097}
19098impl HLTVStatusEvent {
19099 #[allow(unused_variables)]
19100 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19101 Ok(HLTVStatusEvent {
19102 clients: read_value::<u32>(
19103 stream,
19104 definition.get_entry(7649887508575031031u64),
19105 "clients",
19106 )?,
19107 slots: read_value::<u32>(
19108 stream,
19109 definition.get_entry(16612704165544482374u64),
19110 "slots",
19111 )?,
19112 proxies: read_value::<u16>(
19113 stream,
19114 definition.get_entry(15307552237670760667u64),
19115 "proxies",
19116 )?,
19117 master: read_value::<MaybeUtf8String>(
19118 stream,
19119 definition.get_entry(17259658682407053043u64),
19120 "master",
19121 )?,
19122 })
19123 }
19124 #[allow(unused_variables)]
19125 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19126 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19127 match field.hash {
19128 7649887508575031031u64 => Ok(self.clients.clone().into()),
19129 16612704165544482374u64 => Ok(self.slots.clone().into()),
19130 15307552237670760667u64 => Ok(self.proxies.clone().into()),
19131 17259658682407053043u64 => Ok(self.master.clone().into()),
19132 _ => Err(ParseError::MissingGameEventValue {
19133 ty: "HLTVStatus",
19134 field: "todo".into(),
19135 }),
19136 }
19137 }
19138 #[allow(unused_variables)]
19139 fn write(
19140 &self,
19141 stream: &mut BitWriteStream<LittleEndian>,
19142 definition: &GameEventDefinition,
19143 ) -> Result<()> {
19144 for entry in &definition.entries {
19145 let value = self
19146 .get_field(entry)
19147 .unwrap_or_else(|_| entry.kind.default_value());
19148 stream.write(&value)?;
19149 }
19150 Ok(())
19151 }
19152}
19153#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19154#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19155pub struct HLTVCameramanEvent {
19156 pub index: u16,
19157}
19158impl HLTVCameramanEvent {
19159 #[allow(unused_variables)]
19160 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19161 Ok(HLTVCameramanEvent {
19162 index: read_value::<u16>(
19163 stream,
19164 definition.get_entry(9497966886403524235u64),
19165 "index",
19166 )?,
19167 })
19168 }
19169 #[allow(unused_variables)]
19170 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19171 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19172 match field.hash {
19173 9497966886403524235u64 => Ok(self.index.clone().into()),
19174 _ => Err(ParseError::MissingGameEventValue {
19175 ty: "HLTVCameraman",
19176 field: "todo".into(),
19177 }),
19178 }
19179 }
19180 #[allow(unused_variables)]
19181 fn write(
19182 &self,
19183 stream: &mut BitWriteStream<LittleEndian>,
19184 definition: &GameEventDefinition,
19185 ) -> Result<()> {
19186 for entry in &definition.entries {
19187 let value = self
19188 .get_field(entry)
19189 .unwrap_or_else(|_| entry.kind.default_value());
19190 stream.write(&value)?;
19191 }
19192 Ok(())
19193 }
19194}
19195#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19196#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19197pub struct HLTVRankCameraEvent {
19198 pub index: u8,
19199 pub rank: f32,
19200 pub target: u16,
19201}
19202impl HLTVRankCameraEvent {
19203 #[allow(unused_variables)]
19204 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19205 Ok(HLTVRankCameraEvent {
19206 index: read_value::<u8>(
19207 stream,
19208 definition.get_entry(9497966886403524235u64),
19209 "index",
19210 )?,
19211 rank: read_value::<f32>(stream, definition.get_entry(7904697092003280967u64), "rank")?,
19212 target: read_value::<u16>(
19213 stream,
19214 definition.get_entry(1653916590517707752u64),
19215 "target",
19216 )?,
19217 })
19218 }
19219 #[allow(unused_variables)]
19220 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19221 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19222 match field.hash {
19223 9497966886403524235u64 => Ok(self.index.clone().into()),
19224 7904697092003280967u64 => Ok(self.rank.clone().into()),
19225 1653916590517707752u64 => Ok(self.target.clone().into()),
19226 _ => Err(ParseError::MissingGameEventValue {
19227 ty: "HLTVRankCamera",
19228 field: "todo".into(),
19229 }),
19230 }
19231 }
19232 #[allow(unused_variables)]
19233 fn write(
19234 &self,
19235 stream: &mut BitWriteStream<LittleEndian>,
19236 definition: &GameEventDefinition,
19237 ) -> Result<()> {
19238 for entry in &definition.entries {
19239 let value = self
19240 .get_field(entry)
19241 .unwrap_or_else(|_| entry.kind.default_value());
19242 stream.write(&value)?;
19243 }
19244 Ok(())
19245 }
19246}
19247#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19248#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19249pub struct HLTVRankEntityEvent {
19250 pub index: u16,
19251 pub rank: f32,
19252 pub target: u16,
19253}
19254impl HLTVRankEntityEvent {
19255 #[allow(unused_variables)]
19256 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19257 Ok(HLTVRankEntityEvent {
19258 index: read_value::<u16>(
19259 stream,
19260 definition.get_entry(9497966886403524235u64),
19261 "index",
19262 )?,
19263 rank: read_value::<f32>(stream, definition.get_entry(7904697092003280967u64), "rank")?,
19264 target: read_value::<u16>(
19265 stream,
19266 definition.get_entry(1653916590517707752u64),
19267 "target",
19268 )?,
19269 })
19270 }
19271 #[allow(unused_variables)]
19272 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19273 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19274 match field.hash {
19275 9497966886403524235u64 => Ok(self.index.clone().into()),
19276 7904697092003280967u64 => Ok(self.rank.clone().into()),
19277 1653916590517707752u64 => Ok(self.target.clone().into()),
19278 _ => Err(ParseError::MissingGameEventValue {
19279 ty: "HLTVRankEntity",
19280 field: "todo".into(),
19281 }),
19282 }
19283 }
19284 #[allow(unused_variables)]
19285 fn write(
19286 &self,
19287 stream: &mut BitWriteStream<LittleEndian>,
19288 definition: &GameEventDefinition,
19289 ) -> Result<()> {
19290 for entry in &definition.entries {
19291 let value = self
19292 .get_field(entry)
19293 .unwrap_or_else(|_| entry.kind.default_value());
19294 stream.write(&value)?;
19295 }
19296 Ok(())
19297 }
19298}
19299#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19300#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19301pub struct HLTVFixedEvent {
19302 pub pos_x: u32,
19303 pub pos_y: u32,
19304 pub pos_z: u32,
19305 pub theta: u16,
19306 pub phi: u16,
19307 pub offset: u16,
19308 pub fov: f32,
19309 pub target: u16,
19310}
19311impl HLTVFixedEvent {
19312 #[allow(unused_variables)]
19313 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19314 Ok(HLTVFixedEvent {
19315 pos_x: read_value::<u32>(
19316 stream,
19317 definition.get_entry(10101535539947993315u64),
19318 "pos_x",
19319 )?,
19320 pos_y: read_value::<u32>(
19321 stream,
19322 definition.get_entry(10101534440436365104u64),
19323 "pos_y",
19324 )?,
19325 pos_z: read_value::<u32>(
19326 stream,
19327 definition.get_entry(10101537738971249737u64),
19328 "pos_z",
19329 )?,
19330 theta: read_value::<u16>(
19331 stream,
19332 definition.get_entry(16923039152111475483u64),
19333 "theta",
19334 )?,
19335 phi: read_value::<u16>(stream, definition.get_entry(8625054201726242788u64), "phi")?,
19336 offset: read_value::<u16>(
19337 stream,
19338 definition.get_entry(173583165163845066u64),
19339 "offset",
19340 )?,
19341 fov: read_value::<f32>(stream, definition.get_entry(15902909680995393884u64), "fov")?,
19342 target: read_value::<u16>(
19343 stream,
19344 definition.get_entry(1653916590517707752u64),
19345 "target",
19346 )?,
19347 })
19348 }
19349 #[allow(unused_variables)]
19350 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19351 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19352 match field.hash {
19353 10101535539947993315u64 => Ok(self.pos_x.clone().into()),
19354 10101534440436365104u64 => Ok(self.pos_y.clone().into()),
19355 10101537738971249737u64 => Ok(self.pos_z.clone().into()),
19356 16923039152111475483u64 => Ok(self.theta.clone().into()),
19357 8625054201726242788u64 => Ok(self.phi.clone().into()),
19358 173583165163845066u64 => Ok(self.offset.clone().into()),
19359 15902909680995393884u64 => Ok(self.fov.clone().into()),
19360 1653916590517707752u64 => Ok(self.target.clone().into()),
19361 _ => Err(ParseError::MissingGameEventValue {
19362 ty: "HLTVFixed",
19363 field: "todo".into(),
19364 }),
19365 }
19366 }
19367 #[allow(unused_variables)]
19368 fn write(
19369 &self,
19370 stream: &mut BitWriteStream<LittleEndian>,
19371 definition: &GameEventDefinition,
19372 ) -> Result<()> {
19373 for entry in &definition.entries {
19374 let value = self
19375 .get_field(entry)
19376 .unwrap_or_else(|_| entry.kind.default_value());
19377 stream.write(&value)?;
19378 }
19379 Ok(())
19380 }
19381}
19382#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19383#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19384pub struct HLTVChaseEvent {
19385 pub target_1: u16,
19386 pub target_2: u16,
19387 pub distance: u16,
19388 pub theta: u16,
19389 pub phi: u16,
19390 pub inertia: u8,
19391 pub in_eye: u8,
19392}
19393impl HLTVChaseEvent {
19394 #[allow(unused_variables)]
19395 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19396 Ok(HLTVChaseEvent {
19397 target_1: read_value::<u16>(
19398 stream,
19399 definition.get_entry(17244538795293747643u64),
19400 "target_1",
19401 )?,
19402 target_2: read_value::<u16>(
19403 stream,
19404 definition.get_entry(17244539894805375854u64),
19405 "target_2",
19406 )?,
19407 distance: read_value::<u16>(
19408 stream,
19409 definition.get_entry(15956180055569954882u64),
19410 "distance",
19411 )?,
19412 theta: read_value::<u16>(
19413 stream,
19414 definition.get_entry(16923039152111475483u64),
19415 "theta",
19416 )?,
19417 phi: read_value::<u16>(stream, definition.get_entry(8625054201726242788u64), "phi")?,
19418 inertia: read_value::<u8>(
19419 stream,
19420 definition.get_entry(16127751084747526033u64),
19421 "inertia",
19422 )?,
19423 in_eye: read_value::<u8>(
19424 stream,
19425 definition.get_entry(10269529380097519287u64),
19426 "in_eye",
19427 )?,
19428 })
19429 }
19430 #[allow(unused_variables)]
19431 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19432 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19433 match field.hash {
19434 17244538795293747643u64 => Ok(self.target_1.clone().into()),
19435 17244539894805375854u64 => Ok(self.target_2.clone().into()),
19436 15956180055569954882u64 => Ok(self.distance.clone().into()),
19437 16923039152111475483u64 => Ok(self.theta.clone().into()),
19438 8625054201726242788u64 => Ok(self.phi.clone().into()),
19439 16127751084747526033u64 => Ok(self.inertia.clone().into()),
19440 10269529380097519287u64 => Ok(self.in_eye.clone().into()),
19441 _ => Err(ParseError::MissingGameEventValue {
19442 ty: "HLTVChase",
19443 field: "todo".into(),
19444 }),
19445 }
19446 }
19447 #[allow(unused_variables)]
19448 fn write(
19449 &self,
19450 stream: &mut BitWriteStream<LittleEndian>,
19451 definition: &GameEventDefinition,
19452 ) -> Result<()> {
19453 for entry in &definition.entries {
19454 let value = self
19455 .get_field(entry)
19456 .unwrap_or_else(|_| entry.kind.default_value());
19457 stream.write(&value)?;
19458 }
19459 Ok(())
19460 }
19461}
19462#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19463#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19464pub struct HLTVMessageEvent {
19465 pub text: MaybeUtf8String,
19466}
19467impl HLTVMessageEvent {
19468 #[allow(unused_variables)]
19469 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19470 Ok(HLTVMessageEvent {
19471 text: read_value::<MaybeUtf8String>(
19472 stream,
19473 definition.get_entry(18015793717152399486u64),
19474 "text",
19475 )?,
19476 })
19477 }
19478 #[allow(unused_variables)]
19479 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19480 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19481 match field.hash {
19482 18015793717152399486u64 => Ok(self.text.clone().into()),
19483 _ => Err(ParseError::MissingGameEventValue {
19484 ty: "HLTVMessage",
19485 field: "todo".into(),
19486 }),
19487 }
19488 }
19489 #[allow(unused_variables)]
19490 fn write(
19491 &self,
19492 stream: &mut BitWriteStream<LittleEndian>,
19493 definition: &GameEventDefinition,
19494 ) -> Result<()> {
19495 for entry in &definition.entries {
19496 let value = self
19497 .get_field(entry)
19498 .unwrap_or_else(|_| entry.kind.default_value());
19499 stream.write(&value)?;
19500 }
19501 Ok(())
19502 }
19503}
19504#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19505#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19506pub struct HLTVTitleEvent {
19507 pub text: MaybeUtf8String,
19508}
19509impl HLTVTitleEvent {
19510 #[allow(unused_variables)]
19511 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19512 Ok(HLTVTitleEvent {
19513 text: read_value::<MaybeUtf8String>(
19514 stream,
19515 definition.get_entry(18015793717152399486u64),
19516 "text",
19517 )?,
19518 })
19519 }
19520 #[allow(unused_variables)]
19521 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19522 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19523 match field.hash {
19524 18015793717152399486u64 => Ok(self.text.clone().into()),
19525 _ => Err(ParseError::MissingGameEventValue {
19526 ty: "HLTVTitle",
19527 field: "todo".into(),
19528 }),
19529 }
19530 }
19531 #[allow(unused_variables)]
19532 fn write(
19533 &self,
19534 stream: &mut BitWriteStream<LittleEndian>,
19535 definition: &GameEventDefinition,
19536 ) -> Result<()> {
19537 for entry in &definition.entries {
19538 let value = self
19539 .get_field(entry)
19540 .unwrap_or_else(|_| entry.kind.default_value());
19541 stream.write(&value)?;
19542 }
19543 Ok(())
19544 }
19545}
19546#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19547#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19548pub struct HLTVChatEvent {
19549 pub text: MaybeUtf8String,
19550}
19551impl HLTVChatEvent {
19552 #[allow(unused_variables)]
19553 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19554 Ok(HLTVChatEvent {
19555 text: read_value::<MaybeUtf8String>(
19556 stream,
19557 definition.get_entry(18015793717152399486u64),
19558 "text",
19559 )?,
19560 })
19561 }
19562 #[allow(unused_variables)]
19563 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19564 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19565 match field.hash {
19566 18015793717152399486u64 => Ok(self.text.clone().into()),
19567 _ => Err(ParseError::MissingGameEventValue {
19568 ty: "HLTVChat",
19569 field: "todo".into(),
19570 }),
19571 }
19572 }
19573 #[allow(unused_variables)]
19574 fn write(
19575 &self,
19576 stream: &mut BitWriteStream<LittleEndian>,
19577 definition: &GameEventDefinition,
19578 ) -> Result<()> {
19579 for entry in &definition.entries {
19580 let value = self
19581 .get_field(entry)
19582 .unwrap_or_else(|_| entry.kind.default_value());
19583 stream.write(&value)?;
19584 }
19585 Ok(())
19586 }
19587}
19588#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19589#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19590pub struct ReplayStartRecordEvent {}
19591impl ReplayStartRecordEvent {
19592 #[allow(unused_variables)]
19593 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19594 Ok(ReplayStartRecordEvent {})
19595 }
19596 #[allow(unused_variables)]
19597 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19598 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19599 match field.hash {
19600 _ => Err(ParseError::MissingGameEventValue {
19601 ty: "ReplayStartRecord",
19602 field: "todo".into(),
19603 }),
19604 }
19605 }
19606 #[allow(unused_variables)]
19607 fn write(
19608 &self,
19609 stream: &mut BitWriteStream<LittleEndian>,
19610 definition: &GameEventDefinition,
19611 ) -> Result<()> {
19612 for entry in &definition.entries {
19613 let value = self
19614 .get_field(entry)
19615 .unwrap_or_else(|_| entry.kind.default_value());
19616 stream.write(&value)?;
19617 }
19618 Ok(())
19619 }
19620}
19621#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19622#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19623pub struct ReplaySessionInfoEvent {
19624 pub sn: MaybeUtf8String,
19625 pub di: u8,
19626 pub cb: u32,
19627 pub st: u32,
19628}
19629impl ReplaySessionInfoEvent {
19630 #[allow(unused_variables)]
19631 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19632 Ok(ReplaySessionInfoEvent {
19633 sn: read_value::<MaybeUtf8String>(
19634 stream,
19635 definition.get_entry(637602428010181156u64),
19636 "sn",
19637 )?,
19638 di: read_value::<u8>(stream, definition.get_entry(617370314543444270u64), "di")?,
19639 cb: read_value::<u32>(stream, definition.get_entry(622143294520562096u64), "cb")?,
19640 st: read_value::<u32>(stream, definition.get_entry(637613423126463266u64), "st")?,
19641 })
19642 }
19643 #[allow(unused_variables)]
19644 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19645 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19646 match field.hash {
19647 637602428010181156u64 => Ok(self.sn.clone().into()),
19648 617370314543444270u64 => Ok(self.di.clone().into()),
19649 622143294520562096u64 => Ok(self.cb.clone().into()),
19650 637613423126463266u64 => Ok(self.st.clone().into()),
19651 _ => Err(ParseError::MissingGameEventValue {
19652 ty: "ReplaySessionInfo",
19653 field: "todo".into(),
19654 }),
19655 }
19656 }
19657 #[allow(unused_variables)]
19658 fn write(
19659 &self,
19660 stream: &mut BitWriteStream<LittleEndian>,
19661 definition: &GameEventDefinition,
19662 ) -> Result<()> {
19663 for entry in &definition.entries {
19664 let value = self
19665 .get_field(entry)
19666 .unwrap_or_else(|_| entry.kind.default_value());
19667 stream.write(&value)?;
19668 }
19669 Ok(())
19670 }
19671}
19672#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19673#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19674pub struct ReplayEndRecordEvent {}
19675impl ReplayEndRecordEvent {
19676 #[allow(unused_variables)]
19677 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19678 Ok(ReplayEndRecordEvent {})
19679 }
19680 #[allow(unused_variables)]
19681 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19682 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19683 match field.hash {
19684 _ => Err(ParseError::MissingGameEventValue {
19685 ty: "ReplayEndRecord",
19686 field: "todo".into(),
19687 }),
19688 }
19689 }
19690 #[allow(unused_variables)]
19691 fn write(
19692 &self,
19693 stream: &mut BitWriteStream<LittleEndian>,
19694 definition: &GameEventDefinition,
19695 ) -> Result<()> {
19696 for entry in &definition.entries {
19697 let value = self
19698 .get_field(entry)
19699 .unwrap_or_else(|_| entry.kind.default_value());
19700 stream.write(&value)?;
19701 }
19702 Ok(())
19703 }
19704}
19705#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19706#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19707pub struct ReplayReplaysAvailableEvent {}
19708impl ReplayReplaysAvailableEvent {
19709 #[allow(unused_variables)]
19710 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19711 Ok(ReplayReplaysAvailableEvent {})
19712 }
19713 #[allow(unused_variables)]
19714 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19715 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19716 match field.hash {
19717 _ => Err(ParseError::MissingGameEventValue {
19718 ty: "ReplayReplaysAvailable",
19719 field: "todo".into(),
19720 }),
19721 }
19722 }
19723 #[allow(unused_variables)]
19724 fn write(
19725 &self,
19726 stream: &mut BitWriteStream<LittleEndian>,
19727 definition: &GameEventDefinition,
19728 ) -> Result<()> {
19729 for entry in &definition.entries {
19730 let value = self
19731 .get_field(entry)
19732 .unwrap_or_else(|_| entry.kind.default_value());
19733 stream.write(&value)?;
19734 }
19735 Ok(())
19736 }
19737}
19738#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19739#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19740pub struct ReplayServerErrorEvent {
19741 pub error: MaybeUtf8String,
19742}
19743impl ReplayServerErrorEvent {
19744 #[allow(unused_variables)]
19745 fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
19746 Ok(ReplayServerErrorEvent {
19747 error: read_value::<MaybeUtf8String>(
19748 stream,
19749 definition.get_entry(11489899660447141169u64),
19750 "error",
19751 )?,
19752 })
19753 }
19754 #[allow(unused_variables)]
19755 fn get_field(&self, field: &GameEventEntry) -> Result<GameEventValue> {
19756 #[allow(clippy::clone_on_copy, clippy::match_single_binding)]
19757 match field.hash {
19758 11489899660447141169u64 => Ok(self.error.clone().into()),
19759 _ => Err(ParseError::MissingGameEventValue {
19760 ty: "ReplayServerError",
19761 field: "todo".into(),
19762 }),
19763 }
19764 }
19765 #[allow(unused_variables)]
19766 fn write(
19767 &self,
19768 stream: &mut BitWriteStream<LittleEndian>,
19769 definition: &GameEventDefinition,
19770 ) -> Result<()> {
19771 for entry in &definition.entries {
19772 let value = self
19773 .get_field(entry)
19774 .unwrap_or_else(|_| entry.kind.default_value());
19775 stream.write(&value)?;
19776 }
19777 Ok(())
19778 }
19779}
19780#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
19781#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
19782#[serde(tag = "type")]
19783pub enum GameEvent {
19784 ServerSpawn(Box<ServerSpawnEvent>),
19785 ServerChangeLevelFailed(ServerChangeLevelFailedEvent),
19786 ServerShutdown(ServerShutdownEvent),
19787 ServerCvar(ServerCvarEvent),
19788 ServerMessage(ServerMessageEvent),
19789 ServerAddBan(Box<ServerAddBanEvent>),
19790 ServerRemoveBan(ServerRemoveBanEvent),
19791 PlayerConnect(PlayerConnectEvent),
19792 PlayerConnectClient(PlayerConnectClientEvent),
19793 PlayerInfo(PlayerInfoEvent),
19794 PlayerDisconnect(PlayerDisconnectEvent),
19795 PlayerActivate(PlayerActivateEvent),
19796 PlayerSay(PlayerSayEvent),
19797 ClientDisconnect(ClientDisconnectEvent),
19798 ClientBeginConnect(ClientBeginConnectEvent),
19799 ClientConnected(ClientConnectedEvent),
19800 ClientFullConnect(ClientFullConnectEvent),
19801 HostQuit(HostQuitEvent),
19802 TeamInfo(TeamInfoEvent),
19803 TeamScore(TeamScoreEvent),
19804 TeamPlayBroadcastAudio(TeamPlayBroadcastAudioEvent),
19805 PlayerTeam(PlayerTeamEvent),
19806 PlayerClass(PlayerClassEvent),
19807 PlayerDeath(Box<PlayerDeathEvent>),
19808 PlayerHurt(PlayerHurtEvent),
19809 PlayerChat(PlayerChatEvent),
19810 PlayerScore(PlayerScoreEvent),
19811 PlayerSpawn(PlayerSpawnEvent),
19812 PlayerShoot(PlayerShootEvent),
19813 PlayerUse(PlayerUseEvent),
19814 PlayerChangeName(PlayerChangeNameEvent),
19815 PlayerHintMessage(PlayerHintMessageEvent),
19816 BasePlayerTeleported(BasePlayerTeleportedEvent),
19817 GameInit(GameInitEvent),
19818 GameNewMap(GameNewMapEvent),
19819 GameStart(GameStartEvent),
19820 GameEnd(GameEndEvent),
19821 RoundStart(RoundStartEvent),
19822 RoundEnd(RoundEndEvent),
19823 GameMessage(GameMessageEvent),
19824 BreakBreakable(BreakBreakableEvent),
19825 BreakProp(BreakPropEvent),
19826 EntityKilled(EntityKilledEvent),
19827 BonusUpdated(BonusUpdatedEvent),
19828 AchievementEvent(AchievementEventEvent),
19829 AchievementIncrement(AchievementIncrementEvent),
19830 PhysgunPickup(PhysgunPickupEvent),
19831 FlareIgniteNpc(FlareIgniteNpcEvent),
19832 HelicopterGrenadePuntMiss(HelicopterGrenadePuntMissEvent),
19833 UserDataDownloaded(UserDataDownloadedEvent),
19834 RagdollDissolved(RagdollDissolvedEvent),
19835 HLTVChangedMode(HLTVChangedModeEvent),
19836 HLTVChangedTarget(HLTVChangedTargetEvent),
19837 VoteEnded(VoteEndedEvent),
19838 VoteStarted(VoteStartedEvent),
19839 VoteChanged(VoteChangedEvent),
19840 VotePassed(VotePassedEvent),
19841 VoteFailed(VoteFailedEvent),
19842 VoteCast(VoteCastEvent),
19843 VoteOptions(Box<VoteOptionsEvent>),
19844 ReplaySaved(ReplaySavedEvent),
19845 EnteredPerformanceMode(EnteredPerformanceModeEvent),
19846 BrowseReplays(BrowseReplaysEvent),
19847 ReplayYoutubeStats(ReplayYoutubeStatsEvent),
19848 InventoryUpdated(InventoryUpdatedEvent),
19849 CartUpdated(CartUpdatedEvent),
19850 StorePriceSheetUpdated(StorePriceSheetUpdatedEvent),
19851 EconInventoryConnected(EconInventoryConnectedEvent),
19852 ItemSchemaInitialized(ItemSchemaInitializedEvent),
19853 GcNewSession(GcNewSessionEvent),
19854 GcLostSession(GcLostSessionEvent),
19855 IntroFinish(IntroFinishEvent),
19856 IntroNextCamera(IntroNextCameraEvent),
19857 PlayerChangeClass(PlayerChangeClassEvent),
19858 TfMapTimeRemaining(TfMapTimeRemainingEvent),
19859 TfGameOver(TfGameOverEvent),
19860 CtfFlagCaptured(CtfFlagCapturedEvent),
19861 ControlPointInitialized(ControlPointInitializedEvent),
19862 ControlPointUpdateImages(ControlPointUpdateImagesEvent),
19863 ControlPointUpdateLayout(ControlPointUpdateLayoutEvent),
19864 ControlPointUpdateCapping(ControlPointUpdateCappingEvent),
19865 ControlPointUpdateOwner(ControlPointUpdateOwnerEvent),
19866 ControlPointStartTouch(ControlPointStartTouchEvent),
19867 ControlPointEndTouch(ControlPointEndTouchEvent),
19868 ControlPointPulseElement(ControlPointPulseElementEvent),
19869 ControlPointFakeCapture(ControlPointFakeCaptureEvent),
19870 ControlPointFakeCaptureMultiplier(ControlPointFakeCaptureMultiplierEvent),
19871 TeamPlayRoundSelected(TeamPlayRoundSelectedEvent),
19872 TeamPlayRoundStart(TeamPlayRoundStartEvent),
19873 TeamPlayRoundActive(TeamPlayRoundActiveEvent),
19874 TeamPlayWaitingBegins(TeamPlayWaitingBeginsEvent),
19875 TeamPlayWaitingEnds(TeamPlayWaitingEndsEvent),
19876 TeamPlayWaitingAboutToEnd(TeamPlayWaitingAboutToEndEvent),
19877 TeamPlayRestartRound(TeamPlayRestartRoundEvent),
19878 TeamPlayReadyRestart(TeamPlayReadyRestartEvent),
19879 TeamPlayRoundRestartSeconds(TeamPlayRoundRestartSecondsEvent),
19880 TeamPlayTeamReady(TeamPlayTeamReadyEvent),
19881 TeamPlayRoundWin(TeamPlayRoundWinEvent),
19882 TeamPlayUpdateTimer(TeamPlayUpdateTimerEvent),
19883 TeamPlayRoundStalemate(TeamPlayRoundStalemateEvent),
19884 TeamPlayOvertimeBegin(TeamPlayOvertimeBeginEvent),
19885 TeamPlayOvertimeEnd(TeamPlayOvertimeEndEvent),
19886 TeamPlaySuddenDeathBegin(TeamPlaySuddenDeathBeginEvent),
19887 TeamPlaySuddenDeathEnd(TeamPlaySuddenDeathEndEvent),
19888 TeamPlayGameOver(TeamPlayGameOverEvent),
19889 TeamPlayMapTimeRemaining(TeamPlayMapTimeRemainingEvent),
19890 TeamPlayTimerFlash(TeamPlayTimerFlashEvent),
19891 TeamPlayTimerTimeAdded(TeamPlayTimerTimeAddedEvent),
19892 TeamPlayPointStartCapture(TeamPlayPointStartCaptureEvent),
19893 TeamPlayPointCaptured(TeamPlayPointCapturedEvent),
19894 TeamPlayPointLocked(TeamPlayPointLockedEvent),
19895 TeamPlayPointUnlocked(TeamPlayPointUnlockedEvent),
19896 TeamPlayCaptureBroken(TeamPlayCaptureBrokenEvent),
19897 TeamPlayCaptureBlocked(TeamPlayCaptureBlockedEvent),
19898 TeamPlayFlagEvent(TeamPlayFlagEventEvent),
19899 TeamPlayWinPanel(TeamPlayWinPanelEvent),
19900 TeamPlayTeamBalancedPlayer(TeamPlayTeamBalancedPlayerEvent),
19901 TeamPlaySetupFinished(TeamPlaySetupFinishedEvent),
19902 TeamPlayAlert(TeamPlayAlertEvent),
19903 TrainingComplete(TrainingCompleteEvent),
19904 ShowFreezePanel(ShowFreezePanelEvent),
19905 HideFreezePanel(HideFreezePanelEvent),
19906 FreezeCamStarted(FreezeCamStartedEvent),
19907 LocalPlayerChangeTeam(LocalPlayerChangeTeamEvent),
19908 LocalPlayerScoreChanged(LocalPlayerScoreChangedEvent),
19909 LocalPlayerChangeClass(LocalPlayerChangeClassEvent),
19910 LocalPlayerRespawn(LocalPlayerRespawnEvent),
19911 BuildingInfoChanged(BuildingInfoChangedEvent),
19912 LocalPlayerChangeDisguise(LocalPlayerChangeDisguiseEvent),
19913 PlayerAccountChanged(PlayerAccountChangedEvent),
19914 SpyPdaReset(SpyPdaResetEvent),
19915 FlagStatusUpdate(FlagStatusUpdateEvent),
19916 PlayerStatsUpdated(PlayerStatsUpdatedEvent),
19917 PlayingCommentary(PlayingCommentaryEvent),
19918 PlayerChargeDeployed(PlayerChargeDeployedEvent),
19919 PlayerBuiltObject(PlayerBuiltObjectEvent),
19920 PlayerUpgradedObject(PlayerUpgradedObjectEvent),
19921 PlayerCarryObject(PlayerCarryObjectEvent),
19922 PlayerDropObject(PlayerDropObjectEvent),
19923 ObjectRemoved(ObjectRemovedEvent),
19924 ObjectDestroyed(ObjectDestroyedEvent),
19925 ObjectDetonated(ObjectDetonatedEvent),
19926 AchievementEarned(AchievementEarnedEvent),
19927 SpecTargetUpdated(SpecTargetUpdatedEvent),
19928 TournamentStateUpdate(TournamentStateUpdateEvent),
19929 TournamentEnableCountdown(TournamentEnableCountdownEvent),
19930 PlayerCalledForMedic(PlayerCalledForMedicEvent),
19931 PlayerAskedForBall(PlayerAskedForBallEvent),
19932 LocalPlayerBecameObserver(LocalPlayerBecameObserverEvent),
19933 PlayerIgnitedInv(PlayerIgnitedInvEvent),
19934 PlayerIgnited(PlayerIgnitedEvent),
19935 PlayerExtinguished(PlayerExtinguishedEvent),
19936 PlayerTeleported(PlayerTeleportedEvent),
19937 PlayerHealedMedicCall(PlayerHealedMedicCallEvent),
19938 LocalPlayerChargeReady(LocalPlayerChargeReadyEvent),
19939 LocalPlayerWindDown(LocalPlayerWindDownEvent),
19940 PlayerInvulned(PlayerInvulnedEvent),
19941 EscortSpeed(EscortSpeedEvent),
19942 EscortProgress(EscortProgressEvent),
19943 EscortRecede(EscortRecedeEvent),
19944 GameUIActivated(GameUIActivatedEvent),
19945 GameUIHidden(GameUIHiddenEvent),
19946 PlayerEscortScore(PlayerEscortScoreEvent),
19947 PlayerHealOnHit(PlayerHealOnHitEvent),
19948 PlayerStealSandvich(PlayerStealSandvichEvent),
19949 ShowClassLayout(ShowClassLayoutEvent),
19950 ShowVsPanel(ShowVsPanelEvent),
19951 PlayerDamaged(PlayerDamagedEvent),
19952 ArenaPlayerNotification(ArenaPlayerNotificationEvent),
19953 ArenaMatchMaxStreak(ArenaMatchMaxStreakEvent),
19954 ArenaRoundStart(ArenaRoundStartEvent),
19955 ArenaWinPanel(ArenaWinPanelEvent),
19956 PveWinPanel(PveWinPanelEvent),
19957 AirDash(AirDashEvent),
19958 Landed(LandedEvent),
19959 PlayerDamageDodged(PlayerDamageDodgedEvent),
19960 PlayerStunned(PlayerStunnedEvent),
19961 ScoutGrandSlam(ScoutGrandSlamEvent),
19962 ScoutSlamdollLanded(ScoutSlamdollLandedEvent),
19963 ArrowImpact(ArrowImpactEvent),
19964 PlayerJarated(PlayerJaratedEvent),
19965 PlayerJaratedFade(PlayerJaratedFadeEvent),
19966 PlayerShieldBlocked(PlayerShieldBlockedEvent),
19967 PlayerPinned(PlayerPinnedEvent),
19968 PlayerHealedByMedic(PlayerHealedByMedicEvent),
19969 PlayerSappedObject(PlayerSappedObjectEvent),
19970 ItemFound(ItemFoundEvent),
19971 ShowAnnotation(ShowAnnotationEvent),
19972 HideAnnotation(HideAnnotationEvent),
19973 PostInventoryApplication(PostInventoryApplicationEvent),
19974 ControlPointUnlockUpdated(ControlPointUnlockUpdatedEvent),
19975 DeployBuffBanner(DeployBuffBannerEvent),
19976 PlayerBuff(PlayerBuffEvent),
19977 MedicDeath(MedicDeathEvent),
19978 OvertimeNag(OvertimeNagEvent),
19979 TeamsChanged(TeamsChangedEvent),
19980 HalloweenPumpkinGrab(HalloweenPumpkinGrabEvent),
19981 RocketJump(RocketJumpEvent),
19982 RocketJumpLanded(RocketJumpLandedEvent),
19983 StickyJump(StickyJumpEvent),
19984 StickyJumpLanded(StickyJumpLandedEvent),
19985 RocketPackLaunch(RocketPackLaunchEvent),
19986 RocketPackLanded(RocketPackLandedEvent),
19987 MedicDefended(MedicDefendedEvent),
19988 LocalPlayerHealed(LocalPlayerHealedEvent),
19989 PlayerDestroyedPipeBomb(PlayerDestroyedPipeBombEvent),
19990 ObjectDeflected(ObjectDeflectedEvent),
19991 PlayerMvp(PlayerMvpEvent),
19992 RaidSpawnMob(RaidSpawnMobEvent),
19993 RaidSpawnSquad(RaidSpawnSquadEvent),
19994 NavBlocked(NavBlockedEvent),
19995 PathTrackPassed(PathTrackPassedEvent),
19996 NumCappersChanged(NumCappersChangedEvent),
19997 PlayerRegenerate(PlayerRegenerateEvent),
19998 UpdateStatusItem(UpdateStatusItemEvent),
19999 StatsResetRound(StatsResetRoundEvent),
20000 ScoreStatsAccumulatedUpdate(ScoreStatsAccumulatedUpdateEvent),
20001 ScoreStatsAccumulatedReset(ScoreStatsAccumulatedResetEvent),
20002 AchievementEarnedLocal(AchievementEarnedLocalEvent),
20003 PlayerHealed(PlayerHealedEvent),
20004 BuildingHealed(BuildingHealedEvent),
20005 ItemPickup(ItemPickupEvent),
20006 DuelStatus(DuelStatusEvent),
20007 FishNotice(Box<FishNoticeEvent>),
20008 FishNoticeArm(Box<FishNoticeArmEvent>),
20009 SlapNotice(Box<SlapNoticeEvent>),
20010 ThrowableHit(Box<ThrowableHitEvent>),
20011 PumpkinLordSummoned(PumpkinLordSummonedEvent),
20012 PumpkinLordKilled(PumpkinLordKilledEvent),
20013 MerasmusSummoned(MerasmusSummonedEvent),
20014 MerasmusKilled(MerasmusKilledEvent),
20015 MerasmusEscapeWarning(MerasmusEscapeWarningEvent),
20016 MerasmusEscaped(MerasmusEscapedEvent),
20017 EyeballBossSummoned(EyeballBossSummonedEvent),
20018 EyeballBossStunned(EyeballBossStunnedEvent),
20019 EyeballBossKilled(EyeballBossKilledEvent),
20020 EyeballBossKiller(EyeballBossKillerEvent),
20021 EyeballBossEscapeImminent(EyeballBossEscapeImminentEvent),
20022 EyeballBossEscaped(EyeballBossEscapedEvent),
20023 NpcHurt(NpcHurtEvent),
20024 ControlPointTimerUpdated(ControlPointTimerUpdatedEvent),
20025 PlayerHighFiveStart(PlayerHighFiveStartEvent),
20026 PlayerHighFiveCancel(PlayerHighFiveCancelEvent),
20027 PlayerHighFiveSuccess(PlayerHighFiveSuccessEvent),
20028 PlayerBonusPoints(PlayerBonusPointsEvent),
20029 PlayerUpgraded(PlayerUpgradedEvent),
20030 PlayerBuyback(PlayerBuybackEvent),
20031 PlayerUsedPowerUpBottle(PlayerUsedPowerUpBottleEvent),
20032 ChristmasGiftGrab(ChristmasGiftGrabEvent),
20033 PlayerKilledAchievementZone(PlayerKilledAchievementZoneEvent),
20034 PartyUpdated(PartyUpdatedEvent),
20035 PartyPrefChanged(PartyPrefChangedEvent),
20036 PartyCriteriaChanged(PartyCriteriaChangedEvent),
20037 PartyInvitesChanged(PartyInvitesChangedEvent),
20038 PartyQueueStateChanged(PartyQueueStateChangedEvent),
20039 PartyChat(PartyChatEvent),
20040 PartyMemberJoin(PartyMemberJoinEvent),
20041 PartyMemberLeave(PartyMemberLeaveEvent),
20042 MatchInvitesUpdated(MatchInvitesUpdatedEvent),
20043 LobbyUpdated(LobbyUpdatedEvent),
20044 MvmMissionUpdate(MvmMissionUpdateEvent),
20045 RecalculateHolidays(RecalculateHolidaysEvent),
20046 PlayerCurrencyChanged(PlayerCurrencyChangedEvent),
20047 DoomsdayRocketOpen(DoomsdayRocketOpenEvent),
20048 RemoveNemesisRelationships(RemoveNemesisRelationshipsEvent),
20049 MvmCreditBonusWave(MvmCreditBonusWaveEvent),
20050 MvmCreditBonusAll(MvmCreditBonusAllEvent),
20051 MvmCreditBonusAllAdvanced(MvmCreditBonusAllAdvancedEvent),
20052 MvmQuickSentryUpgrade(MvmQuickSentryUpgradeEvent),
20053 MvmTankDestroyedByPlayers(MvmTankDestroyedByPlayersEvent),
20054 MvmKillRobotDeliveringBomb(MvmKillRobotDeliveringBombEvent),
20055 MvmPickupCurrency(MvmPickupCurrencyEvent),
20056 MvmBombCarrierKilled(MvmBombCarrierKilledEvent),
20057 MvmSentryBusterDetonate(MvmSentryBusterDetonateEvent),
20058 MvmScoutMarkedForDeath(MvmScoutMarkedForDeathEvent),
20059 MvmMedicPowerUpShared(MvmMedicPowerUpSharedEvent),
20060 MvmBeginWave(MvmBeginWaveEvent),
20061 MvmWaveComplete(MvmWaveCompleteEvent),
20062 MvmMissionComplete(MvmMissionCompleteEvent),
20063 MvmBombResetByPlayer(MvmBombResetByPlayerEvent),
20064 MvmBombAlarmTriggered(MvmBombAlarmTriggeredEvent),
20065 MvmBombDeployResetByPlayer(MvmBombDeployResetByPlayerEvent),
20066 MvmWaveFailed(MvmWaveFailedEvent),
20067 MvmResetStats(MvmResetStatsEvent),
20068 DamageResisted(DamageResistedEvent),
20069 RevivePlayerNotify(RevivePlayerNotifyEvent),
20070 RevivePlayerStopped(RevivePlayerStoppedEvent),
20071 RevivePlayerComplete(RevivePlayerCompleteEvent),
20072 PlayerTurnedToGhost(PlayerTurnedToGhostEvent),
20073 MedigunShieldBlockedDamage(MedigunShieldBlockedDamageEvent),
20074 MvmAdvWaveCompleteNoGates(MvmAdvWaveCompleteNoGatesEvent),
20075 MvmSniperHeadshotCurrency(MvmSniperHeadshotCurrencyEvent),
20076 MvmMannhattanPit(MvmMannhattanPitEvent),
20077 FlagCarriedInDetectionZone(FlagCarriedInDetectionZoneEvent),
20078 MvmAdvWaveKilledStunRadio(MvmAdvWaveKilledStunRadioEvent),
20079 PlayerDirectHitStun(PlayerDirectHitStunEvent),
20080 MvmSentryBusterKilled(MvmSentryBusterKilledEvent),
20081 UpgradesFileChanged(UpgradesFileChangedEvent),
20082 RdTeamPointsChanged(RdTeamPointsChangedEvent),
20083 RdRulesStateChanged(RdRulesStateChangedEvent),
20084 RdRobotKilled(RdRobotKilledEvent),
20085 RdRobotImpact(RdRobotImpactEvent),
20086 TeamPlayPreRoundTimeLeft(TeamPlayPreRoundTimeLeftEvent),
20087 ParachuteDeploy(ParachuteDeployEvent),
20088 ParachuteHolster(ParachuteHolsterEvent),
20089 KillRefillsMeter(KillRefillsMeterEvent),
20090 RpsTauntEvent(RpsTauntEventEvent),
20091 CongaKill(CongaKillEvent),
20092 PlayerInitialSpawn(PlayerInitialSpawnEvent),
20093 CompetitiveVictory(CompetitiveVictoryEvent),
20094 CompetitiveStatsUpdate(CompetitiveStatsUpdateEvent),
20095 MiniGameWin(MiniGameWinEvent),
20096 SentryOnGoActive(SentryOnGoActiveEvent),
20097 DuckXpLevelUp(DuckXpLevelUpEvent),
20098 QuestLogOpened(QuestLogOpenedEvent),
20099 SchemaUpdated(SchemaUpdatedEvent),
20100 LocalPlayerPickupWeapon(LocalPlayerPickupWeaponEvent),
20101 RdPlayerScorePoints(RdPlayerScorePointsEvent),
20102 DemomanDetStickies(DemomanDetStickiesEvent),
20103 QuestObjectiveCompleted(QuestObjectiveCompletedEvent),
20104 PlayerScoreChanged(PlayerScoreChangedEvent),
20105 KilledCappingPlayer(KilledCappingPlayerEvent),
20106 EnvironmentalDeath(EnvironmentalDeathEvent),
20107 ProjectileDirectHit(ProjectileDirectHitEvent),
20108 PassGet(PassGetEvent),
20109 PassScore(PassScoreEvent),
20110 PassFree(PassFreeEvent),
20111 PassPassCaught(PassPassCaughtEvent),
20112 PassBallStolen(PassBallStolenEvent),
20113 PassBallBlocked(PassBallBlockedEvent),
20114 DamagePrevented(DamagePreventedEvent),
20115 HalloweenBossKilled(HalloweenBossKilledEvent),
20116 EscapedLootIsland(EscapedLootIslandEvent),
20117 TaggedPlayerAsIt(TaggedPlayerAsItEvent),
20118 MerasmusStunned(MerasmusStunnedEvent),
20119 MerasmusPropFound(MerasmusPropFoundEvent),
20120 HalloweenSkeletonKilled(HalloweenSkeletonKilledEvent),
20121 SkeletonKilledQuest(SkeletonKilledQuestEvent),
20122 SkeletonKingKilledQuest(SkeletonKingKilledQuestEvent),
20123 EscapeHell(EscapeHellEvent),
20124 CrossSpectralBridge(CrossSpectralBridgeEvent),
20125 MiniGameWon(MiniGameWonEvent),
20126 RespawnGhost(RespawnGhostEvent),
20127 KillInHell(KillInHellEvent),
20128 HalloweenDuckCollected(HalloweenDuckCollectedEvent),
20129 SpecialScore(SpecialScoreEvent),
20130 TeamLeaderKilled(TeamLeaderKilledEvent),
20131 HalloweenSoulCollected(HalloweenSoulCollectedEvent),
20132 RecalculateTruce(RecalculateTruceEvent),
20133 DeadRingerCheatDeath(DeadRingerCheatDeathEvent),
20134 CrossbowHeal(CrossbowHealEvent),
20135 DamageMitigated(DamageMitigatedEvent),
20136 PayloadPushed(PayloadPushedEvent),
20137 PlayerAbandonedMatch(PlayerAbandonedMatchEvent),
20138 ClDrawline(ClDrawlineEvent),
20139 RestartTimerTime(RestartTimerTimeEvent),
20140 WinLimitChanged(WinLimitChangedEvent),
20141 WinPanelShowScores(WinPanelShowScoresEvent),
20142 TopStreamsRequestFinished(TopStreamsRequestFinishedEvent),
20143 CompetitiveStateChanged(CompetitiveStateChangedEvent),
20144 GlobalWarDataUpdated(GlobalWarDataUpdatedEvent),
20145 StopWatchChanged(StopWatchChangedEvent),
20146 DsStop(DsStopEvent),
20147 DsScreenshot(DsScreenshotEvent),
20148 ShowMatchSummary(ShowMatchSummaryEvent),
20149 ExperienceChanged(ExperienceChangedEvent),
20150 BeginXpLerp(BeginXpLerpEvent),
20151 MatchmakerStatsUpdated(MatchmakerStatsUpdatedEvent),
20152 RematchVotePeriodOver(RematchVotePeriodOverEvent),
20153 RematchFailedToCreate(RematchFailedToCreateEvent),
20154 PlayerRematchChange(PlayerRematchChangeEvent),
20155 PingUpdated(PingUpdatedEvent),
20156 MMStatsUpdated(MMStatsUpdatedEvent),
20157 PlayerNextMapVoteChange(PlayerNextMapVoteChangeEvent),
20158 VoteMapsChanged(VoteMapsChangedEvent),
20159 ProtoDefChanged(ProtoDefChangedEvent),
20160 PlayerDomination(PlayerDominationEvent),
20161 PlayerRocketPackPushed(PlayerRocketPackPushedEvent),
20162 QuestRequest(QuestRequestEvent),
20163 QuestResponse(QuestResponseEvent),
20164 QuestProgress(QuestProgressEvent),
20165 ProjectileRemoved(ProjectileRemovedEvent),
20166 QuestMapDataChanged(QuestMapDataChangedEvent),
20167 GasDousedPlayerIgnited(GasDousedPlayerIgnitedEvent),
20168 QuestTurnInState(QuestTurnInStateEvent),
20169 ItemsAcknowledged(ItemsAcknowledgedEvent),
20170 CapperKilled(CapperKilledEvent),
20171 MainMenuStabilized(MainMenuStabilizedEvent),
20172 WorldStatusChanged(WorldStatusChangedEvent),
20173 HLTVStatus(HLTVStatusEvent),
20174 HLTVCameraman(HLTVCameramanEvent),
20175 HLTVRankCamera(HLTVRankCameraEvent),
20176 HLTVRankEntity(HLTVRankEntityEvent),
20177 HLTVFixed(HLTVFixedEvent),
20178 HLTVChase(HLTVChaseEvent),
20179 HLTVMessage(HLTVMessageEvent),
20180 HLTVTitle(HLTVTitleEvent),
20181 HLTVChat(HLTVChatEvent),
20182 ReplayStartRecord(ReplayStartRecordEvent),
20183 ReplaySessionInfo(ReplaySessionInfoEvent),
20184 ReplayEndRecord(ReplayEndRecordEvent),
20185 ReplayReplaysAvailable(ReplayReplaysAvailableEvent),
20186 ReplayServerError(ReplayServerErrorEvent),
20187 Unknown(RawGameEvent),
20188}
20189#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
20190#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
20191pub enum GameEventType {
20192 #[serde(rename = "server_spawn")]
20193 ServerSpawn,
20194 #[serde(rename = "server_changelevel_failed")]
20195 ServerChangeLevelFailed,
20196 #[serde(rename = "server_shutdown")]
20197 ServerShutdown,
20198 #[serde(rename = "server_cvar")]
20199 ServerCvar,
20200 #[serde(rename = "server_message")]
20201 ServerMessage,
20202 #[serde(rename = "server_addban")]
20203 ServerAddBan,
20204 #[serde(rename = "server_removeban")]
20205 ServerRemoveBan,
20206 #[serde(rename = "player_connect")]
20207 PlayerConnect,
20208 #[serde(rename = "player_connect_client")]
20209 PlayerConnectClient,
20210 #[serde(rename = "player_info")]
20211 PlayerInfo,
20212 #[serde(rename = "player_disconnect")]
20213 PlayerDisconnect,
20214 #[serde(rename = "player_activate")]
20215 PlayerActivate,
20216 #[serde(rename = "player_say")]
20217 PlayerSay,
20218 #[serde(rename = "client_disconnect")]
20219 ClientDisconnect,
20220 #[serde(rename = "client_beginconnect")]
20221 ClientBeginConnect,
20222 #[serde(rename = "client_connected")]
20223 ClientConnected,
20224 #[serde(rename = "client_fullconnect")]
20225 ClientFullConnect,
20226 #[serde(rename = "host_quit")]
20227 HostQuit,
20228 #[serde(rename = "team_info")]
20229 TeamInfo,
20230 #[serde(rename = "team_score")]
20231 TeamScore,
20232 #[serde(rename = "teamplay_broadcast_audio")]
20233 TeamPlayBroadcastAudio,
20234 #[serde(rename = "player_team")]
20235 PlayerTeam,
20236 #[serde(rename = "player_class")]
20237 PlayerClass,
20238 #[serde(rename = "player_death")]
20239 PlayerDeath,
20240 #[serde(rename = "player_hurt")]
20241 PlayerHurt,
20242 #[serde(rename = "player_chat")]
20243 PlayerChat,
20244 #[serde(rename = "player_score")]
20245 PlayerScore,
20246 #[serde(rename = "player_spawn")]
20247 PlayerSpawn,
20248 #[serde(rename = "player_shoot")]
20249 PlayerShoot,
20250 #[serde(rename = "player_use")]
20251 PlayerUse,
20252 #[serde(rename = "player_changename")]
20253 PlayerChangeName,
20254 #[serde(rename = "player_hintmessage")]
20255 PlayerHintMessage,
20256 #[serde(rename = "base_player_teleported")]
20257 BasePlayerTeleported,
20258 #[serde(rename = "game_init")]
20259 GameInit,
20260 #[serde(rename = "game_newmap")]
20261 GameNewMap,
20262 #[serde(rename = "game_start")]
20263 GameStart,
20264 #[serde(rename = "game_end")]
20265 GameEnd,
20266 #[serde(rename = "round_start")]
20267 RoundStart,
20268 #[serde(rename = "round_end")]
20269 RoundEnd,
20270 #[serde(rename = "game_message")]
20271 GameMessage,
20272 #[serde(rename = "break_breakable")]
20273 BreakBreakable,
20274 #[serde(rename = "break_prop")]
20275 BreakProp,
20276 #[serde(rename = "entity_killed")]
20277 EntityKilled,
20278 #[serde(rename = "bonus_updated")]
20279 BonusUpdated,
20280 #[serde(rename = "achievement_event")]
20281 AchievementEvent,
20282 #[serde(rename = "achievement_increment")]
20283 AchievementIncrement,
20284 #[serde(rename = "physgun_pickup")]
20285 PhysgunPickup,
20286 #[serde(rename = "flare_ignite_npc")]
20287 FlareIgniteNpc,
20288 #[serde(rename = "helicopter_grenade_punt_miss")]
20289 HelicopterGrenadePuntMiss,
20290 #[serde(rename = "user_data_downloaded")]
20291 UserDataDownloaded,
20292 #[serde(rename = "ragdoll_dissolved")]
20293 RagdollDissolved,
20294 #[serde(rename = "hltv_changed_mode")]
20295 HLTVChangedMode,
20296 #[serde(rename = "hltv_changed_target")]
20297 HLTVChangedTarget,
20298 #[serde(rename = "vote_ended")]
20299 VoteEnded,
20300 #[serde(rename = "vote_started")]
20301 VoteStarted,
20302 #[serde(rename = "vote_changed")]
20303 VoteChanged,
20304 #[serde(rename = "vote_passed")]
20305 VotePassed,
20306 #[serde(rename = "vote_failed")]
20307 VoteFailed,
20308 #[serde(rename = "vote_cast")]
20309 VoteCast,
20310 #[serde(rename = "vote_options")]
20311 VoteOptions,
20312 #[serde(rename = "replay_saved")]
20313 ReplaySaved,
20314 #[serde(rename = "entered_performance_mode")]
20315 EnteredPerformanceMode,
20316 #[serde(rename = "browse_replays")]
20317 BrowseReplays,
20318 #[serde(rename = "replay_youtube_stats")]
20319 ReplayYoutubeStats,
20320 #[serde(rename = "inventory_updated")]
20321 InventoryUpdated,
20322 #[serde(rename = "cart_updated")]
20323 CartUpdated,
20324 #[serde(rename = "store_pricesheet_updated")]
20325 StorePriceSheetUpdated,
20326 #[serde(rename = "econ_inventory_connected")]
20327 EconInventoryConnected,
20328 #[serde(rename = "item_schema_initialized")]
20329 ItemSchemaInitialized,
20330 #[serde(rename = "gc_new_session")]
20331 GcNewSession,
20332 #[serde(rename = "gc_lost_session")]
20333 GcLostSession,
20334 #[serde(rename = "intro_finish")]
20335 IntroFinish,
20336 #[serde(rename = "intro_nextcamera")]
20337 IntroNextCamera,
20338 #[serde(rename = "player_changeclass")]
20339 PlayerChangeClass,
20340 #[serde(rename = "tf_map_time_remaining")]
20341 TfMapTimeRemaining,
20342 #[serde(rename = "tf_game_over")]
20343 TfGameOver,
20344 #[serde(rename = "ctf_flag_captured")]
20345 CtfFlagCaptured,
20346 #[serde(rename = "controlpoint_initialized")]
20347 ControlPointInitialized,
20348 #[serde(rename = "controlpoint_updateimages")]
20349 ControlPointUpdateImages,
20350 #[serde(rename = "controlpoint_updatelayout")]
20351 ControlPointUpdateLayout,
20352 #[serde(rename = "controlpoint_updatecapping")]
20353 ControlPointUpdateCapping,
20354 #[serde(rename = "controlpoint_updateowner")]
20355 ControlPointUpdateOwner,
20356 #[serde(rename = "controlpoint_starttouch")]
20357 ControlPointStartTouch,
20358 #[serde(rename = "controlpoint_endtouch")]
20359 ControlPointEndTouch,
20360 #[serde(rename = "controlpoint_pulse_element")]
20361 ControlPointPulseElement,
20362 #[serde(rename = "controlpoint_fake_capture")]
20363 ControlPointFakeCapture,
20364 #[serde(rename = "controlpoint_fake_capture_mult")]
20365 ControlPointFakeCaptureMultiplier,
20366 #[serde(rename = "teamplay_round_selected")]
20367 TeamPlayRoundSelected,
20368 #[serde(rename = "teamplay_round_start")]
20369 TeamPlayRoundStart,
20370 #[serde(rename = "teamplay_round_active")]
20371 TeamPlayRoundActive,
20372 #[serde(rename = "teamplay_waiting_begins")]
20373 TeamPlayWaitingBegins,
20374 #[serde(rename = "teamplay_waiting_ends")]
20375 TeamPlayWaitingEnds,
20376 #[serde(rename = "teamplay_waiting_abouttoend")]
20377 TeamPlayWaitingAboutToEnd,
20378 #[serde(rename = "teamplay_restart_round")]
20379 TeamPlayRestartRound,
20380 #[serde(rename = "teamplay_ready_restart")]
20381 TeamPlayReadyRestart,
20382 #[serde(rename = "teamplay_round_restart_seconds")]
20383 TeamPlayRoundRestartSeconds,
20384 #[serde(rename = "teamplay_team_ready")]
20385 TeamPlayTeamReady,
20386 #[serde(rename = "teamplay_round_win")]
20387 TeamPlayRoundWin,
20388 #[serde(rename = "teamplay_update_timer")]
20389 TeamPlayUpdateTimer,
20390 #[serde(rename = "teamplay_round_stalemate")]
20391 TeamPlayRoundStalemate,
20392 #[serde(rename = "teamplay_overtime_begin")]
20393 TeamPlayOvertimeBegin,
20394 #[serde(rename = "teamplay_overtime_end")]
20395 TeamPlayOvertimeEnd,
20396 #[serde(rename = "teamplay_suddendeath_begin")]
20397 TeamPlaySuddenDeathBegin,
20398 #[serde(rename = "teamplay_suddendeath_end")]
20399 TeamPlaySuddenDeathEnd,
20400 #[serde(rename = "teamplay_game_over")]
20401 TeamPlayGameOver,
20402 #[serde(rename = "teamplay_map_time_remaining")]
20403 TeamPlayMapTimeRemaining,
20404 #[serde(rename = "teamplay_timer_flash")]
20405 TeamPlayTimerFlash,
20406 #[serde(rename = "teamplay_timer_time_added")]
20407 TeamPlayTimerTimeAdded,
20408 #[serde(rename = "teamplay_point_startcapture")]
20409 TeamPlayPointStartCapture,
20410 #[serde(rename = "teamplay_point_captured")]
20411 TeamPlayPointCaptured,
20412 #[serde(rename = "teamplay_point_locked")]
20413 TeamPlayPointLocked,
20414 #[serde(rename = "teamplay_point_unlocked")]
20415 TeamPlayPointUnlocked,
20416 #[serde(rename = "teamplay_capture_broken")]
20417 TeamPlayCaptureBroken,
20418 #[serde(rename = "teamplay_capture_blocked")]
20419 TeamPlayCaptureBlocked,
20420 #[serde(rename = "teamplay_flag_event")]
20421 TeamPlayFlagEvent,
20422 #[serde(rename = "teamplay_win_panel")]
20423 TeamPlayWinPanel,
20424 #[serde(rename = "teamplay_teambalanced_player")]
20425 TeamPlayTeamBalancedPlayer,
20426 #[serde(rename = "teamplay_setup_finished")]
20427 TeamPlaySetupFinished,
20428 #[serde(rename = "teamplay_alert")]
20429 TeamPlayAlert,
20430 #[serde(rename = "training_complete")]
20431 TrainingComplete,
20432 #[serde(rename = "show_freezepanel")]
20433 ShowFreezePanel,
20434 #[serde(rename = "hide_freezepanel")]
20435 HideFreezePanel,
20436 #[serde(rename = "freezecam_started")]
20437 FreezeCamStarted,
20438 #[serde(rename = "localplayer_changeteam")]
20439 LocalPlayerChangeTeam,
20440 #[serde(rename = "localplayer_score_changed")]
20441 LocalPlayerScoreChanged,
20442 #[serde(rename = "localplayer_changeclass")]
20443 LocalPlayerChangeClass,
20444 #[serde(rename = "localplayer_respawn")]
20445 LocalPlayerRespawn,
20446 #[serde(rename = "building_info_changed")]
20447 BuildingInfoChanged,
20448 #[serde(rename = "localplayer_changedisguise")]
20449 LocalPlayerChangeDisguise,
20450 #[serde(rename = "player_account_changed")]
20451 PlayerAccountChanged,
20452 #[serde(rename = "spy_pda_reset")]
20453 SpyPdaReset,
20454 #[serde(rename = "flagstatus_update")]
20455 FlagStatusUpdate,
20456 #[serde(rename = "player_stats_updated")]
20457 PlayerStatsUpdated,
20458 #[serde(rename = "playing_commentary")]
20459 PlayingCommentary,
20460 #[serde(rename = "player_chargedeployed")]
20461 PlayerChargeDeployed,
20462 #[serde(rename = "player_builtobject")]
20463 PlayerBuiltObject,
20464 #[serde(rename = "player_upgradedobject")]
20465 PlayerUpgradedObject,
20466 #[serde(rename = "player_carryobject")]
20467 PlayerCarryObject,
20468 #[serde(rename = "player_dropobject")]
20469 PlayerDropObject,
20470 #[serde(rename = "object_removed")]
20471 ObjectRemoved,
20472 #[serde(rename = "object_destroyed")]
20473 ObjectDestroyed,
20474 #[serde(rename = "object_detonated")]
20475 ObjectDetonated,
20476 #[serde(rename = "achievement_earned")]
20477 AchievementEarned,
20478 #[serde(rename = "spec_target_updated")]
20479 SpecTargetUpdated,
20480 #[serde(rename = "tournament_stateupdate")]
20481 TournamentStateUpdate,
20482 #[serde(rename = "tournament_enablecountdown")]
20483 TournamentEnableCountdown,
20484 #[serde(rename = "player_calledformedic")]
20485 PlayerCalledForMedic,
20486 #[serde(rename = "player_askedforball")]
20487 PlayerAskedForBall,
20488 #[serde(rename = "localplayer_becameobserver")]
20489 LocalPlayerBecameObserver,
20490 #[serde(rename = "player_ignited_inv")]
20491 PlayerIgnitedInv,
20492 #[serde(rename = "player_ignited")]
20493 PlayerIgnited,
20494 #[serde(rename = "player_extinguished")]
20495 PlayerExtinguished,
20496 #[serde(rename = "player_teleported")]
20497 PlayerTeleported,
20498 #[serde(rename = "player_healedmediccall")]
20499 PlayerHealedMedicCall,
20500 #[serde(rename = "localplayer_chargeready")]
20501 LocalPlayerChargeReady,
20502 #[serde(rename = "localplayer_winddown")]
20503 LocalPlayerWindDown,
20504 #[serde(rename = "player_invulned")]
20505 PlayerInvulned,
20506 #[serde(rename = "escort_speed")]
20507 EscortSpeed,
20508 #[serde(rename = "escort_progress")]
20509 EscortProgress,
20510 #[serde(rename = "escort_recede")]
20511 EscortRecede,
20512 #[serde(rename = "gameui_activated")]
20513 GameUIActivated,
20514 #[serde(rename = "gameui_hidden")]
20515 GameUIHidden,
20516 #[serde(rename = "player_escort_score")]
20517 PlayerEscortScore,
20518 #[serde(rename = "player_healonhit")]
20519 PlayerHealOnHit,
20520 #[serde(rename = "player_stealsandvich")]
20521 PlayerStealSandvich,
20522 #[serde(rename = "show_class_layout")]
20523 ShowClassLayout,
20524 #[serde(rename = "show_vs_panel")]
20525 ShowVsPanel,
20526 #[serde(rename = "player_damaged")]
20527 PlayerDamaged,
20528 #[serde(rename = "arena_player_notification")]
20529 ArenaPlayerNotification,
20530 #[serde(rename = "arena_match_maxstreak")]
20531 ArenaMatchMaxStreak,
20532 #[serde(rename = "arena_round_start")]
20533 ArenaRoundStart,
20534 #[serde(rename = "arena_win_panel")]
20535 ArenaWinPanel,
20536 #[serde(rename = "pve_win_panel")]
20537 PveWinPanel,
20538 #[serde(rename = "air_dash")]
20539 AirDash,
20540 #[serde(rename = "landed")]
20541 Landed,
20542 #[serde(rename = "player_damage_dodged")]
20543 PlayerDamageDodged,
20544 #[serde(rename = "player_stunned")]
20545 PlayerStunned,
20546 #[serde(rename = "scout_grand_slam")]
20547 ScoutGrandSlam,
20548 #[serde(rename = "scout_slamdoll_landed")]
20549 ScoutSlamdollLanded,
20550 #[serde(rename = "arrow_impact")]
20551 ArrowImpact,
20552 #[serde(rename = "player_jarated")]
20553 PlayerJarated,
20554 #[serde(rename = "player_jarated_fade")]
20555 PlayerJaratedFade,
20556 #[serde(rename = "player_shield_blocked")]
20557 PlayerShieldBlocked,
20558 #[serde(rename = "player_pinned")]
20559 PlayerPinned,
20560 #[serde(rename = "player_healedbymedic")]
20561 PlayerHealedByMedic,
20562 #[serde(rename = "player_sapped_object")]
20563 PlayerSappedObject,
20564 #[serde(rename = "item_found")]
20565 ItemFound,
20566 #[serde(rename = "show_annotation")]
20567 ShowAnnotation,
20568 #[serde(rename = "hide_annotation")]
20569 HideAnnotation,
20570 #[serde(rename = "post_inventory_application")]
20571 PostInventoryApplication,
20572 #[serde(rename = "controlpoint_unlock_updated")]
20573 ControlPointUnlockUpdated,
20574 #[serde(rename = "deploy_buff_banner")]
20575 DeployBuffBanner,
20576 #[serde(rename = "player_buff")]
20577 PlayerBuff,
20578 #[serde(rename = "medic_death")]
20579 MedicDeath,
20580 #[serde(rename = "overtime_nag")]
20581 OvertimeNag,
20582 #[serde(rename = "teams_changed")]
20583 TeamsChanged,
20584 #[serde(rename = "halloween_pumpkin_grab")]
20585 HalloweenPumpkinGrab,
20586 #[serde(rename = "rocket_jump")]
20587 RocketJump,
20588 #[serde(rename = "rocket_jump_landed")]
20589 RocketJumpLanded,
20590 #[serde(rename = "sticky_jump")]
20591 StickyJump,
20592 #[serde(rename = "sticky_jump_landed")]
20593 StickyJumpLanded,
20594 #[serde(rename = "rocketpack_launch")]
20595 RocketPackLaunch,
20596 #[serde(rename = "rocketpack_landed")]
20597 RocketPackLanded,
20598 #[serde(rename = "medic_defended")]
20599 MedicDefended,
20600 #[serde(rename = "localplayer_healed")]
20601 LocalPlayerHealed,
20602 #[serde(rename = "player_destroyed_pipebomb")]
20603 PlayerDestroyedPipeBomb,
20604 #[serde(rename = "object_deflected")]
20605 ObjectDeflected,
20606 #[serde(rename = "player_mvp")]
20607 PlayerMvp,
20608 #[serde(rename = "raid_spawn_mob")]
20609 RaidSpawnMob,
20610 #[serde(rename = "raid_spawn_squad")]
20611 RaidSpawnSquad,
20612 #[serde(rename = "nav_blocked")]
20613 NavBlocked,
20614 #[serde(rename = "path_track_passed")]
20615 PathTrackPassed,
20616 #[serde(rename = "num_cappers_changed")]
20617 NumCappersChanged,
20618 #[serde(rename = "player_regenerate")]
20619 PlayerRegenerate,
20620 #[serde(rename = "update_status_item")]
20621 UpdateStatusItem,
20622 #[serde(rename = "stats_resetround")]
20623 StatsResetRound,
20624 #[serde(rename = "scorestats_accumulated_update")]
20625 ScoreStatsAccumulatedUpdate,
20626 #[serde(rename = "scorestats_accumulated_reset")]
20627 ScoreStatsAccumulatedReset,
20628 #[serde(rename = "achievement_earned_local")]
20629 AchievementEarnedLocal,
20630 #[serde(rename = "player_healed")]
20631 PlayerHealed,
20632 #[serde(rename = "building_healed")]
20633 BuildingHealed,
20634 #[serde(rename = "item_pickup")]
20635 ItemPickup,
20636 #[serde(rename = "duel_status")]
20637 DuelStatus,
20638 #[serde(rename = "fish_notice")]
20639 FishNotice,
20640 #[serde(rename = "fish_notice__arm")]
20641 FishNoticeArm,
20642 #[serde(rename = "slap_notice")]
20643 SlapNotice,
20644 #[serde(rename = "throwable_hit")]
20645 ThrowableHit,
20646 #[serde(rename = "pumpkin_lord_summoned")]
20647 PumpkinLordSummoned,
20648 #[serde(rename = "pumpkin_lord_killed")]
20649 PumpkinLordKilled,
20650 #[serde(rename = "merasmus_summoned")]
20651 MerasmusSummoned,
20652 #[serde(rename = "merasmus_killed")]
20653 MerasmusKilled,
20654 #[serde(rename = "merasmus_escape_warning")]
20655 MerasmusEscapeWarning,
20656 #[serde(rename = "merasmus_escaped")]
20657 MerasmusEscaped,
20658 #[serde(rename = "eyeball_boss_summoned")]
20659 EyeballBossSummoned,
20660 #[serde(rename = "eyeball_boss_stunned")]
20661 EyeballBossStunned,
20662 #[serde(rename = "eyeball_boss_killed")]
20663 EyeballBossKilled,
20664 #[serde(rename = "eyeball_boss_killer")]
20665 EyeballBossKiller,
20666 #[serde(rename = "eyeball_boss_escape_imminent")]
20667 EyeballBossEscapeImminent,
20668 #[serde(rename = "eyeball_boss_escaped")]
20669 EyeballBossEscaped,
20670 #[serde(rename = "npc_hurt")]
20671 NpcHurt,
20672 #[serde(rename = "controlpoint_timer_updated")]
20673 ControlPointTimerUpdated,
20674 #[serde(rename = "player_highfive_start")]
20675 PlayerHighFiveStart,
20676 #[serde(rename = "player_highfive_cancel")]
20677 PlayerHighFiveCancel,
20678 #[serde(rename = "player_highfive_success")]
20679 PlayerHighFiveSuccess,
20680 #[serde(rename = "player_bonuspoints")]
20681 PlayerBonusPoints,
20682 #[serde(rename = "player_upgraded")]
20683 PlayerUpgraded,
20684 #[serde(rename = "player_buyback")]
20685 PlayerBuyback,
20686 #[serde(rename = "player_used_powerup_bottle")]
20687 PlayerUsedPowerUpBottle,
20688 #[serde(rename = "christmas_gift_grab")]
20689 ChristmasGiftGrab,
20690 #[serde(rename = "player_killed_achievement_zone")]
20691 PlayerKilledAchievementZone,
20692 #[serde(rename = "party_updated")]
20693 PartyUpdated,
20694 #[serde(rename = "party_pref_changed")]
20695 PartyPrefChanged,
20696 #[serde(rename = "party_criteria_changed")]
20697 PartyCriteriaChanged,
20698 #[serde(rename = "party_invites_changed")]
20699 PartyInvitesChanged,
20700 #[serde(rename = "party_queue_state_changed")]
20701 PartyQueueStateChanged,
20702 #[serde(rename = "party_chat")]
20703 PartyChat,
20704 #[serde(rename = "party_member_join")]
20705 PartyMemberJoin,
20706 #[serde(rename = "party_member_leave")]
20707 PartyMemberLeave,
20708 #[serde(rename = "match_invites_updated")]
20709 MatchInvitesUpdated,
20710 #[serde(rename = "lobby_updated")]
20711 LobbyUpdated,
20712 #[serde(rename = "mvm_mission_update")]
20713 MvmMissionUpdate,
20714 #[serde(rename = "recalculate_holidays")]
20715 RecalculateHolidays,
20716 #[serde(rename = "player_currency_changed")]
20717 PlayerCurrencyChanged,
20718 #[serde(rename = "doomsday_rocket_open")]
20719 DoomsdayRocketOpen,
20720 #[serde(rename = "remove_nemesis_relationships")]
20721 RemoveNemesisRelationships,
20722 #[serde(rename = "mvm_creditbonus_wave")]
20723 MvmCreditBonusWave,
20724 #[serde(rename = "mvm_creditbonus_all")]
20725 MvmCreditBonusAll,
20726 #[serde(rename = "mvm_creditbonus_all_advanced")]
20727 MvmCreditBonusAllAdvanced,
20728 #[serde(rename = "mvm_quick_sentry_upgrade")]
20729 MvmQuickSentryUpgrade,
20730 #[serde(rename = "mvm_tank_destroyed_by_players")]
20731 MvmTankDestroyedByPlayers,
20732 #[serde(rename = "mvm_kill_robot_delivering_bomb")]
20733 MvmKillRobotDeliveringBomb,
20734 #[serde(rename = "mvm_pickup_currency")]
20735 MvmPickupCurrency,
20736 #[serde(rename = "mvm_bomb_carrier_killed")]
20737 MvmBombCarrierKilled,
20738 #[serde(rename = "mvm_sentrybuster_detonate")]
20739 MvmSentryBusterDetonate,
20740 #[serde(rename = "mvm_scout_marked_for_death")]
20741 MvmScoutMarkedForDeath,
20742 #[serde(rename = "mvm_medic_powerup_shared")]
20743 MvmMedicPowerUpShared,
20744 #[serde(rename = "mvm_begin_wave")]
20745 MvmBeginWave,
20746 #[serde(rename = "mvm_wave_complete")]
20747 MvmWaveComplete,
20748 #[serde(rename = "mvm_mission_complete")]
20749 MvmMissionComplete,
20750 #[serde(rename = "mvm_bomb_reset_by_player")]
20751 MvmBombResetByPlayer,
20752 #[serde(rename = "mvm_bomb_alarm_triggered")]
20753 MvmBombAlarmTriggered,
20754 #[serde(rename = "mvm_bomb_deploy_reset_by_player")]
20755 MvmBombDeployResetByPlayer,
20756 #[serde(rename = "mvm_wave_failed")]
20757 MvmWaveFailed,
20758 #[serde(rename = "mvm_reset_stats")]
20759 MvmResetStats,
20760 #[serde(rename = "damage_resisted")]
20761 DamageResisted,
20762 #[serde(rename = "revive_player_notify")]
20763 RevivePlayerNotify,
20764 #[serde(rename = "revive_player_stopped")]
20765 RevivePlayerStopped,
20766 #[serde(rename = "revive_player_complete")]
20767 RevivePlayerComplete,
20768 #[serde(rename = "player_turned_to_ghost")]
20769 PlayerTurnedToGhost,
20770 #[serde(rename = "medigun_shield_blocked_damage")]
20771 MedigunShieldBlockedDamage,
20772 #[serde(rename = "mvm_adv_wave_complete_no_gates")]
20773 MvmAdvWaveCompleteNoGates,
20774 #[serde(rename = "mvm_sniper_headshot_currency")]
20775 MvmSniperHeadshotCurrency,
20776 #[serde(rename = "mvm_mannhattan_pit")]
20777 MvmMannhattanPit,
20778 #[serde(rename = "flag_carried_in_detection_zone")]
20779 FlagCarriedInDetectionZone,
20780 #[serde(rename = "mvm_adv_wave_killed_stun_radio")]
20781 MvmAdvWaveKilledStunRadio,
20782 #[serde(rename = "player_directhit_stun")]
20783 PlayerDirectHitStun,
20784 #[serde(rename = "mvm_sentrybuster_killed")]
20785 MvmSentryBusterKilled,
20786 #[serde(rename = "upgrades_file_changed")]
20787 UpgradesFileChanged,
20788 #[serde(rename = "rd_team_points_changed")]
20789 RdTeamPointsChanged,
20790 #[serde(rename = "rd_rules_state_changed")]
20791 RdRulesStateChanged,
20792 #[serde(rename = "rd_robot_killed")]
20793 RdRobotKilled,
20794 #[serde(rename = "rd_robot_impact")]
20795 RdRobotImpact,
20796 #[serde(rename = "teamplay_pre_round_time_left")]
20797 TeamPlayPreRoundTimeLeft,
20798 #[serde(rename = "parachute_deploy")]
20799 ParachuteDeploy,
20800 #[serde(rename = "parachute_holster")]
20801 ParachuteHolster,
20802 #[serde(rename = "kill_refills_meter")]
20803 KillRefillsMeter,
20804 #[serde(rename = "rps_taunt_event")]
20805 RpsTauntEvent,
20806 #[serde(rename = "conga_kill")]
20807 CongaKill,
20808 #[serde(rename = "player_initial_spawn")]
20809 PlayerInitialSpawn,
20810 #[serde(rename = "competitive_victory")]
20811 CompetitiveVictory,
20812 #[serde(rename = "competitive_stats_update")]
20813 CompetitiveStatsUpdate,
20814 #[serde(rename = "minigame_win")]
20815 MiniGameWin,
20816 #[serde(rename = "sentry_on_go_active")]
20817 SentryOnGoActive,
20818 #[serde(rename = "duck_xp_level_up")]
20819 DuckXpLevelUp,
20820 #[serde(rename = "questlog_opened")]
20821 QuestLogOpened,
20822 #[serde(rename = "schema_updated")]
20823 SchemaUpdated,
20824 #[serde(rename = "localplayer_pickup_weapon")]
20825 LocalPlayerPickupWeapon,
20826 #[serde(rename = "rd_player_score_points")]
20827 RdPlayerScorePoints,
20828 #[serde(rename = "demoman_det_stickies")]
20829 DemomanDetStickies,
20830 #[serde(rename = "quest_objective_completed")]
20831 QuestObjectiveCompleted,
20832 #[serde(rename = "player_score_changed")]
20833 PlayerScoreChanged,
20834 #[serde(rename = "killed_capping_player")]
20835 KilledCappingPlayer,
20836 #[serde(rename = "environmental_death")]
20837 EnvironmentalDeath,
20838 #[serde(rename = "projectile_direct_hit")]
20839 ProjectileDirectHit,
20840 #[serde(rename = "pass_get")]
20841 PassGet,
20842 #[serde(rename = "pass_score")]
20843 PassScore,
20844 #[serde(rename = "pass_free")]
20845 PassFree,
20846 #[serde(rename = "pass_pass_caught")]
20847 PassPassCaught,
20848 #[serde(rename = "pass_ball_stolen")]
20849 PassBallStolen,
20850 #[serde(rename = "pass_ball_blocked")]
20851 PassBallBlocked,
20852 #[serde(rename = "damage_prevented")]
20853 DamagePrevented,
20854 #[serde(rename = "halloween_boss_killed")]
20855 HalloweenBossKilled,
20856 #[serde(rename = "escaped_loot_island")]
20857 EscapedLootIsland,
20858 #[serde(rename = "tagged_player_as_it")]
20859 TaggedPlayerAsIt,
20860 #[serde(rename = "merasmus_stunned")]
20861 MerasmusStunned,
20862 #[serde(rename = "merasmus_prop_found")]
20863 MerasmusPropFound,
20864 #[serde(rename = "halloween_skeleton_killed")]
20865 HalloweenSkeletonKilled,
20866 #[serde(rename = "skeleton_killed_quest")]
20867 SkeletonKilledQuest,
20868 #[serde(rename = "skeleton_king_killed_quest")]
20869 SkeletonKingKilledQuest,
20870 #[serde(rename = "escape_hell")]
20871 EscapeHell,
20872 #[serde(rename = "cross_spectral_bridge")]
20873 CrossSpectralBridge,
20874 #[serde(rename = "minigame_won")]
20875 MiniGameWon,
20876 #[serde(rename = "respawn_ghost")]
20877 RespawnGhost,
20878 #[serde(rename = "kill_in_hell")]
20879 KillInHell,
20880 #[serde(rename = "halloween_duck_collected")]
20881 HalloweenDuckCollected,
20882 #[serde(rename = "special_score")]
20883 SpecialScore,
20884 #[serde(rename = "team_leader_killed")]
20885 TeamLeaderKilled,
20886 #[serde(rename = "halloween_soul_collected")]
20887 HalloweenSoulCollected,
20888 #[serde(rename = "recalculate_truce")]
20889 RecalculateTruce,
20890 #[serde(rename = "deadringer_cheat_death")]
20891 DeadRingerCheatDeath,
20892 #[serde(rename = "crossbow_heal")]
20893 CrossbowHeal,
20894 #[serde(rename = "damage_mitigated")]
20895 DamageMitigated,
20896 #[serde(rename = "payload_pushed")]
20897 PayloadPushed,
20898 #[serde(rename = "player_abandoned_match")]
20899 PlayerAbandonedMatch,
20900 #[serde(rename = "cl_drawline")]
20901 ClDrawline,
20902 #[serde(rename = "restart_timer_time")]
20903 RestartTimerTime,
20904 #[serde(rename = "winlimit_changed")]
20905 WinLimitChanged,
20906 #[serde(rename = "winpanel_show_scores")]
20907 WinPanelShowScores,
20908 #[serde(rename = "top_streams_request_finished")]
20909 TopStreamsRequestFinished,
20910 #[serde(rename = "competitive_state_changed")]
20911 CompetitiveStateChanged,
20912 #[serde(rename = "global_war_data_updated")]
20913 GlobalWarDataUpdated,
20914 #[serde(rename = "stop_watch_changed")]
20915 StopWatchChanged,
20916 #[serde(rename = "ds_stop")]
20917 DsStop,
20918 #[serde(rename = "ds_screenshot")]
20919 DsScreenshot,
20920 #[serde(rename = "show_match_summary")]
20921 ShowMatchSummary,
20922 #[serde(rename = "experience_changed")]
20923 ExperienceChanged,
20924 #[serde(rename = "begin_xp_lerp")]
20925 BeginXpLerp,
20926 #[serde(rename = "matchmaker_stats_updated")]
20927 MatchmakerStatsUpdated,
20928 #[serde(rename = "rematch_vote_period_over")]
20929 RematchVotePeriodOver,
20930 #[serde(rename = "rematch_failed_to_create")]
20931 RematchFailedToCreate,
20932 #[serde(rename = "player_rematch_change")]
20933 PlayerRematchChange,
20934 #[serde(rename = "ping_updated")]
20935 PingUpdated,
20936 #[serde(rename = "mmstats_updated")]
20937 MMStatsUpdated,
20938 #[serde(rename = "player_next_map_vote_change")]
20939 PlayerNextMapVoteChange,
20940 #[serde(rename = "vote_maps_changed")]
20941 VoteMapsChanged,
20942 #[serde(rename = "proto_def_changed")]
20943 ProtoDefChanged,
20944 #[serde(rename = "player_domination")]
20945 PlayerDomination,
20946 #[serde(rename = "player_rocketpack_pushed")]
20947 PlayerRocketPackPushed,
20948 #[serde(rename = "quest_request")]
20949 QuestRequest,
20950 #[serde(rename = "quest_response")]
20951 QuestResponse,
20952 #[serde(rename = "quest_progress")]
20953 QuestProgress,
20954 #[serde(rename = "projectile_removed")]
20955 ProjectileRemoved,
20956 #[serde(rename = "quest_map_data_changed")]
20957 QuestMapDataChanged,
20958 #[serde(rename = "gas_doused_player_ignited")]
20959 GasDousedPlayerIgnited,
20960 #[serde(rename = "quest_turn_in_state")]
20961 QuestTurnInState,
20962 #[serde(rename = "items_acknowledged")]
20963 ItemsAcknowledged,
20964 #[serde(rename = "capper_killed")]
20965 CapperKilled,
20966 #[serde(rename = "mainmenu_stabilized")]
20967 MainMenuStabilized,
20968 #[serde(rename = "world_status_changed")]
20969 WorldStatusChanged,
20970 #[serde(rename = "hltv_status")]
20971 HLTVStatus,
20972 #[serde(rename = "hltv_cameraman")]
20973 HLTVCameraman,
20974 #[serde(rename = "hltv_rank_camera")]
20975 HLTVRankCamera,
20976 #[serde(rename = "hltv_rank_entity")]
20977 HLTVRankEntity,
20978 #[serde(rename = "hltv_fixed")]
20979 HLTVFixed,
20980 #[serde(rename = "hltv_chase")]
20981 HLTVChase,
20982 #[serde(rename = "hltv_message")]
20983 HLTVMessage,
20984 #[serde(rename = "hltv_title")]
20985 HLTVTitle,
20986 #[serde(rename = "hltv_chat")]
20987 HLTVChat,
20988 #[serde(rename = "replay_startrecord")]
20989 ReplayStartRecord,
20990 #[serde(rename = "replay_sessioninfo")]
20991 ReplaySessionInfo,
20992 #[serde(rename = "replay_endrecord")]
20993 ReplayEndRecord,
20994 #[serde(rename = "replay_replaysavailable")]
20995 ReplayReplaysAvailable,
20996 #[serde(rename = "replay_servererror")]
20997 ReplayServerError,
20998 Unknown(String),
20999}
21000impl GameEventType {
21001 pub fn from_type_name(name: &str) -> Self {
21002 match name {
21003 "server_spawn" => GameEventType::ServerSpawn,
21004 "server_changelevel_failed" => GameEventType::ServerChangeLevelFailed,
21005 "server_shutdown" => GameEventType::ServerShutdown,
21006 "server_cvar" => GameEventType::ServerCvar,
21007 "server_message" => GameEventType::ServerMessage,
21008 "server_addban" => GameEventType::ServerAddBan,
21009 "server_removeban" => GameEventType::ServerRemoveBan,
21010 "player_connect" => GameEventType::PlayerConnect,
21011 "player_connect_client" => GameEventType::PlayerConnectClient,
21012 "player_info" => GameEventType::PlayerInfo,
21013 "player_disconnect" => GameEventType::PlayerDisconnect,
21014 "player_activate" => GameEventType::PlayerActivate,
21015 "player_say" => GameEventType::PlayerSay,
21016 "client_disconnect" => GameEventType::ClientDisconnect,
21017 "client_beginconnect" => GameEventType::ClientBeginConnect,
21018 "client_connected" => GameEventType::ClientConnected,
21019 "client_fullconnect" => GameEventType::ClientFullConnect,
21020 "host_quit" => GameEventType::HostQuit,
21021 "team_info" => GameEventType::TeamInfo,
21022 "team_score" => GameEventType::TeamScore,
21023 "teamplay_broadcast_audio" => GameEventType::TeamPlayBroadcastAudio,
21024 "player_team" => GameEventType::PlayerTeam,
21025 "player_class" => GameEventType::PlayerClass,
21026 "player_death" => GameEventType::PlayerDeath,
21027 "player_hurt" => GameEventType::PlayerHurt,
21028 "player_chat" => GameEventType::PlayerChat,
21029 "player_score" => GameEventType::PlayerScore,
21030 "player_spawn" => GameEventType::PlayerSpawn,
21031 "player_shoot" => GameEventType::PlayerShoot,
21032 "player_use" => GameEventType::PlayerUse,
21033 "player_changename" => GameEventType::PlayerChangeName,
21034 "player_hintmessage" => GameEventType::PlayerHintMessage,
21035 "base_player_teleported" => GameEventType::BasePlayerTeleported,
21036 "game_init" => GameEventType::GameInit,
21037 "game_newmap" => GameEventType::GameNewMap,
21038 "game_start" => GameEventType::GameStart,
21039 "game_end" => GameEventType::GameEnd,
21040 "round_start" => GameEventType::RoundStart,
21041 "round_end" => GameEventType::RoundEnd,
21042 "game_message" => GameEventType::GameMessage,
21043 "break_breakable" => GameEventType::BreakBreakable,
21044 "break_prop" => GameEventType::BreakProp,
21045 "entity_killed" => GameEventType::EntityKilled,
21046 "bonus_updated" => GameEventType::BonusUpdated,
21047 "achievement_event" => GameEventType::AchievementEvent,
21048 "achievement_increment" => GameEventType::AchievementIncrement,
21049 "physgun_pickup" => GameEventType::PhysgunPickup,
21050 "flare_ignite_npc" => GameEventType::FlareIgniteNpc,
21051 "helicopter_grenade_punt_miss" => GameEventType::HelicopterGrenadePuntMiss,
21052 "user_data_downloaded" => GameEventType::UserDataDownloaded,
21053 "ragdoll_dissolved" => GameEventType::RagdollDissolved,
21054 "hltv_changed_mode" => GameEventType::HLTVChangedMode,
21055 "hltv_changed_target" => GameEventType::HLTVChangedTarget,
21056 "vote_ended" => GameEventType::VoteEnded,
21057 "vote_started" => GameEventType::VoteStarted,
21058 "vote_changed" => GameEventType::VoteChanged,
21059 "vote_passed" => GameEventType::VotePassed,
21060 "vote_failed" => GameEventType::VoteFailed,
21061 "vote_cast" => GameEventType::VoteCast,
21062 "vote_options" => GameEventType::VoteOptions,
21063 "replay_saved" => GameEventType::ReplaySaved,
21064 "entered_performance_mode" => GameEventType::EnteredPerformanceMode,
21065 "browse_replays" => GameEventType::BrowseReplays,
21066 "replay_youtube_stats" => GameEventType::ReplayYoutubeStats,
21067 "inventory_updated" => GameEventType::InventoryUpdated,
21068 "cart_updated" => GameEventType::CartUpdated,
21069 "store_pricesheet_updated" => GameEventType::StorePriceSheetUpdated,
21070 "econ_inventory_connected" => GameEventType::EconInventoryConnected,
21071 "item_schema_initialized" => GameEventType::ItemSchemaInitialized,
21072 "gc_new_session" => GameEventType::GcNewSession,
21073 "gc_lost_session" => GameEventType::GcLostSession,
21074 "intro_finish" => GameEventType::IntroFinish,
21075 "intro_nextcamera" => GameEventType::IntroNextCamera,
21076 "player_changeclass" => GameEventType::PlayerChangeClass,
21077 "tf_map_time_remaining" => GameEventType::TfMapTimeRemaining,
21078 "tf_game_over" => GameEventType::TfGameOver,
21079 "ctf_flag_captured" => GameEventType::CtfFlagCaptured,
21080 "controlpoint_initialized" => GameEventType::ControlPointInitialized,
21081 "controlpoint_updateimages" => GameEventType::ControlPointUpdateImages,
21082 "controlpoint_updatelayout" => GameEventType::ControlPointUpdateLayout,
21083 "controlpoint_updatecapping" => GameEventType::ControlPointUpdateCapping,
21084 "controlpoint_updateowner" => GameEventType::ControlPointUpdateOwner,
21085 "controlpoint_starttouch" => GameEventType::ControlPointStartTouch,
21086 "controlpoint_endtouch" => GameEventType::ControlPointEndTouch,
21087 "controlpoint_pulse_element" => GameEventType::ControlPointPulseElement,
21088 "controlpoint_fake_capture" => GameEventType::ControlPointFakeCapture,
21089 "controlpoint_fake_capture_mult" => GameEventType::ControlPointFakeCaptureMultiplier,
21090 "teamplay_round_selected" => GameEventType::TeamPlayRoundSelected,
21091 "teamplay_round_start" => GameEventType::TeamPlayRoundStart,
21092 "teamplay_round_active" => GameEventType::TeamPlayRoundActive,
21093 "teamplay_waiting_begins" => GameEventType::TeamPlayWaitingBegins,
21094 "teamplay_waiting_ends" => GameEventType::TeamPlayWaitingEnds,
21095 "teamplay_waiting_abouttoend" => GameEventType::TeamPlayWaitingAboutToEnd,
21096 "teamplay_restart_round" => GameEventType::TeamPlayRestartRound,
21097 "teamplay_ready_restart" => GameEventType::TeamPlayReadyRestart,
21098 "teamplay_round_restart_seconds" => GameEventType::TeamPlayRoundRestartSeconds,
21099 "teamplay_team_ready" => GameEventType::TeamPlayTeamReady,
21100 "teamplay_round_win" => GameEventType::TeamPlayRoundWin,
21101 "teamplay_update_timer" => GameEventType::TeamPlayUpdateTimer,
21102 "teamplay_round_stalemate" => GameEventType::TeamPlayRoundStalemate,
21103 "teamplay_overtime_begin" => GameEventType::TeamPlayOvertimeBegin,
21104 "teamplay_overtime_end" => GameEventType::TeamPlayOvertimeEnd,
21105 "teamplay_suddendeath_begin" => GameEventType::TeamPlaySuddenDeathBegin,
21106 "teamplay_suddendeath_end" => GameEventType::TeamPlaySuddenDeathEnd,
21107 "teamplay_game_over" => GameEventType::TeamPlayGameOver,
21108 "teamplay_map_time_remaining" => GameEventType::TeamPlayMapTimeRemaining,
21109 "teamplay_timer_flash" => GameEventType::TeamPlayTimerFlash,
21110 "teamplay_timer_time_added" => GameEventType::TeamPlayTimerTimeAdded,
21111 "teamplay_point_startcapture" => GameEventType::TeamPlayPointStartCapture,
21112 "teamplay_point_captured" => GameEventType::TeamPlayPointCaptured,
21113 "teamplay_point_locked" => GameEventType::TeamPlayPointLocked,
21114 "teamplay_point_unlocked" => GameEventType::TeamPlayPointUnlocked,
21115 "teamplay_capture_broken" => GameEventType::TeamPlayCaptureBroken,
21116 "teamplay_capture_blocked" => GameEventType::TeamPlayCaptureBlocked,
21117 "teamplay_flag_event" => GameEventType::TeamPlayFlagEvent,
21118 "teamplay_win_panel" => GameEventType::TeamPlayWinPanel,
21119 "teamplay_teambalanced_player" => GameEventType::TeamPlayTeamBalancedPlayer,
21120 "teamplay_setup_finished" => GameEventType::TeamPlaySetupFinished,
21121 "teamplay_alert" => GameEventType::TeamPlayAlert,
21122 "training_complete" => GameEventType::TrainingComplete,
21123 "show_freezepanel" => GameEventType::ShowFreezePanel,
21124 "hide_freezepanel" => GameEventType::HideFreezePanel,
21125 "freezecam_started" => GameEventType::FreezeCamStarted,
21126 "localplayer_changeteam" => GameEventType::LocalPlayerChangeTeam,
21127 "localplayer_score_changed" => GameEventType::LocalPlayerScoreChanged,
21128 "localplayer_changeclass" => GameEventType::LocalPlayerChangeClass,
21129 "localplayer_respawn" => GameEventType::LocalPlayerRespawn,
21130 "building_info_changed" => GameEventType::BuildingInfoChanged,
21131 "localplayer_changedisguise" => GameEventType::LocalPlayerChangeDisguise,
21132 "player_account_changed" => GameEventType::PlayerAccountChanged,
21133 "spy_pda_reset" => GameEventType::SpyPdaReset,
21134 "flagstatus_update" => GameEventType::FlagStatusUpdate,
21135 "player_stats_updated" => GameEventType::PlayerStatsUpdated,
21136 "playing_commentary" => GameEventType::PlayingCommentary,
21137 "player_chargedeployed" => GameEventType::PlayerChargeDeployed,
21138 "player_builtobject" => GameEventType::PlayerBuiltObject,
21139 "player_upgradedobject" => GameEventType::PlayerUpgradedObject,
21140 "player_carryobject" => GameEventType::PlayerCarryObject,
21141 "player_dropobject" => GameEventType::PlayerDropObject,
21142 "object_removed" => GameEventType::ObjectRemoved,
21143 "object_destroyed" => GameEventType::ObjectDestroyed,
21144 "object_detonated" => GameEventType::ObjectDetonated,
21145 "achievement_earned" => GameEventType::AchievementEarned,
21146 "spec_target_updated" => GameEventType::SpecTargetUpdated,
21147 "tournament_stateupdate" => GameEventType::TournamentStateUpdate,
21148 "tournament_enablecountdown" => GameEventType::TournamentEnableCountdown,
21149 "player_calledformedic" => GameEventType::PlayerCalledForMedic,
21150 "player_askedforball" => GameEventType::PlayerAskedForBall,
21151 "localplayer_becameobserver" => GameEventType::LocalPlayerBecameObserver,
21152 "player_ignited_inv" => GameEventType::PlayerIgnitedInv,
21153 "player_ignited" => GameEventType::PlayerIgnited,
21154 "player_extinguished" => GameEventType::PlayerExtinguished,
21155 "player_teleported" => GameEventType::PlayerTeleported,
21156 "player_healedmediccall" => GameEventType::PlayerHealedMedicCall,
21157 "localplayer_chargeready" => GameEventType::LocalPlayerChargeReady,
21158 "localplayer_winddown" => GameEventType::LocalPlayerWindDown,
21159 "player_invulned" => GameEventType::PlayerInvulned,
21160 "escort_speed" => GameEventType::EscortSpeed,
21161 "escort_progress" => GameEventType::EscortProgress,
21162 "escort_recede" => GameEventType::EscortRecede,
21163 "gameui_activated" => GameEventType::GameUIActivated,
21164 "gameui_hidden" => GameEventType::GameUIHidden,
21165 "player_escort_score" => GameEventType::PlayerEscortScore,
21166 "player_healonhit" => GameEventType::PlayerHealOnHit,
21167 "player_stealsandvich" => GameEventType::PlayerStealSandvich,
21168 "show_class_layout" => GameEventType::ShowClassLayout,
21169 "show_vs_panel" => GameEventType::ShowVsPanel,
21170 "player_damaged" => GameEventType::PlayerDamaged,
21171 "arena_player_notification" => GameEventType::ArenaPlayerNotification,
21172 "arena_match_maxstreak" => GameEventType::ArenaMatchMaxStreak,
21173 "arena_round_start" => GameEventType::ArenaRoundStart,
21174 "arena_win_panel" => GameEventType::ArenaWinPanel,
21175 "pve_win_panel" => GameEventType::PveWinPanel,
21176 "air_dash" => GameEventType::AirDash,
21177 "landed" => GameEventType::Landed,
21178 "player_damage_dodged" => GameEventType::PlayerDamageDodged,
21179 "player_stunned" => GameEventType::PlayerStunned,
21180 "scout_grand_slam" => GameEventType::ScoutGrandSlam,
21181 "scout_slamdoll_landed" => GameEventType::ScoutSlamdollLanded,
21182 "arrow_impact" => GameEventType::ArrowImpact,
21183 "player_jarated" => GameEventType::PlayerJarated,
21184 "player_jarated_fade" => GameEventType::PlayerJaratedFade,
21185 "player_shield_blocked" => GameEventType::PlayerShieldBlocked,
21186 "player_pinned" => GameEventType::PlayerPinned,
21187 "player_healedbymedic" => GameEventType::PlayerHealedByMedic,
21188 "player_sapped_object" => GameEventType::PlayerSappedObject,
21189 "item_found" => GameEventType::ItemFound,
21190 "show_annotation" => GameEventType::ShowAnnotation,
21191 "hide_annotation" => GameEventType::HideAnnotation,
21192 "post_inventory_application" => GameEventType::PostInventoryApplication,
21193 "controlpoint_unlock_updated" => GameEventType::ControlPointUnlockUpdated,
21194 "deploy_buff_banner" => GameEventType::DeployBuffBanner,
21195 "player_buff" => GameEventType::PlayerBuff,
21196 "medic_death" => GameEventType::MedicDeath,
21197 "overtime_nag" => GameEventType::OvertimeNag,
21198 "teams_changed" => GameEventType::TeamsChanged,
21199 "halloween_pumpkin_grab" => GameEventType::HalloweenPumpkinGrab,
21200 "rocket_jump" => GameEventType::RocketJump,
21201 "rocket_jump_landed" => GameEventType::RocketJumpLanded,
21202 "sticky_jump" => GameEventType::StickyJump,
21203 "sticky_jump_landed" => GameEventType::StickyJumpLanded,
21204 "rocketpack_launch" => GameEventType::RocketPackLaunch,
21205 "rocketpack_landed" => GameEventType::RocketPackLanded,
21206 "medic_defended" => GameEventType::MedicDefended,
21207 "localplayer_healed" => GameEventType::LocalPlayerHealed,
21208 "player_destroyed_pipebomb" => GameEventType::PlayerDestroyedPipeBomb,
21209 "object_deflected" => GameEventType::ObjectDeflected,
21210 "player_mvp" => GameEventType::PlayerMvp,
21211 "raid_spawn_mob" => GameEventType::RaidSpawnMob,
21212 "raid_spawn_squad" => GameEventType::RaidSpawnSquad,
21213 "nav_blocked" => GameEventType::NavBlocked,
21214 "path_track_passed" => GameEventType::PathTrackPassed,
21215 "num_cappers_changed" => GameEventType::NumCappersChanged,
21216 "player_regenerate" => GameEventType::PlayerRegenerate,
21217 "update_status_item" => GameEventType::UpdateStatusItem,
21218 "stats_resetround" => GameEventType::StatsResetRound,
21219 "scorestats_accumulated_update" => GameEventType::ScoreStatsAccumulatedUpdate,
21220 "scorestats_accumulated_reset" => GameEventType::ScoreStatsAccumulatedReset,
21221 "achievement_earned_local" => GameEventType::AchievementEarnedLocal,
21222 "player_healed" => GameEventType::PlayerHealed,
21223 "building_healed" => GameEventType::BuildingHealed,
21224 "item_pickup" => GameEventType::ItemPickup,
21225 "duel_status" => GameEventType::DuelStatus,
21226 "fish_notice" => GameEventType::FishNotice,
21227 "fish_notice__arm" => GameEventType::FishNoticeArm,
21228 "slap_notice" => GameEventType::SlapNotice,
21229 "throwable_hit" => GameEventType::ThrowableHit,
21230 "pumpkin_lord_summoned" => GameEventType::PumpkinLordSummoned,
21231 "pumpkin_lord_killed" => GameEventType::PumpkinLordKilled,
21232 "merasmus_summoned" => GameEventType::MerasmusSummoned,
21233 "merasmus_killed" => GameEventType::MerasmusKilled,
21234 "merasmus_escape_warning" => GameEventType::MerasmusEscapeWarning,
21235 "merasmus_escaped" => GameEventType::MerasmusEscaped,
21236 "eyeball_boss_summoned" => GameEventType::EyeballBossSummoned,
21237 "eyeball_boss_stunned" => GameEventType::EyeballBossStunned,
21238 "eyeball_boss_killed" => GameEventType::EyeballBossKilled,
21239 "eyeball_boss_killer" => GameEventType::EyeballBossKiller,
21240 "eyeball_boss_escape_imminent" => GameEventType::EyeballBossEscapeImminent,
21241 "eyeball_boss_escaped" => GameEventType::EyeballBossEscaped,
21242 "npc_hurt" => GameEventType::NpcHurt,
21243 "controlpoint_timer_updated" => GameEventType::ControlPointTimerUpdated,
21244 "player_highfive_start" => GameEventType::PlayerHighFiveStart,
21245 "player_highfive_cancel" => GameEventType::PlayerHighFiveCancel,
21246 "player_highfive_success" => GameEventType::PlayerHighFiveSuccess,
21247 "player_bonuspoints" => GameEventType::PlayerBonusPoints,
21248 "player_upgraded" => GameEventType::PlayerUpgraded,
21249 "player_buyback" => GameEventType::PlayerBuyback,
21250 "player_used_powerup_bottle" => GameEventType::PlayerUsedPowerUpBottle,
21251 "christmas_gift_grab" => GameEventType::ChristmasGiftGrab,
21252 "player_killed_achievement_zone" => GameEventType::PlayerKilledAchievementZone,
21253 "party_updated" => GameEventType::PartyUpdated,
21254 "party_pref_changed" => GameEventType::PartyPrefChanged,
21255 "party_criteria_changed" => GameEventType::PartyCriteriaChanged,
21256 "party_invites_changed" => GameEventType::PartyInvitesChanged,
21257 "party_queue_state_changed" => GameEventType::PartyQueueStateChanged,
21258 "party_chat" => GameEventType::PartyChat,
21259 "party_member_join" => GameEventType::PartyMemberJoin,
21260 "party_member_leave" => GameEventType::PartyMemberLeave,
21261 "match_invites_updated" => GameEventType::MatchInvitesUpdated,
21262 "lobby_updated" => GameEventType::LobbyUpdated,
21263 "mvm_mission_update" => GameEventType::MvmMissionUpdate,
21264 "recalculate_holidays" => GameEventType::RecalculateHolidays,
21265 "player_currency_changed" => GameEventType::PlayerCurrencyChanged,
21266 "doomsday_rocket_open" => GameEventType::DoomsdayRocketOpen,
21267 "remove_nemesis_relationships" => GameEventType::RemoveNemesisRelationships,
21268 "mvm_creditbonus_wave" => GameEventType::MvmCreditBonusWave,
21269 "mvm_creditbonus_all" => GameEventType::MvmCreditBonusAll,
21270 "mvm_creditbonus_all_advanced" => GameEventType::MvmCreditBonusAllAdvanced,
21271 "mvm_quick_sentry_upgrade" => GameEventType::MvmQuickSentryUpgrade,
21272 "mvm_tank_destroyed_by_players" => GameEventType::MvmTankDestroyedByPlayers,
21273 "mvm_kill_robot_delivering_bomb" => GameEventType::MvmKillRobotDeliveringBomb,
21274 "mvm_pickup_currency" => GameEventType::MvmPickupCurrency,
21275 "mvm_bomb_carrier_killed" => GameEventType::MvmBombCarrierKilled,
21276 "mvm_sentrybuster_detonate" => GameEventType::MvmSentryBusterDetonate,
21277 "mvm_scout_marked_for_death" => GameEventType::MvmScoutMarkedForDeath,
21278 "mvm_medic_powerup_shared" => GameEventType::MvmMedicPowerUpShared,
21279 "mvm_begin_wave" => GameEventType::MvmBeginWave,
21280 "mvm_wave_complete" => GameEventType::MvmWaveComplete,
21281 "mvm_mission_complete" => GameEventType::MvmMissionComplete,
21282 "mvm_bomb_reset_by_player" => GameEventType::MvmBombResetByPlayer,
21283 "mvm_bomb_alarm_triggered" => GameEventType::MvmBombAlarmTriggered,
21284 "mvm_bomb_deploy_reset_by_player" => GameEventType::MvmBombDeployResetByPlayer,
21285 "mvm_wave_failed" => GameEventType::MvmWaveFailed,
21286 "mvm_reset_stats" => GameEventType::MvmResetStats,
21287 "damage_resisted" => GameEventType::DamageResisted,
21288 "revive_player_notify" => GameEventType::RevivePlayerNotify,
21289 "revive_player_stopped" => GameEventType::RevivePlayerStopped,
21290 "revive_player_complete" => GameEventType::RevivePlayerComplete,
21291 "player_turned_to_ghost" => GameEventType::PlayerTurnedToGhost,
21292 "medigun_shield_blocked_damage" => GameEventType::MedigunShieldBlockedDamage,
21293 "mvm_adv_wave_complete_no_gates" => GameEventType::MvmAdvWaveCompleteNoGates,
21294 "mvm_sniper_headshot_currency" => GameEventType::MvmSniperHeadshotCurrency,
21295 "mvm_mannhattan_pit" => GameEventType::MvmMannhattanPit,
21296 "flag_carried_in_detection_zone" => GameEventType::FlagCarriedInDetectionZone,
21297 "mvm_adv_wave_killed_stun_radio" => GameEventType::MvmAdvWaveKilledStunRadio,
21298 "player_directhit_stun" => GameEventType::PlayerDirectHitStun,
21299 "mvm_sentrybuster_killed" => GameEventType::MvmSentryBusterKilled,
21300 "upgrades_file_changed" => GameEventType::UpgradesFileChanged,
21301 "rd_team_points_changed" => GameEventType::RdTeamPointsChanged,
21302 "rd_rules_state_changed" => GameEventType::RdRulesStateChanged,
21303 "rd_robot_killed" => GameEventType::RdRobotKilled,
21304 "rd_robot_impact" => GameEventType::RdRobotImpact,
21305 "teamplay_pre_round_time_left" => GameEventType::TeamPlayPreRoundTimeLeft,
21306 "parachute_deploy" => GameEventType::ParachuteDeploy,
21307 "parachute_holster" => GameEventType::ParachuteHolster,
21308 "kill_refills_meter" => GameEventType::KillRefillsMeter,
21309 "rps_taunt_event" => GameEventType::RpsTauntEvent,
21310 "conga_kill" => GameEventType::CongaKill,
21311 "player_initial_spawn" => GameEventType::PlayerInitialSpawn,
21312 "competitive_victory" => GameEventType::CompetitiveVictory,
21313 "competitive_stats_update" => GameEventType::CompetitiveStatsUpdate,
21314 "minigame_win" => GameEventType::MiniGameWin,
21315 "sentry_on_go_active" => GameEventType::SentryOnGoActive,
21316 "duck_xp_level_up" => GameEventType::DuckXpLevelUp,
21317 "questlog_opened" => GameEventType::QuestLogOpened,
21318 "schema_updated" => GameEventType::SchemaUpdated,
21319 "localplayer_pickup_weapon" => GameEventType::LocalPlayerPickupWeapon,
21320 "rd_player_score_points" => GameEventType::RdPlayerScorePoints,
21321 "demoman_det_stickies" => GameEventType::DemomanDetStickies,
21322 "quest_objective_completed" => GameEventType::QuestObjectiveCompleted,
21323 "player_score_changed" => GameEventType::PlayerScoreChanged,
21324 "killed_capping_player" => GameEventType::KilledCappingPlayer,
21325 "environmental_death" => GameEventType::EnvironmentalDeath,
21326 "projectile_direct_hit" => GameEventType::ProjectileDirectHit,
21327 "pass_get" => GameEventType::PassGet,
21328 "pass_score" => GameEventType::PassScore,
21329 "pass_free" => GameEventType::PassFree,
21330 "pass_pass_caught" => GameEventType::PassPassCaught,
21331 "pass_ball_stolen" => GameEventType::PassBallStolen,
21332 "pass_ball_blocked" => GameEventType::PassBallBlocked,
21333 "damage_prevented" => GameEventType::DamagePrevented,
21334 "halloween_boss_killed" => GameEventType::HalloweenBossKilled,
21335 "escaped_loot_island" => GameEventType::EscapedLootIsland,
21336 "tagged_player_as_it" => GameEventType::TaggedPlayerAsIt,
21337 "merasmus_stunned" => GameEventType::MerasmusStunned,
21338 "merasmus_prop_found" => GameEventType::MerasmusPropFound,
21339 "halloween_skeleton_killed" => GameEventType::HalloweenSkeletonKilled,
21340 "skeleton_killed_quest" => GameEventType::SkeletonKilledQuest,
21341 "skeleton_king_killed_quest" => GameEventType::SkeletonKingKilledQuest,
21342 "escape_hell" => GameEventType::EscapeHell,
21343 "cross_spectral_bridge" => GameEventType::CrossSpectralBridge,
21344 "minigame_won" => GameEventType::MiniGameWon,
21345 "respawn_ghost" => GameEventType::RespawnGhost,
21346 "kill_in_hell" => GameEventType::KillInHell,
21347 "halloween_duck_collected" => GameEventType::HalloweenDuckCollected,
21348 "special_score" => GameEventType::SpecialScore,
21349 "team_leader_killed" => GameEventType::TeamLeaderKilled,
21350 "halloween_soul_collected" => GameEventType::HalloweenSoulCollected,
21351 "recalculate_truce" => GameEventType::RecalculateTruce,
21352 "deadringer_cheat_death" => GameEventType::DeadRingerCheatDeath,
21353 "crossbow_heal" => GameEventType::CrossbowHeal,
21354 "damage_mitigated" => GameEventType::DamageMitigated,
21355 "payload_pushed" => GameEventType::PayloadPushed,
21356 "player_abandoned_match" => GameEventType::PlayerAbandonedMatch,
21357 "cl_drawline" => GameEventType::ClDrawline,
21358 "restart_timer_time" => GameEventType::RestartTimerTime,
21359 "winlimit_changed" => GameEventType::WinLimitChanged,
21360 "winpanel_show_scores" => GameEventType::WinPanelShowScores,
21361 "top_streams_request_finished" => GameEventType::TopStreamsRequestFinished,
21362 "competitive_state_changed" => GameEventType::CompetitiveStateChanged,
21363 "global_war_data_updated" => GameEventType::GlobalWarDataUpdated,
21364 "stop_watch_changed" => GameEventType::StopWatchChanged,
21365 "ds_stop" => GameEventType::DsStop,
21366 "ds_screenshot" => GameEventType::DsScreenshot,
21367 "show_match_summary" => GameEventType::ShowMatchSummary,
21368 "experience_changed" => GameEventType::ExperienceChanged,
21369 "begin_xp_lerp" => GameEventType::BeginXpLerp,
21370 "matchmaker_stats_updated" => GameEventType::MatchmakerStatsUpdated,
21371 "rematch_vote_period_over" => GameEventType::RematchVotePeriodOver,
21372 "rematch_failed_to_create" => GameEventType::RematchFailedToCreate,
21373 "player_rematch_change" => GameEventType::PlayerRematchChange,
21374 "ping_updated" => GameEventType::PingUpdated,
21375 "mmstats_updated" => GameEventType::MMStatsUpdated,
21376 "player_next_map_vote_change" => GameEventType::PlayerNextMapVoteChange,
21377 "vote_maps_changed" => GameEventType::VoteMapsChanged,
21378 "proto_def_changed" => GameEventType::ProtoDefChanged,
21379 "player_domination" => GameEventType::PlayerDomination,
21380 "player_rocketpack_pushed" => GameEventType::PlayerRocketPackPushed,
21381 "quest_request" => GameEventType::QuestRequest,
21382 "quest_response" => GameEventType::QuestResponse,
21383 "quest_progress" => GameEventType::QuestProgress,
21384 "projectile_removed" => GameEventType::ProjectileRemoved,
21385 "quest_map_data_changed" => GameEventType::QuestMapDataChanged,
21386 "gas_doused_player_ignited" => GameEventType::GasDousedPlayerIgnited,
21387 "quest_turn_in_state" => GameEventType::QuestTurnInState,
21388 "items_acknowledged" => GameEventType::ItemsAcknowledged,
21389 "capper_killed" => GameEventType::CapperKilled,
21390 "mainmenu_stabilized" => GameEventType::MainMenuStabilized,
21391 "world_status_changed" => GameEventType::WorldStatusChanged,
21392 "hltv_status" => GameEventType::HLTVStatus,
21393 "hltv_cameraman" => GameEventType::HLTVCameraman,
21394 "hltv_rank_camera" => GameEventType::HLTVRankCamera,
21395 "hltv_rank_entity" => GameEventType::HLTVRankEntity,
21396 "hltv_fixed" => GameEventType::HLTVFixed,
21397 "hltv_chase" => GameEventType::HLTVChase,
21398 "hltv_message" => GameEventType::HLTVMessage,
21399 "hltv_title" => GameEventType::HLTVTitle,
21400 "hltv_chat" => GameEventType::HLTVChat,
21401 "replay_startrecord" => GameEventType::ReplayStartRecord,
21402 "replay_sessioninfo" => GameEventType::ReplaySessionInfo,
21403 "replay_endrecord" => GameEventType::ReplayEndRecord,
21404 "replay_replaysavailable" => GameEventType::ReplayReplaysAvailable,
21405 "replay_servererror" => GameEventType::ReplayServerError,
21406 ty => GameEventType::Unknown(ty.into()),
21407 }
21408 }
21409 pub fn as_str(&self) -> &str {
21410 match self {
21411 GameEventType::ServerSpawn => "server_spawn",
21412 GameEventType::ServerChangeLevelFailed => "server_changelevel_failed",
21413 GameEventType::ServerShutdown => "server_shutdown",
21414 GameEventType::ServerCvar => "server_cvar",
21415 GameEventType::ServerMessage => "server_message",
21416 GameEventType::ServerAddBan => "server_addban",
21417 GameEventType::ServerRemoveBan => "server_removeban",
21418 GameEventType::PlayerConnect => "player_connect",
21419 GameEventType::PlayerConnectClient => "player_connect_client",
21420 GameEventType::PlayerInfo => "player_info",
21421 GameEventType::PlayerDisconnect => "player_disconnect",
21422 GameEventType::PlayerActivate => "player_activate",
21423 GameEventType::PlayerSay => "player_say",
21424 GameEventType::ClientDisconnect => "client_disconnect",
21425 GameEventType::ClientBeginConnect => "client_beginconnect",
21426 GameEventType::ClientConnected => "client_connected",
21427 GameEventType::ClientFullConnect => "client_fullconnect",
21428 GameEventType::HostQuit => "host_quit",
21429 GameEventType::TeamInfo => "team_info",
21430 GameEventType::TeamScore => "team_score",
21431 GameEventType::TeamPlayBroadcastAudio => "teamplay_broadcast_audio",
21432 GameEventType::PlayerTeam => "player_team",
21433 GameEventType::PlayerClass => "player_class",
21434 GameEventType::PlayerDeath => "player_death",
21435 GameEventType::PlayerHurt => "player_hurt",
21436 GameEventType::PlayerChat => "player_chat",
21437 GameEventType::PlayerScore => "player_score",
21438 GameEventType::PlayerSpawn => "player_spawn",
21439 GameEventType::PlayerShoot => "player_shoot",
21440 GameEventType::PlayerUse => "player_use",
21441 GameEventType::PlayerChangeName => "player_changename",
21442 GameEventType::PlayerHintMessage => "player_hintmessage",
21443 GameEventType::BasePlayerTeleported => "base_player_teleported",
21444 GameEventType::GameInit => "game_init",
21445 GameEventType::GameNewMap => "game_newmap",
21446 GameEventType::GameStart => "game_start",
21447 GameEventType::GameEnd => "game_end",
21448 GameEventType::RoundStart => "round_start",
21449 GameEventType::RoundEnd => "round_end",
21450 GameEventType::GameMessage => "game_message",
21451 GameEventType::BreakBreakable => "break_breakable",
21452 GameEventType::BreakProp => "break_prop",
21453 GameEventType::EntityKilled => "entity_killed",
21454 GameEventType::BonusUpdated => "bonus_updated",
21455 GameEventType::AchievementEvent => "achievement_event",
21456 GameEventType::AchievementIncrement => "achievement_increment",
21457 GameEventType::PhysgunPickup => "physgun_pickup",
21458 GameEventType::FlareIgniteNpc => "flare_ignite_npc",
21459 GameEventType::HelicopterGrenadePuntMiss => "helicopter_grenade_punt_miss",
21460 GameEventType::UserDataDownloaded => "user_data_downloaded",
21461 GameEventType::RagdollDissolved => "ragdoll_dissolved",
21462 GameEventType::HLTVChangedMode => "hltv_changed_mode",
21463 GameEventType::HLTVChangedTarget => "hltv_changed_target",
21464 GameEventType::VoteEnded => "vote_ended",
21465 GameEventType::VoteStarted => "vote_started",
21466 GameEventType::VoteChanged => "vote_changed",
21467 GameEventType::VotePassed => "vote_passed",
21468 GameEventType::VoteFailed => "vote_failed",
21469 GameEventType::VoteCast => "vote_cast",
21470 GameEventType::VoteOptions => "vote_options",
21471 GameEventType::ReplaySaved => "replay_saved",
21472 GameEventType::EnteredPerformanceMode => "entered_performance_mode",
21473 GameEventType::BrowseReplays => "browse_replays",
21474 GameEventType::ReplayYoutubeStats => "replay_youtube_stats",
21475 GameEventType::InventoryUpdated => "inventory_updated",
21476 GameEventType::CartUpdated => "cart_updated",
21477 GameEventType::StorePriceSheetUpdated => "store_pricesheet_updated",
21478 GameEventType::EconInventoryConnected => "econ_inventory_connected",
21479 GameEventType::ItemSchemaInitialized => "item_schema_initialized",
21480 GameEventType::GcNewSession => "gc_new_session",
21481 GameEventType::GcLostSession => "gc_lost_session",
21482 GameEventType::IntroFinish => "intro_finish",
21483 GameEventType::IntroNextCamera => "intro_nextcamera",
21484 GameEventType::PlayerChangeClass => "player_changeclass",
21485 GameEventType::TfMapTimeRemaining => "tf_map_time_remaining",
21486 GameEventType::TfGameOver => "tf_game_over",
21487 GameEventType::CtfFlagCaptured => "ctf_flag_captured",
21488 GameEventType::ControlPointInitialized => "controlpoint_initialized",
21489 GameEventType::ControlPointUpdateImages => "controlpoint_updateimages",
21490 GameEventType::ControlPointUpdateLayout => "controlpoint_updatelayout",
21491 GameEventType::ControlPointUpdateCapping => "controlpoint_updatecapping",
21492 GameEventType::ControlPointUpdateOwner => "controlpoint_updateowner",
21493 GameEventType::ControlPointStartTouch => "controlpoint_starttouch",
21494 GameEventType::ControlPointEndTouch => "controlpoint_endtouch",
21495 GameEventType::ControlPointPulseElement => "controlpoint_pulse_element",
21496 GameEventType::ControlPointFakeCapture => "controlpoint_fake_capture",
21497 GameEventType::ControlPointFakeCaptureMultiplier => "controlpoint_fake_capture_mult",
21498 GameEventType::TeamPlayRoundSelected => "teamplay_round_selected",
21499 GameEventType::TeamPlayRoundStart => "teamplay_round_start",
21500 GameEventType::TeamPlayRoundActive => "teamplay_round_active",
21501 GameEventType::TeamPlayWaitingBegins => "teamplay_waiting_begins",
21502 GameEventType::TeamPlayWaitingEnds => "teamplay_waiting_ends",
21503 GameEventType::TeamPlayWaitingAboutToEnd => "teamplay_waiting_abouttoend",
21504 GameEventType::TeamPlayRestartRound => "teamplay_restart_round",
21505 GameEventType::TeamPlayReadyRestart => "teamplay_ready_restart",
21506 GameEventType::TeamPlayRoundRestartSeconds => "teamplay_round_restart_seconds",
21507 GameEventType::TeamPlayTeamReady => "teamplay_team_ready",
21508 GameEventType::TeamPlayRoundWin => "teamplay_round_win",
21509 GameEventType::TeamPlayUpdateTimer => "teamplay_update_timer",
21510 GameEventType::TeamPlayRoundStalemate => "teamplay_round_stalemate",
21511 GameEventType::TeamPlayOvertimeBegin => "teamplay_overtime_begin",
21512 GameEventType::TeamPlayOvertimeEnd => "teamplay_overtime_end",
21513 GameEventType::TeamPlaySuddenDeathBegin => "teamplay_suddendeath_begin",
21514 GameEventType::TeamPlaySuddenDeathEnd => "teamplay_suddendeath_end",
21515 GameEventType::TeamPlayGameOver => "teamplay_game_over",
21516 GameEventType::TeamPlayMapTimeRemaining => "teamplay_map_time_remaining",
21517 GameEventType::TeamPlayTimerFlash => "teamplay_timer_flash",
21518 GameEventType::TeamPlayTimerTimeAdded => "teamplay_timer_time_added",
21519 GameEventType::TeamPlayPointStartCapture => "teamplay_point_startcapture",
21520 GameEventType::TeamPlayPointCaptured => "teamplay_point_captured",
21521 GameEventType::TeamPlayPointLocked => "teamplay_point_locked",
21522 GameEventType::TeamPlayPointUnlocked => "teamplay_point_unlocked",
21523 GameEventType::TeamPlayCaptureBroken => "teamplay_capture_broken",
21524 GameEventType::TeamPlayCaptureBlocked => "teamplay_capture_blocked",
21525 GameEventType::TeamPlayFlagEvent => "teamplay_flag_event",
21526 GameEventType::TeamPlayWinPanel => "teamplay_win_panel",
21527 GameEventType::TeamPlayTeamBalancedPlayer => "teamplay_teambalanced_player",
21528 GameEventType::TeamPlaySetupFinished => "teamplay_setup_finished",
21529 GameEventType::TeamPlayAlert => "teamplay_alert",
21530 GameEventType::TrainingComplete => "training_complete",
21531 GameEventType::ShowFreezePanel => "show_freezepanel",
21532 GameEventType::HideFreezePanel => "hide_freezepanel",
21533 GameEventType::FreezeCamStarted => "freezecam_started",
21534 GameEventType::LocalPlayerChangeTeam => "localplayer_changeteam",
21535 GameEventType::LocalPlayerScoreChanged => "localplayer_score_changed",
21536 GameEventType::LocalPlayerChangeClass => "localplayer_changeclass",
21537 GameEventType::LocalPlayerRespawn => "localplayer_respawn",
21538 GameEventType::BuildingInfoChanged => "building_info_changed",
21539 GameEventType::LocalPlayerChangeDisguise => "localplayer_changedisguise",
21540 GameEventType::PlayerAccountChanged => "player_account_changed",
21541 GameEventType::SpyPdaReset => "spy_pda_reset",
21542 GameEventType::FlagStatusUpdate => "flagstatus_update",
21543 GameEventType::PlayerStatsUpdated => "player_stats_updated",
21544 GameEventType::PlayingCommentary => "playing_commentary",
21545 GameEventType::PlayerChargeDeployed => "player_chargedeployed",
21546 GameEventType::PlayerBuiltObject => "player_builtobject",
21547 GameEventType::PlayerUpgradedObject => "player_upgradedobject",
21548 GameEventType::PlayerCarryObject => "player_carryobject",
21549 GameEventType::PlayerDropObject => "player_dropobject",
21550 GameEventType::ObjectRemoved => "object_removed",
21551 GameEventType::ObjectDestroyed => "object_destroyed",
21552 GameEventType::ObjectDetonated => "object_detonated",
21553 GameEventType::AchievementEarned => "achievement_earned",
21554 GameEventType::SpecTargetUpdated => "spec_target_updated",
21555 GameEventType::TournamentStateUpdate => "tournament_stateupdate",
21556 GameEventType::TournamentEnableCountdown => "tournament_enablecountdown",
21557 GameEventType::PlayerCalledForMedic => "player_calledformedic",
21558 GameEventType::PlayerAskedForBall => "player_askedforball",
21559 GameEventType::LocalPlayerBecameObserver => "localplayer_becameobserver",
21560 GameEventType::PlayerIgnitedInv => "player_ignited_inv",
21561 GameEventType::PlayerIgnited => "player_ignited",
21562 GameEventType::PlayerExtinguished => "player_extinguished",
21563 GameEventType::PlayerTeleported => "player_teleported",
21564 GameEventType::PlayerHealedMedicCall => "player_healedmediccall",
21565 GameEventType::LocalPlayerChargeReady => "localplayer_chargeready",
21566 GameEventType::LocalPlayerWindDown => "localplayer_winddown",
21567 GameEventType::PlayerInvulned => "player_invulned",
21568 GameEventType::EscortSpeed => "escort_speed",
21569 GameEventType::EscortProgress => "escort_progress",
21570 GameEventType::EscortRecede => "escort_recede",
21571 GameEventType::GameUIActivated => "gameui_activated",
21572 GameEventType::GameUIHidden => "gameui_hidden",
21573 GameEventType::PlayerEscortScore => "player_escort_score",
21574 GameEventType::PlayerHealOnHit => "player_healonhit",
21575 GameEventType::PlayerStealSandvich => "player_stealsandvich",
21576 GameEventType::ShowClassLayout => "show_class_layout",
21577 GameEventType::ShowVsPanel => "show_vs_panel",
21578 GameEventType::PlayerDamaged => "player_damaged",
21579 GameEventType::ArenaPlayerNotification => "arena_player_notification",
21580 GameEventType::ArenaMatchMaxStreak => "arena_match_maxstreak",
21581 GameEventType::ArenaRoundStart => "arena_round_start",
21582 GameEventType::ArenaWinPanel => "arena_win_panel",
21583 GameEventType::PveWinPanel => "pve_win_panel",
21584 GameEventType::AirDash => "air_dash",
21585 GameEventType::Landed => "landed",
21586 GameEventType::PlayerDamageDodged => "player_damage_dodged",
21587 GameEventType::PlayerStunned => "player_stunned",
21588 GameEventType::ScoutGrandSlam => "scout_grand_slam",
21589 GameEventType::ScoutSlamdollLanded => "scout_slamdoll_landed",
21590 GameEventType::ArrowImpact => "arrow_impact",
21591 GameEventType::PlayerJarated => "player_jarated",
21592 GameEventType::PlayerJaratedFade => "player_jarated_fade",
21593 GameEventType::PlayerShieldBlocked => "player_shield_blocked",
21594 GameEventType::PlayerPinned => "player_pinned",
21595 GameEventType::PlayerHealedByMedic => "player_healedbymedic",
21596 GameEventType::PlayerSappedObject => "player_sapped_object",
21597 GameEventType::ItemFound => "item_found",
21598 GameEventType::ShowAnnotation => "show_annotation",
21599 GameEventType::HideAnnotation => "hide_annotation",
21600 GameEventType::PostInventoryApplication => "post_inventory_application",
21601 GameEventType::ControlPointUnlockUpdated => "controlpoint_unlock_updated",
21602 GameEventType::DeployBuffBanner => "deploy_buff_banner",
21603 GameEventType::PlayerBuff => "player_buff",
21604 GameEventType::MedicDeath => "medic_death",
21605 GameEventType::OvertimeNag => "overtime_nag",
21606 GameEventType::TeamsChanged => "teams_changed",
21607 GameEventType::HalloweenPumpkinGrab => "halloween_pumpkin_grab",
21608 GameEventType::RocketJump => "rocket_jump",
21609 GameEventType::RocketJumpLanded => "rocket_jump_landed",
21610 GameEventType::StickyJump => "sticky_jump",
21611 GameEventType::StickyJumpLanded => "sticky_jump_landed",
21612 GameEventType::RocketPackLaunch => "rocketpack_launch",
21613 GameEventType::RocketPackLanded => "rocketpack_landed",
21614 GameEventType::MedicDefended => "medic_defended",
21615 GameEventType::LocalPlayerHealed => "localplayer_healed",
21616 GameEventType::PlayerDestroyedPipeBomb => "player_destroyed_pipebomb",
21617 GameEventType::ObjectDeflected => "object_deflected",
21618 GameEventType::PlayerMvp => "player_mvp",
21619 GameEventType::RaidSpawnMob => "raid_spawn_mob",
21620 GameEventType::RaidSpawnSquad => "raid_spawn_squad",
21621 GameEventType::NavBlocked => "nav_blocked",
21622 GameEventType::PathTrackPassed => "path_track_passed",
21623 GameEventType::NumCappersChanged => "num_cappers_changed",
21624 GameEventType::PlayerRegenerate => "player_regenerate",
21625 GameEventType::UpdateStatusItem => "update_status_item",
21626 GameEventType::StatsResetRound => "stats_resetround",
21627 GameEventType::ScoreStatsAccumulatedUpdate => "scorestats_accumulated_update",
21628 GameEventType::ScoreStatsAccumulatedReset => "scorestats_accumulated_reset",
21629 GameEventType::AchievementEarnedLocal => "achievement_earned_local",
21630 GameEventType::PlayerHealed => "player_healed",
21631 GameEventType::BuildingHealed => "building_healed",
21632 GameEventType::ItemPickup => "item_pickup",
21633 GameEventType::DuelStatus => "duel_status",
21634 GameEventType::FishNotice => "fish_notice",
21635 GameEventType::FishNoticeArm => "fish_notice__arm",
21636 GameEventType::SlapNotice => "slap_notice",
21637 GameEventType::ThrowableHit => "throwable_hit",
21638 GameEventType::PumpkinLordSummoned => "pumpkin_lord_summoned",
21639 GameEventType::PumpkinLordKilled => "pumpkin_lord_killed",
21640 GameEventType::MerasmusSummoned => "merasmus_summoned",
21641 GameEventType::MerasmusKilled => "merasmus_killed",
21642 GameEventType::MerasmusEscapeWarning => "merasmus_escape_warning",
21643 GameEventType::MerasmusEscaped => "merasmus_escaped",
21644 GameEventType::EyeballBossSummoned => "eyeball_boss_summoned",
21645 GameEventType::EyeballBossStunned => "eyeball_boss_stunned",
21646 GameEventType::EyeballBossKilled => "eyeball_boss_killed",
21647 GameEventType::EyeballBossKiller => "eyeball_boss_killer",
21648 GameEventType::EyeballBossEscapeImminent => "eyeball_boss_escape_imminent",
21649 GameEventType::EyeballBossEscaped => "eyeball_boss_escaped",
21650 GameEventType::NpcHurt => "npc_hurt",
21651 GameEventType::ControlPointTimerUpdated => "controlpoint_timer_updated",
21652 GameEventType::PlayerHighFiveStart => "player_highfive_start",
21653 GameEventType::PlayerHighFiveCancel => "player_highfive_cancel",
21654 GameEventType::PlayerHighFiveSuccess => "player_highfive_success",
21655 GameEventType::PlayerBonusPoints => "player_bonuspoints",
21656 GameEventType::PlayerUpgraded => "player_upgraded",
21657 GameEventType::PlayerBuyback => "player_buyback",
21658 GameEventType::PlayerUsedPowerUpBottle => "player_used_powerup_bottle",
21659 GameEventType::ChristmasGiftGrab => "christmas_gift_grab",
21660 GameEventType::PlayerKilledAchievementZone => "player_killed_achievement_zone",
21661 GameEventType::PartyUpdated => "party_updated",
21662 GameEventType::PartyPrefChanged => "party_pref_changed",
21663 GameEventType::PartyCriteriaChanged => "party_criteria_changed",
21664 GameEventType::PartyInvitesChanged => "party_invites_changed",
21665 GameEventType::PartyQueueStateChanged => "party_queue_state_changed",
21666 GameEventType::PartyChat => "party_chat",
21667 GameEventType::PartyMemberJoin => "party_member_join",
21668 GameEventType::PartyMemberLeave => "party_member_leave",
21669 GameEventType::MatchInvitesUpdated => "match_invites_updated",
21670 GameEventType::LobbyUpdated => "lobby_updated",
21671 GameEventType::MvmMissionUpdate => "mvm_mission_update",
21672 GameEventType::RecalculateHolidays => "recalculate_holidays",
21673 GameEventType::PlayerCurrencyChanged => "player_currency_changed",
21674 GameEventType::DoomsdayRocketOpen => "doomsday_rocket_open",
21675 GameEventType::RemoveNemesisRelationships => "remove_nemesis_relationships",
21676 GameEventType::MvmCreditBonusWave => "mvm_creditbonus_wave",
21677 GameEventType::MvmCreditBonusAll => "mvm_creditbonus_all",
21678 GameEventType::MvmCreditBonusAllAdvanced => "mvm_creditbonus_all_advanced",
21679 GameEventType::MvmQuickSentryUpgrade => "mvm_quick_sentry_upgrade",
21680 GameEventType::MvmTankDestroyedByPlayers => "mvm_tank_destroyed_by_players",
21681 GameEventType::MvmKillRobotDeliveringBomb => "mvm_kill_robot_delivering_bomb",
21682 GameEventType::MvmPickupCurrency => "mvm_pickup_currency",
21683 GameEventType::MvmBombCarrierKilled => "mvm_bomb_carrier_killed",
21684 GameEventType::MvmSentryBusterDetonate => "mvm_sentrybuster_detonate",
21685 GameEventType::MvmScoutMarkedForDeath => "mvm_scout_marked_for_death",
21686 GameEventType::MvmMedicPowerUpShared => "mvm_medic_powerup_shared",
21687 GameEventType::MvmBeginWave => "mvm_begin_wave",
21688 GameEventType::MvmWaveComplete => "mvm_wave_complete",
21689 GameEventType::MvmMissionComplete => "mvm_mission_complete",
21690 GameEventType::MvmBombResetByPlayer => "mvm_bomb_reset_by_player",
21691 GameEventType::MvmBombAlarmTriggered => "mvm_bomb_alarm_triggered",
21692 GameEventType::MvmBombDeployResetByPlayer => "mvm_bomb_deploy_reset_by_player",
21693 GameEventType::MvmWaveFailed => "mvm_wave_failed",
21694 GameEventType::MvmResetStats => "mvm_reset_stats",
21695 GameEventType::DamageResisted => "damage_resisted",
21696 GameEventType::RevivePlayerNotify => "revive_player_notify",
21697 GameEventType::RevivePlayerStopped => "revive_player_stopped",
21698 GameEventType::RevivePlayerComplete => "revive_player_complete",
21699 GameEventType::PlayerTurnedToGhost => "player_turned_to_ghost",
21700 GameEventType::MedigunShieldBlockedDamage => "medigun_shield_blocked_damage",
21701 GameEventType::MvmAdvWaveCompleteNoGates => "mvm_adv_wave_complete_no_gates",
21702 GameEventType::MvmSniperHeadshotCurrency => "mvm_sniper_headshot_currency",
21703 GameEventType::MvmMannhattanPit => "mvm_mannhattan_pit",
21704 GameEventType::FlagCarriedInDetectionZone => "flag_carried_in_detection_zone",
21705 GameEventType::MvmAdvWaveKilledStunRadio => "mvm_adv_wave_killed_stun_radio",
21706 GameEventType::PlayerDirectHitStun => "player_directhit_stun",
21707 GameEventType::MvmSentryBusterKilled => "mvm_sentrybuster_killed",
21708 GameEventType::UpgradesFileChanged => "upgrades_file_changed",
21709 GameEventType::RdTeamPointsChanged => "rd_team_points_changed",
21710 GameEventType::RdRulesStateChanged => "rd_rules_state_changed",
21711 GameEventType::RdRobotKilled => "rd_robot_killed",
21712 GameEventType::RdRobotImpact => "rd_robot_impact",
21713 GameEventType::TeamPlayPreRoundTimeLeft => "teamplay_pre_round_time_left",
21714 GameEventType::ParachuteDeploy => "parachute_deploy",
21715 GameEventType::ParachuteHolster => "parachute_holster",
21716 GameEventType::KillRefillsMeter => "kill_refills_meter",
21717 GameEventType::RpsTauntEvent => "rps_taunt_event",
21718 GameEventType::CongaKill => "conga_kill",
21719 GameEventType::PlayerInitialSpawn => "player_initial_spawn",
21720 GameEventType::CompetitiveVictory => "competitive_victory",
21721 GameEventType::CompetitiveStatsUpdate => "competitive_stats_update",
21722 GameEventType::MiniGameWin => "minigame_win",
21723 GameEventType::SentryOnGoActive => "sentry_on_go_active",
21724 GameEventType::DuckXpLevelUp => "duck_xp_level_up",
21725 GameEventType::QuestLogOpened => "questlog_opened",
21726 GameEventType::SchemaUpdated => "schema_updated",
21727 GameEventType::LocalPlayerPickupWeapon => "localplayer_pickup_weapon",
21728 GameEventType::RdPlayerScorePoints => "rd_player_score_points",
21729 GameEventType::DemomanDetStickies => "demoman_det_stickies",
21730 GameEventType::QuestObjectiveCompleted => "quest_objective_completed",
21731 GameEventType::PlayerScoreChanged => "player_score_changed",
21732 GameEventType::KilledCappingPlayer => "killed_capping_player",
21733 GameEventType::EnvironmentalDeath => "environmental_death",
21734 GameEventType::ProjectileDirectHit => "projectile_direct_hit",
21735 GameEventType::PassGet => "pass_get",
21736 GameEventType::PassScore => "pass_score",
21737 GameEventType::PassFree => "pass_free",
21738 GameEventType::PassPassCaught => "pass_pass_caught",
21739 GameEventType::PassBallStolen => "pass_ball_stolen",
21740 GameEventType::PassBallBlocked => "pass_ball_blocked",
21741 GameEventType::DamagePrevented => "damage_prevented",
21742 GameEventType::HalloweenBossKilled => "halloween_boss_killed",
21743 GameEventType::EscapedLootIsland => "escaped_loot_island",
21744 GameEventType::TaggedPlayerAsIt => "tagged_player_as_it",
21745 GameEventType::MerasmusStunned => "merasmus_stunned",
21746 GameEventType::MerasmusPropFound => "merasmus_prop_found",
21747 GameEventType::HalloweenSkeletonKilled => "halloween_skeleton_killed",
21748 GameEventType::SkeletonKilledQuest => "skeleton_killed_quest",
21749 GameEventType::SkeletonKingKilledQuest => "skeleton_king_killed_quest",
21750 GameEventType::EscapeHell => "escape_hell",
21751 GameEventType::CrossSpectralBridge => "cross_spectral_bridge",
21752 GameEventType::MiniGameWon => "minigame_won",
21753 GameEventType::RespawnGhost => "respawn_ghost",
21754 GameEventType::KillInHell => "kill_in_hell",
21755 GameEventType::HalloweenDuckCollected => "halloween_duck_collected",
21756 GameEventType::SpecialScore => "special_score",
21757 GameEventType::TeamLeaderKilled => "team_leader_killed",
21758 GameEventType::HalloweenSoulCollected => "halloween_soul_collected",
21759 GameEventType::RecalculateTruce => "recalculate_truce",
21760 GameEventType::DeadRingerCheatDeath => "deadringer_cheat_death",
21761 GameEventType::CrossbowHeal => "crossbow_heal",
21762 GameEventType::DamageMitigated => "damage_mitigated",
21763 GameEventType::PayloadPushed => "payload_pushed",
21764 GameEventType::PlayerAbandonedMatch => "player_abandoned_match",
21765 GameEventType::ClDrawline => "cl_drawline",
21766 GameEventType::RestartTimerTime => "restart_timer_time",
21767 GameEventType::WinLimitChanged => "winlimit_changed",
21768 GameEventType::WinPanelShowScores => "winpanel_show_scores",
21769 GameEventType::TopStreamsRequestFinished => "top_streams_request_finished",
21770 GameEventType::CompetitiveStateChanged => "competitive_state_changed",
21771 GameEventType::GlobalWarDataUpdated => "global_war_data_updated",
21772 GameEventType::StopWatchChanged => "stop_watch_changed",
21773 GameEventType::DsStop => "ds_stop",
21774 GameEventType::DsScreenshot => "ds_screenshot",
21775 GameEventType::ShowMatchSummary => "show_match_summary",
21776 GameEventType::ExperienceChanged => "experience_changed",
21777 GameEventType::BeginXpLerp => "begin_xp_lerp",
21778 GameEventType::MatchmakerStatsUpdated => "matchmaker_stats_updated",
21779 GameEventType::RematchVotePeriodOver => "rematch_vote_period_over",
21780 GameEventType::RematchFailedToCreate => "rematch_failed_to_create",
21781 GameEventType::PlayerRematchChange => "player_rematch_change",
21782 GameEventType::PingUpdated => "ping_updated",
21783 GameEventType::MMStatsUpdated => "mmstats_updated",
21784 GameEventType::PlayerNextMapVoteChange => "player_next_map_vote_change",
21785 GameEventType::VoteMapsChanged => "vote_maps_changed",
21786 GameEventType::ProtoDefChanged => "proto_def_changed",
21787 GameEventType::PlayerDomination => "player_domination",
21788 GameEventType::PlayerRocketPackPushed => "player_rocketpack_pushed",
21789 GameEventType::QuestRequest => "quest_request",
21790 GameEventType::QuestResponse => "quest_response",
21791 GameEventType::QuestProgress => "quest_progress",
21792 GameEventType::ProjectileRemoved => "projectile_removed",
21793 GameEventType::QuestMapDataChanged => "quest_map_data_changed",
21794 GameEventType::GasDousedPlayerIgnited => "gas_doused_player_ignited",
21795 GameEventType::QuestTurnInState => "quest_turn_in_state",
21796 GameEventType::ItemsAcknowledged => "items_acknowledged",
21797 GameEventType::CapperKilled => "capper_killed",
21798 GameEventType::MainMenuStabilized => "mainmenu_stabilized",
21799 GameEventType::WorldStatusChanged => "world_status_changed",
21800 GameEventType::HLTVStatus => "hltv_status",
21801 GameEventType::HLTVCameraman => "hltv_cameraman",
21802 GameEventType::HLTVRankCamera => "hltv_rank_camera",
21803 GameEventType::HLTVRankEntity => "hltv_rank_entity",
21804 GameEventType::HLTVFixed => "hltv_fixed",
21805 GameEventType::HLTVChase => "hltv_chase",
21806 GameEventType::HLTVMessage => "hltv_message",
21807 GameEventType::HLTVTitle => "hltv_title",
21808 GameEventType::HLTVChat => "hltv_chat",
21809 GameEventType::ReplayStartRecord => "replay_startrecord",
21810 GameEventType::ReplaySessionInfo => "replay_sessioninfo",
21811 GameEventType::ReplayEndRecord => "replay_endrecord",
21812 GameEventType::ReplayReplaysAvailable => "replay_replaysavailable",
21813 GameEventType::ReplayServerError => "replay_servererror",
21814 GameEventType::Unknown(ty) => ty,
21815 }
21816 }
21817}
21818impl GameEvent {
21819 pub fn read(stream: &mut Stream, definition: &GameEventDefinition) -> Result<Self> {
21820 Ok(match definition.event_type {
21821 GameEventType::ServerSpawn => {
21822 GameEvent::ServerSpawn(Box::new(<ServerSpawnEvent>::read(stream, definition)?))
21823 }
21824 GameEventType::ServerChangeLevelFailed => GameEvent::ServerChangeLevelFailed(
21825 ServerChangeLevelFailedEvent::read(stream, definition)?,
21826 ),
21827 GameEventType::ServerShutdown => {
21828 GameEvent::ServerShutdown(ServerShutdownEvent::read(stream, definition)?)
21829 }
21830 GameEventType::ServerCvar => {
21831 GameEvent::ServerCvar(ServerCvarEvent::read(stream, definition)?)
21832 }
21833 GameEventType::ServerMessage => {
21834 GameEvent::ServerMessage(ServerMessageEvent::read(stream, definition)?)
21835 }
21836 GameEventType::ServerAddBan => {
21837 GameEvent::ServerAddBan(Box::new(<ServerAddBanEvent>::read(stream, definition)?))
21838 }
21839 GameEventType::ServerRemoveBan => {
21840 GameEvent::ServerRemoveBan(ServerRemoveBanEvent::read(stream, definition)?)
21841 }
21842 GameEventType::PlayerConnect => {
21843 GameEvent::PlayerConnect(PlayerConnectEvent::read(stream, definition)?)
21844 }
21845 GameEventType::PlayerConnectClient => {
21846 GameEvent::PlayerConnectClient(PlayerConnectClientEvent::read(stream, definition)?)
21847 }
21848 GameEventType::PlayerInfo => {
21849 GameEvent::PlayerInfo(PlayerInfoEvent::read(stream, definition)?)
21850 }
21851 GameEventType::PlayerDisconnect => {
21852 GameEvent::PlayerDisconnect(PlayerDisconnectEvent::read(stream, definition)?)
21853 }
21854 GameEventType::PlayerActivate => {
21855 GameEvent::PlayerActivate(PlayerActivateEvent::read(stream, definition)?)
21856 }
21857 GameEventType::PlayerSay => {
21858 GameEvent::PlayerSay(PlayerSayEvent::read(stream, definition)?)
21859 }
21860 GameEventType::ClientDisconnect => {
21861 GameEvent::ClientDisconnect(ClientDisconnectEvent::read(stream, definition)?)
21862 }
21863 GameEventType::ClientBeginConnect => {
21864 GameEvent::ClientBeginConnect(ClientBeginConnectEvent::read(stream, definition)?)
21865 }
21866 GameEventType::ClientConnected => {
21867 GameEvent::ClientConnected(ClientConnectedEvent::read(stream, definition)?)
21868 }
21869 GameEventType::ClientFullConnect => {
21870 GameEvent::ClientFullConnect(ClientFullConnectEvent::read(stream, definition)?)
21871 }
21872 GameEventType::HostQuit => {
21873 GameEvent::HostQuit(HostQuitEvent::read(stream, definition)?)
21874 }
21875 GameEventType::TeamInfo => {
21876 GameEvent::TeamInfo(TeamInfoEvent::read(stream, definition)?)
21877 }
21878 GameEventType::TeamScore => {
21879 GameEvent::TeamScore(TeamScoreEvent::read(stream, definition)?)
21880 }
21881 GameEventType::TeamPlayBroadcastAudio => GameEvent::TeamPlayBroadcastAudio(
21882 TeamPlayBroadcastAudioEvent::read(stream, definition)?,
21883 ),
21884 GameEventType::PlayerTeam => {
21885 GameEvent::PlayerTeam(PlayerTeamEvent::read(stream, definition)?)
21886 }
21887 GameEventType::PlayerClass => {
21888 GameEvent::PlayerClass(PlayerClassEvent::read(stream, definition)?)
21889 }
21890 GameEventType::PlayerDeath => {
21891 GameEvent::PlayerDeath(Box::new(<PlayerDeathEvent>::read(stream, definition)?))
21892 }
21893 GameEventType::PlayerHurt => {
21894 GameEvent::PlayerHurt(PlayerHurtEvent::read(stream, definition)?)
21895 }
21896 GameEventType::PlayerChat => {
21897 GameEvent::PlayerChat(PlayerChatEvent::read(stream, definition)?)
21898 }
21899 GameEventType::PlayerScore => {
21900 GameEvent::PlayerScore(PlayerScoreEvent::read(stream, definition)?)
21901 }
21902 GameEventType::PlayerSpawn => {
21903 GameEvent::PlayerSpawn(PlayerSpawnEvent::read(stream, definition)?)
21904 }
21905 GameEventType::PlayerShoot => {
21906 GameEvent::PlayerShoot(PlayerShootEvent::read(stream, definition)?)
21907 }
21908 GameEventType::PlayerUse => {
21909 GameEvent::PlayerUse(PlayerUseEvent::read(stream, definition)?)
21910 }
21911 GameEventType::PlayerChangeName => {
21912 GameEvent::PlayerChangeName(PlayerChangeNameEvent::read(stream, definition)?)
21913 }
21914 GameEventType::PlayerHintMessage => {
21915 GameEvent::PlayerHintMessage(PlayerHintMessageEvent::read(stream, definition)?)
21916 }
21917 GameEventType::BasePlayerTeleported => GameEvent::BasePlayerTeleported(
21918 BasePlayerTeleportedEvent::read(stream, definition)?,
21919 ),
21920 GameEventType::GameInit => {
21921 GameEvent::GameInit(GameInitEvent::read(stream, definition)?)
21922 }
21923 GameEventType::GameNewMap => {
21924 GameEvent::GameNewMap(GameNewMapEvent::read(stream, definition)?)
21925 }
21926 GameEventType::GameStart => {
21927 GameEvent::GameStart(GameStartEvent::read(stream, definition)?)
21928 }
21929 GameEventType::GameEnd => GameEvent::GameEnd(GameEndEvent::read(stream, definition)?),
21930 GameEventType::RoundStart => {
21931 GameEvent::RoundStart(RoundStartEvent::read(stream, definition)?)
21932 }
21933 GameEventType::RoundEnd => {
21934 GameEvent::RoundEnd(RoundEndEvent::read(stream, definition)?)
21935 }
21936 GameEventType::GameMessage => {
21937 GameEvent::GameMessage(GameMessageEvent::read(stream, definition)?)
21938 }
21939 GameEventType::BreakBreakable => {
21940 GameEvent::BreakBreakable(BreakBreakableEvent::read(stream, definition)?)
21941 }
21942 GameEventType::BreakProp => {
21943 GameEvent::BreakProp(BreakPropEvent::read(stream, definition)?)
21944 }
21945 GameEventType::EntityKilled => {
21946 GameEvent::EntityKilled(EntityKilledEvent::read(stream, definition)?)
21947 }
21948 GameEventType::BonusUpdated => {
21949 GameEvent::BonusUpdated(BonusUpdatedEvent::read(stream, definition)?)
21950 }
21951 GameEventType::AchievementEvent => {
21952 GameEvent::AchievementEvent(AchievementEventEvent::read(stream, definition)?)
21953 }
21954 GameEventType::AchievementIncrement => GameEvent::AchievementIncrement(
21955 AchievementIncrementEvent::read(stream, definition)?,
21956 ),
21957 GameEventType::PhysgunPickup => {
21958 GameEvent::PhysgunPickup(PhysgunPickupEvent::read(stream, definition)?)
21959 }
21960 GameEventType::FlareIgniteNpc => {
21961 GameEvent::FlareIgniteNpc(FlareIgniteNpcEvent::read(stream, definition)?)
21962 }
21963 GameEventType::HelicopterGrenadePuntMiss => GameEvent::HelicopterGrenadePuntMiss(
21964 HelicopterGrenadePuntMissEvent::read(stream, definition)?,
21965 ),
21966 GameEventType::UserDataDownloaded => {
21967 GameEvent::UserDataDownloaded(UserDataDownloadedEvent::read(stream, definition)?)
21968 }
21969 GameEventType::RagdollDissolved => {
21970 GameEvent::RagdollDissolved(RagdollDissolvedEvent::read(stream, definition)?)
21971 }
21972 GameEventType::HLTVChangedMode => {
21973 GameEvent::HLTVChangedMode(HLTVChangedModeEvent::read(stream, definition)?)
21974 }
21975 GameEventType::HLTVChangedTarget => {
21976 GameEvent::HLTVChangedTarget(HLTVChangedTargetEvent::read(stream, definition)?)
21977 }
21978 GameEventType::VoteEnded => {
21979 GameEvent::VoteEnded(VoteEndedEvent::read(stream, definition)?)
21980 }
21981 GameEventType::VoteStarted => {
21982 GameEvent::VoteStarted(VoteStartedEvent::read(stream, definition)?)
21983 }
21984 GameEventType::VoteChanged => {
21985 GameEvent::VoteChanged(VoteChangedEvent::read(stream, definition)?)
21986 }
21987 GameEventType::VotePassed => {
21988 GameEvent::VotePassed(VotePassedEvent::read(stream, definition)?)
21989 }
21990 GameEventType::VoteFailed => {
21991 GameEvent::VoteFailed(VoteFailedEvent::read(stream, definition)?)
21992 }
21993 GameEventType::VoteCast => {
21994 GameEvent::VoteCast(VoteCastEvent::read(stream, definition)?)
21995 }
21996 GameEventType::VoteOptions => {
21997 GameEvent::VoteOptions(Box::new(<VoteOptionsEvent>::read(stream, definition)?))
21998 }
21999 GameEventType::ReplaySaved => {
22000 GameEvent::ReplaySaved(ReplaySavedEvent::read(stream, definition)?)
22001 }
22002 GameEventType::EnteredPerformanceMode => GameEvent::EnteredPerformanceMode(
22003 EnteredPerformanceModeEvent::read(stream, definition)?,
22004 ),
22005 GameEventType::BrowseReplays => {
22006 GameEvent::BrowseReplays(BrowseReplaysEvent::read(stream, definition)?)
22007 }
22008 GameEventType::ReplayYoutubeStats => {
22009 GameEvent::ReplayYoutubeStats(ReplayYoutubeStatsEvent::read(stream, definition)?)
22010 }
22011 GameEventType::InventoryUpdated => {
22012 GameEvent::InventoryUpdated(InventoryUpdatedEvent::read(stream, definition)?)
22013 }
22014 GameEventType::CartUpdated => {
22015 GameEvent::CartUpdated(CartUpdatedEvent::read(stream, definition)?)
22016 }
22017 GameEventType::StorePriceSheetUpdated => GameEvent::StorePriceSheetUpdated(
22018 StorePriceSheetUpdatedEvent::read(stream, definition)?,
22019 ),
22020 GameEventType::EconInventoryConnected => GameEvent::EconInventoryConnected(
22021 EconInventoryConnectedEvent::read(stream, definition)?,
22022 ),
22023 GameEventType::ItemSchemaInitialized => GameEvent::ItemSchemaInitialized(
22024 ItemSchemaInitializedEvent::read(stream, definition)?,
22025 ),
22026 GameEventType::GcNewSession => {
22027 GameEvent::GcNewSession(GcNewSessionEvent::read(stream, definition)?)
22028 }
22029 GameEventType::GcLostSession => {
22030 GameEvent::GcLostSession(GcLostSessionEvent::read(stream, definition)?)
22031 }
22032 GameEventType::IntroFinish => {
22033 GameEvent::IntroFinish(IntroFinishEvent::read(stream, definition)?)
22034 }
22035 GameEventType::IntroNextCamera => {
22036 GameEvent::IntroNextCamera(IntroNextCameraEvent::read(stream, definition)?)
22037 }
22038 GameEventType::PlayerChangeClass => {
22039 GameEvent::PlayerChangeClass(PlayerChangeClassEvent::read(stream, definition)?)
22040 }
22041 GameEventType::TfMapTimeRemaining => {
22042 GameEvent::TfMapTimeRemaining(TfMapTimeRemainingEvent::read(stream, definition)?)
22043 }
22044 GameEventType::TfGameOver => {
22045 GameEvent::TfGameOver(TfGameOverEvent::read(stream, definition)?)
22046 }
22047 GameEventType::CtfFlagCaptured => {
22048 GameEvent::CtfFlagCaptured(CtfFlagCapturedEvent::read(stream, definition)?)
22049 }
22050 GameEventType::ControlPointInitialized => GameEvent::ControlPointInitialized(
22051 ControlPointInitializedEvent::read(stream, definition)?,
22052 ),
22053 GameEventType::ControlPointUpdateImages => GameEvent::ControlPointUpdateImages(
22054 ControlPointUpdateImagesEvent::read(stream, definition)?,
22055 ),
22056 GameEventType::ControlPointUpdateLayout => GameEvent::ControlPointUpdateLayout(
22057 ControlPointUpdateLayoutEvent::read(stream, definition)?,
22058 ),
22059 GameEventType::ControlPointUpdateCapping => GameEvent::ControlPointUpdateCapping(
22060 ControlPointUpdateCappingEvent::read(stream, definition)?,
22061 ),
22062 GameEventType::ControlPointUpdateOwner => GameEvent::ControlPointUpdateOwner(
22063 ControlPointUpdateOwnerEvent::read(stream, definition)?,
22064 ),
22065 GameEventType::ControlPointStartTouch => GameEvent::ControlPointStartTouch(
22066 ControlPointStartTouchEvent::read(stream, definition)?,
22067 ),
22068 GameEventType::ControlPointEndTouch => GameEvent::ControlPointEndTouch(
22069 ControlPointEndTouchEvent::read(stream, definition)?,
22070 ),
22071 GameEventType::ControlPointPulseElement => GameEvent::ControlPointPulseElement(
22072 ControlPointPulseElementEvent::read(stream, definition)?,
22073 ),
22074 GameEventType::ControlPointFakeCapture => GameEvent::ControlPointFakeCapture(
22075 ControlPointFakeCaptureEvent::read(stream, definition)?,
22076 ),
22077 GameEventType::ControlPointFakeCaptureMultiplier => {
22078 GameEvent::ControlPointFakeCaptureMultiplier(
22079 ControlPointFakeCaptureMultiplierEvent::read(stream, definition)?,
22080 )
22081 }
22082 GameEventType::TeamPlayRoundSelected => GameEvent::TeamPlayRoundSelected(
22083 TeamPlayRoundSelectedEvent::read(stream, definition)?,
22084 ),
22085 GameEventType::TeamPlayRoundStart => {
22086 GameEvent::TeamPlayRoundStart(TeamPlayRoundStartEvent::read(stream, definition)?)
22087 }
22088 GameEventType::TeamPlayRoundActive => {
22089 GameEvent::TeamPlayRoundActive(TeamPlayRoundActiveEvent::read(stream, definition)?)
22090 }
22091 GameEventType::TeamPlayWaitingBegins => GameEvent::TeamPlayWaitingBegins(
22092 TeamPlayWaitingBeginsEvent::read(stream, definition)?,
22093 ),
22094 GameEventType::TeamPlayWaitingEnds => {
22095 GameEvent::TeamPlayWaitingEnds(TeamPlayWaitingEndsEvent::read(stream, definition)?)
22096 }
22097 GameEventType::TeamPlayWaitingAboutToEnd => GameEvent::TeamPlayWaitingAboutToEnd(
22098 TeamPlayWaitingAboutToEndEvent::read(stream, definition)?,
22099 ),
22100 GameEventType::TeamPlayRestartRound => GameEvent::TeamPlayRestartRound(
22101 TeamPlayRestartRoundEvent::read(stream, definition)?,
22102 ),
22103 GameEventType::TeamPlayReadyRestart => GameEvent::TeamPlayReadyRestart(
22104 TeamPlayReadyRestartEvent::read(stream, definition)?,
22105 ),
22106 GameEventType::TeamPlayRoundRestartSeconds => GameEvent::TeamPlayRoundRestartSeconds(
22107 TeamPlayRoundRestartSecondsEvent::read(stream, definition)?,
22108 ),
22109 GameEventType::TeamPlayTeamReady => {
22110 GameEvent::TeamPlayTeamReady(TeamPlayTeamReadyEvent::read(stream, definition)?)
22111 }
22112 GameEventType::TeamPlayRoundWin => {
22113 GameEvent::TeamPlayRoundWin(TeamPlayRoundWinEvent::read(stream, definition)?)
22114 }
22115 GameEventType::TeamPlayUpdateTimer => {
22116 GameEvent::TeamPlayUpdateTimer(TeamPlayUpdateTimerEvent::read(stream, definition)?)
22117 }
22118 GameEventType::TeamPlayRoundStalemate => GameEvent::TeamPlayRoundStalemate(
22119 TeamPlayRoundStalemateEvent::read(stream, definition)?,
22120 ),
22121 GameEventType::TeamPlayOvertimeBegin => GameEvent::TeamPlayOvertimeBegin(
22122 TeamPlayOvertimeBeginEvent::read(stream, definition)?,
22123 ),
22124 GameEventType::TeamPlayOvertimeEnd => {
22125 GameEvent::TeamPlayOvertimeEnd(TeamPlayOvertimeEndEvent::read(stream, definition)?)
22126 }
22127 GameEventType::TeamPlaySuddenDeathBegin => GameEvent::TeamPlaySuddenDeathBegin(
22128 TeamPlaySuddenDeathBeginEvent::read(stream, definition)?,
22129 ),
22130 GameEventType::TeamPlaySuddenDeathEnd => GameEvent::TeamPlaySuddenDeathEnd(
22131 TeamPlaySuddenDeathEndEvent::read(stream, definition)?,
22132 ),
22133 GameEventType::TeamPlayGameOver => {
22134 GameEvent::TeamPlayGameOver(TeamPlayGameOverEvent::read(stream, definition)?)
22135 }
22136 GameEventType::TeamPlayMapTimeRemaining => GameEvent::TeamPlayMapTimeRemaining(
22137 TeamPlayMapTimeRemainingEvent::read(stream, definition)?,
22138 ),
22139 GameEventType::TeamPlayTimerFlash => {
22140 GameEvent::TeamPlayTimerFlash(TeamPlayTimerFlashEvent::read(stream, definition)?)
22141 }
22142 GameEventType::TeamPlayTimerTimeAdded => GameEvent::TeamPlayTimerTimeAdded(
22143 TeamPlayTimerTimeAddedEvent::read(stream, definition)?,
22144 ),
22145 GameEventType::TeamPlayPointStartCapture => GameEvent::TeamPlayPointStartCapture(
22146 TeamPlayPointStartCaptureEvent::read(stream, definition)?,
22147 ),
22148 GameEventType::TeamPlayPointCaptured => GameEvent::TeamPlayPointCaptured(
22149 TeamPlayPointCapturedEvent::read(stream, definition)?,
22150 ),
22151 GameEventType::TeamPlayPointLocked => {
22152 GameEvent::TeamPlayPointLocked(TeamPlayPointLockedEvent::read(stream, definition)?)
22153 }
22154 GameEventType::TeamPlayPointUnlocked => GameEvent::TeamPlayPointUnlocked(
22155 TeamPlayPointUnlockedEvent::read(stream, definition)?,
22156 ),
22157 GameEventType::TeamPlayCaptureBroken => GameEvent::TeamPlayCaptureBroken(
22158 TeamPlayCaptureBrokenEvent::read(stream, definition)?,
22159 ),
22160 GameEventType::TeamPlayCaptureBlocked => GameEvent::TeamPlayCaptureBlocked(
22161 TeamPlayCaptureBlockedEvent::read(stream, definition)?,
22162 ),
22163 GameEventType::TeamPlayFlagEvent => {
22164 GameEvent::TeamPlayFlagEvent(TeamPlayFlagEventEvent::read(stream, definition)?)
22165 }
22166 GameEventType::TeamPlayWinPanel => {
22167 GameEvent::TeamPlayWinPanel(TeamPlayWinPanelEvent::read(stream, definition)?)
22168 }
22169 GameEventType::TeamPlayTeamBalancedPlayer => GameEvent::TeamPlayTeamBalancedPlayer(
22170 TeamPlayTeamBalancedPlayerEvent::read(stream, definition)?,
22171 ),
22172 GameEventType::TeamPlaySetupFinished => GameEvent::TeamPlaySetupFinished(
22173 TeamPlaySetupFinishedEvent::read(stream, definition)?,
22174 ),
22175 GameEventType::TeamPlayAlert => {
22176 GameEvent::TeamPlayAlert(TeamPlayAlertEvent::read(stream, definition)?)
22177 }
22178 GameEventType::TrainingComplete => {
22179 GameEvent::TrainingComplete(TrainingCompleteEvent::read(stream, definition)?)
22180 }
22181 GameEventType::ShowFreezePanel => {
22182 GameEvent::ShowFreezePanel(ShowFreezePanelEvent::read(stream, definition)?)
22183 }
22184 GameEventType::HideFreezePanel => {
22185 GameEvent::HideFreezePanel(HideFreezePanelEvent::read(stream, definition)?)
22186 }
22187 GameEventType::FreezeCamStarted => {
22188 GameEvent::FreezeCamStarted(FreezeCamStartedEvent::read(stream, definition)?)
22189 }
22190 GameEventType::LocalPlayerChangeTeam => GameEvent::LocalPlayerChangeTeam(
22191 LocalPlayerChangeTeamEvent::read(stream, definition)?,
22192 ),
22193 GameEventType::LocalPlayerScoreChanged => GameEvent::LocalPlayerScoreChanged(
22194 LocalPlayerScoreChangedEvent::read(stream, definition)?,
22195 ),
22196 GameEventType::LocalPlayerChangeClass => GameEvent::LocalPlayerChangeClass(
22197 LocalPlayerChangeClassEvent::read(stream, definition)?,
22198 ),
22199 GameEventType::LocalPlayerRespawn => {
22200 GameEvent::LocalPlayerRespawn(LocalPlayerRespawnEvent::read(stream, definition)?)
22201 }
22202 GameEventType::BuildingInfoChanged => {
22203 GameEvent::BuildingInfoChanged(BuildingInfoChangedEvent::read(stream, definition)?)
22204 }
22205 GameEventType::LocalPlayerChangeDisguise => GameEvent::LocalPlayerChangeDisguise(
22206 LocalPlayerChangeDisguiseEvent::read(stream, definition)?,
22207 ),
22208 GameEventType::PlayerAccountChanged => GameEvent::PlayerAccountChanged(
22209 PlayerAccountChangedEvent::read(stream, definition)?,
22210 ),
22211 GameEventType::SpyPdaReset => {
22212 GameEvent::SpyPdaReset(SpyPdaResetEvent::read(stream, definition)?)
22213 }
22214 GameEventType::FlagStatusUpdate => {
22215 GameEvent::FlagStatusUpdate(FlagStatusUpdateEvent::read(stream, definition)?)
22216 }
22217 GameEventType::PlayerStatsUpdated => {
22218 GameEvent::PlayerStatsUpdated(PlayerStatsUpdatedEvent::read(stream, definition)?)
22219 }
22220 GameEventType::PlayingCommentary => {
22221 GameEvent::PlayingCommentary(PlayingCommentaryEvent::read(stream, definition)?)
22222 }
22223 GameEventType::PlayerChargeDeployed => GameEvent::PlayerChargeDeployed(
22224 PlayerChargeDeployedEvent::read(stream, definition)?,
22225 ),
22226 GameEventType::PlayerBuiltObject => {
22227 GameEvent::PlayerBuiltObject(PlayerBuiltObjectEvent::read(stream, definition)?)
22228 }
22229 GameEventType::PlayerUpgradedObject => GameEvent::PlayerUpgradedObject(
22230 PlayerUpgradedObjectEvent::read(stream, definition)?,
22231 ),
22232 GameEventType::PlayerCarryObject => {
22233 GameEvent::PlayerCarryObject(PlayerCarryObjectEvent::read(stream, definition)?)
22234 }
22235 GameEventType::PlayerDropObject => {
22236 GameEvent::PlayerDropObject(PlayerDropObjectEvent::read(stream, definition)?)
22237 }
22238 GameEventType::ObjectRemoved => {
22239 GameEvent::ObjectRemoved(ObjectRemovedEvent::read(stream, definition)?)
22240 }
22241 GameEventType::ObjectDestroyed => {
22242 GameEvent::ObjectDestroyed(ObjectDestroyedEvent::read(stream, definition)?)
22243 }
22244 GameEventType::ObjectDetonated => {
22245 GameEvent::ObjectDetonated(ObjectDetonatedEvent::read(stream, definition)?)
22246 }
22247 GameEventType::AchievementEarned => {
22248 GameEvent::AchievementEarned(AchievementEarnedEvent::read(stream, definition)?)
22249 }
22250 GameEventType::SpecTargetUpdated => {
22251 GameEvent::SpecTargetUpdated(SpecTargetUpdatedEvent::read(stream, definition)?)
22252 }
22253 GameEventType::TournamentStateUpdate => GameEvent::TournamentStateUpdate(
22254 TournamentStateUpdateEvent::read(stream, definition)?,
22255 ),
22256 GameEventType::TournamentEnableCountdown => GameEvent::TournamentEnableCountdown(
22257 TournamentEnableCountdownEvent::read(stream, definition)?,
22258 ),
22259 GameEventType::PlayerCalledForMedic => GameEvent::PlayerCalledForMedic(
22260 PlayerCalledForMedicEvent::read(stream, definition)?,
22261 ),
22262 GameEventType::PlayerAskedForBall => {
22263 GameEvent::PlayerAskedForBall(PlayerAskedForBallEvent::read(stream, definition)?)
22264 }
22265 GameEventType::LocalPlayerBecameObserver => GameEvent::LocalPlayerBecameObserver(
22266 LocalPlayerBecameObserverEvent::read(stream, definition)?,
22267 ),
22268 GameEventType::PlayerIgnitedInv => {
22269 GameEvent::PlayerIgnitedInv(PlayerIgnitedInvEvent::read(stream, definition)?)
22270 }
22271 GameEventType::PlayerIgnited => {
22272 GameEvent::PlayerIgnited(PlayerIgnitedEvent::read(stream, definition)?)
22273 }
22274 GameEventType::PlayerExtinguished => {
22275 GameEvent::PlayerExtinguished(PlayerExtinguishedEvent::read(stream, definition)?)
22276 }
22277 GameEventType::PlayerTeleported => {
22278 GameEvent::PlayerTeleported(PlayerTeleportedEvent::read(stream, definition)?)
22279 }
22280 GameEventType::PlayerHealedMedicCall => GameEvent::PlayerHealedMedicCall(
22281 PlayerHealedMedicCallEvent::read(stream, definition)?,
22282 ),
22283 GameEventType::LocalPlayerChargeReady => GameEvent::LocalPlayerChargeReady(
22284 LocalPlayerChargeReadyEvent::read(stream, definition)?,
22285 ),
22286 GameEventType::LocalPlayerWindDown => {
22287 GameEvent::LocalPlayerWindDown(LocalPlayerWindDownEvent::read(stream, definition)?)
22288 }
22289 GameEventType::PlayerInvulned => {
22290 GameEvent::PlayerInvulned(PlayerInvulnedEvent::read(stream, definition)?)
22291 }
22292 GameEventType::EscortSpeed => {
22293 GameEvent::EscortSpeed(EscortSpeedEvent::read(stream, definition)?)
22294 }
22295 GameEventType::EscortProgress => {
22296 GameEvent::EscortProgress(EscortProgressEvent::read(stream, definition)?)
22297 }
22298 GameEventType::EscortRecede => {
22299 GameEvent::EscortRecede(EscortRecedeEvent::read(stream, definition)?)
22300 }
22301 GameEventType::GameUIActivated => {
22302 GameEvent::GameUIActivated(GameUIActivatedEvent::read(stream, definition)?)
22303 }
22304 GameEventType::GameUIHidden => {
22305 GameEvent::GameUIHidden(GameUIHiddenEvent::read(stream, definition)?)
22306 }
22307 GameEventType::PlayerEscortScore => {
22308 GameEvent::PlayerEscortScore(PlayerEscortScoreEvent::read(stream, definition)?)
22309 }
22310 GameEventType::PlayerHealOnHit => {
22311 GameEvent::PlayerHealOnHit(PlayerHealOnHitEvent::read(stream, definition)?)
22312 }
22313 GameEventType::PlayerStealSandvich => {
22314 GameEvent::PlayerStealSandvich(PlayerStealSandvichEvent::read(stream, definition)?)
22315 }
22316 GameEventType::ShowClassLayout => {
22317 GameEvent::ShowClassLayout(ShowClassLayoutEvent::read(stream, definition)?)
22318 }
22319 GameEventType::ShowVsPanel => {
22320 GameEvent::ShowVsPanel(ShowVsPanelEvent::read(stream, definition)?)
22321 }
22322 GameEventType::PlayerDamaged => {
22323 GameEvent::PlayerDamaged(PlayerDamagedEvent::read(stream, definition)?)
22324 }
22325 GameEventType::ArenaPlayerNotification => GameEvent::ArenaPlayerNotification(
22326 ArenaPlayerNotificationEvent::read(stream, definition)?,
22327 ),
22328 GameEventType::ArenaMatchMaxStreak => {
22329 GameEvent::ArenaMatchMaxStreak(ArenaMatchMaxStreakEvent::read(stream, definition)?)
22330 }
22331 GameEventType::ArenaRoundStart => {
22332 GameEvent::ArenaRoundStart(ArenaRoundStartEvent::read(stream, definition)?)
22333 }
22334 GameEventType::ArenaWinPanel => {
22335 GameEvent::ArenaWinPanel(ArenaWinPanelEvent::read(stream, definition)?)
22336 }
22337 GameEventType::PveWinPanel => {
22338 GameEvent::PveWinPanel(PveWinPanelEvent::read(stream, definition)?)
22339 }
22340 GameEventType::AirDash => GameEvent::AirDash(AirDashEvent::read(stream, definition)?),
22341 GameEventType::Landed => GameEvent::Landed(LandedEvent::read(stream, definition)?),
22342 GameEventType::PlayerDamageDodged => {
22343 GameEvent::PlayerDamageDodged(PlayerDamageDodgedEvent::read(stream, definition)?)
22344 }
22345 GameEventType::PlayerStunned => {
22346 GameEvent::PlayerStunned(PlayerStunnedEvent::read(stream, definition)?)
22347 }
22348 GameEventType::ScoutGrandSlam => {
22349 GameEvent::ScoutGrandSlam(ScoutGrandSlamEvent::read(stream, definition)?)
22350 }
22351 GameEventType::ScoutSlamdollLanded => {
22352 GameEvent::ScoutSlamdollLanded(ScoutSlamdollLandedEvent::read(stream, definition)?)
22353 }
22354 GameEventType::ArrowImpact => {
22355 GameEvent::ArrowImpact(ArrowImpactEvent::read(stream, definition)?)
22356 }
22357 GameEventType::PlayerJarated => {
22358 GameEvent::PlayerJarated(PlayerJaratedEvent::read(stream, definition)?)
22359 }
22360 GameEventType::PlayerJaratedFade => {
22361 GameEvent::PlayerJaratedFade(PlayerJaratedFadeEvent::read(stream, definition)?)
22362 }
22363 GameEventType::PlayerShieldBlocked => {
22364 GameEvent::PlayerShieldBlocked(PlayerShieldBlockedEvent::read(stream, definition)?)
22365 }
22366 GameEventType::PlayerPinned => {
22367 GameEvent::PlayerPinned(PlayerPinnedEvent::read(stream, definition)?)
22368 }
22369 GameEventType::PlayerHealedByMedic => {
22370 GameEvent::PlayerHealedByMedic(PlayerHealedByMedicEvent::read(stream, definition)?)
22371 }
22372 GameEventType::PlayerSappedObject => {
22373 GameEvent::PlayerSappedObject(PlayerSappedObjectEvent::read(stream, definition)?)
22374 }
22375 GameEventType::ItemFound => {
22376 GameEvent::ItemFound(ItemFoundEvent::read(stream, definition)?)
22377 }
22378 GameEventType::ShowAnnotation => {
22379 GameEvent::ShowAnnotation(ShowAnnotationEvent::read(stream, definition)?)
22380 }
22381 GameEventType::HideAnnotation => {
22382 GameEvent::HideAnnotation(HideAnnotationEvent::read(stream, definition)?)
22383 }
22384 GameEventType::PostInventoryApplication => GameEvent::PostInventoryApplication(
22385 PostInventoryApplicationEvent::read(stream, definition)?,
22386 ),
22387 GameEventType::ControlPointUnlockUpdated => GameEvent::ControlPointUnlockUpdated(
22388 ControlPointUnlockUpdatedEvent::read(stream, definition)?,
22389 ),
22390 GameEventType::DeployBuffBanner => {
22391 GameEvent::DeployBuffBanner(DeployBuffBannerEvent::read(stream, definition)?)
22392 }
22393 GameEventType::PlayerBuff => {
22394 GameEvent::PlayerBuff(PlayerBuffEvent::read(stream, definition)?)
22395 }
22396 GameEventType::MedicDeath => {
22397 GameEvent::MedicDeath(MedicDeathEvent::read(stream, definition)?)
22398 }
22399 GameEventType::OvertimeNag => {
22400 GameEvent::OvertimeNag(OvertimeNagEvent::read(stream, definition)?)
22401 }
22402 GameEventType::TeamsChanged => {
22403 GameEvent::TeamsChanged(TeamsChangedEvent::read(stream, definition)?)
22404 }
22405 GameEventType::HalloweenPumpkinGrab => GameEvent::HalloweenPumpkinGrab(
22406 HalloweenPumpkinGrabEvent::read(stream, definition)?,
22407 ),
22408 GameEventType::RocketJump => {
22409 GameEvent::RocketJump(RocketJumpEvent::read(stream, definition)?)
22410 }
22411 GameEventType::RocketJumpLanded => {
22412 GameEvent::RocketJumpLanded(RocketJumpLandedEvent::read(stream, definition)?)
22413 }
22414 GameEventType::StickyJump => {
22415 GameEvent::StickyJump(StickyJumpEvent::read(stream, definition)?)
22416 }
22417 GameEventType::StickyJumpLanded => {
22418 GameEvent::StickyJumpLanded(StickyJumpLandedEvent::read(stream, definition)?)
22419 }
22420 GameEventType::RocketPackLaunch => {
22421 GameEvent::RocketPackLaunch(RocketPackLaunchEvent::read(stream, definition)?)
22422 }
22423 GameEventType::RocketPackLanded => {
22424 GameEvent::RocketPackLanded(RocketPackLandedEvent::read(stream, definition)?)
22425 }
22426 GameEventType::MedicDefended => {
22427 GameEvent::MedicDefended(MedicDefendedEvent::read(stream, definition)?)
22428 }
22429 GameEventType::LocalPlayerHealed => {
22430 GameEvent::LocalPlayerHealed(LocalPlayerHealedEvent::read(stream, definition)?)
22431 }
22432 GameEventType::PlayerDestroyedPipeBomb => GameEvent::PlayerDestroyedPipeBomb(
22433 PlayerDestroyedPipeBombEvent::read(stream, definition)?,
22434 ),
22435 GameEventType::ObjectDeflected => {
22436 GameEvent::ObjectDeflected(ObjectDeflectedEvent::read(stream, definition)?)
22437 }
22438 GameEventType::PlayerMvp => {
22439 GameEvent::PlayerMvp(PlayerMvpEvent::read(stream, definition)?)
22440 }
22441 GameEventType::RaidSpawnMob => {
22442 GameEvent::RaidSpawnMob(RaidSpawnMobEvent::read(stream, definition)?)
22443 }
22444 GameEventType::RaidSpawnSquad => {
22445 GameEvent::RaidSpawnSquad(RaidSpawnSquadEvent::read(stream, definition)?)
22446 }
22447 GameEventType::NavBlocked => {
22448 GameEvent::NavBlocked(NavBlockedEvent::read(stream, definition)?)
22449 }
22450 GameEventType::PathTrackPassed => {
22451 GameEvent::PathTrackPassed(PathTrackPassedEvent::read(stream, definition)?)
22452 }
22453 GameEventType::NumCappersChanged => {
22454 GameEvent::NumCappersChanged(NumCappersChangedEvent::read(stream, definition)?)
22455 }
22456 GameEventType::PlayerRegenerate => {
22457 GameEvent::PlayerRegenerate(PlayerRegenerateEvent::read(stream, definition)?)
22458 }
22459 GameEventType::UpdateStatusItem => {
22460 GameEvent::UpdateStatusItem(UpdateStatusItemEvent::read(stream, definition)?)
22461 }
22462 GameEventType::StatsResetRound => {
22463 GameEvent::StatsResetRound(StatsResetRoundEvent::read(stream, definition)?)
22464 }
22465 GameEventType::ScoreStatsAccumulatedUpdate => GameEvent::ScoreStatsAccumulatedUpdate(
22466 ScoreStatsAccumulatedUpdateEvent::read(stream, definition)?,
22467 ),
22468 GameEventType::ScoreStatsAccumulatedReset => GameEvent::ScoreStatsAccumulatedReset(
22469 ScoreStatsAccumulatedResetEvent::read(stream, definition)?,
22470 ),
22471 GameEventType::AchievementEarnedLocal => GameEvent::AchievementEarnedLocal(
22472 AchievementEarnedLocalEvent::read(stream, definition)?,
22473 ),
22474 GameEventType::PlayerHealed => {
22475 GameEvent::PlayerHealed(PlayerHealedEvent::read(stream, definition)?)
22476 }
22477 GameEventType::BuildingHealed => {
22478 GameEvent::BuildingHealed(BuildingHealedEvent::read(stream, definition)?)
22479 }
22480 GameEventType::ItemPickup => {
22481 GameEvent::ItemPickup(ItemPickupEvent::read(stream, definition)?)
22482 }
22483 GameEventType::DuelStatus => {
22484 GameEvent::DuelStatus(DuelStatusEvent::read(stream, definition)?)
22485 }
22486 GameEventType::FishNotice => {
22487 GameEvent::FishNotice(Box::new(<FishNoticeEvent>::read(stream, definition)?))
22488 }
22489 GameEventType::FishNoticeArm => {
22490 GameEvent::FishNoticeArm(Box::new(<FishNoticeArmEvent>::read(stream, definition)?))
22491 }
22492 GameEventType::SlapNotice => {
22493 GameEvent::SlapNotice(Box::new(<SlapNoticeEvent>::read(stream, definition)?))
22494 }
22495 GameEventType::ThrowableHit => {
22496 GameEvent::ThrowableHit(Box::new(<ThrowableHitEvent>::read(stream, definition)?))
22497 }
22498 GameEventType::PumpkinLordSummoned => {
22499 GameEvent::PumpkinLordSummoned(PumpkinLordSummonedEvent::read(stream, definition)?)
22500 }
22501 GameEventType::PumpkinLordKilled => {
22502 GameEvent::PumpkinLordKilled(PumpkinLordKilledEvent::read(stream, definition)?)
22503 }
22504 GameEventType::MerasmusSummoned => {
22505 GameEvent::MerasmusSummoned(MerasmusSummonedEvent::read(stream, definition)?)
22506 }
22507 GameEventType::MerasmusKilled => {
22508 GameEvent::MerasmusKilled(MerasmusKilledEvent::read(stream, definition)?)
22509 }
22510 GameEventType::MerasmusEscapeWarning => GameEvent::MerasmusEscapeWarning(
22511 MerasmusEscapeWarningEvent::read(stream, definition)?,
22512 ),
22513 GameEventType::MerasmusEscaped => {
22514 GameEvent::MerasmusEscaped(MerasmusEscapedEvent::read(stream, definition)?)
22515 }
22516 GameEventType::EyeballBossSummoned => {
22517 GameEvent::EyeballBossSummoned(EyeballBossSummonedEvent::read(stream, definition)?)
22518 }
22519 GameEventType::EyeballBossStunned => {
22520 GameEvent::EyeballBossStunned(EyeballBossStunnedEvent::read(stream, definition)?)
22521 }
22522 GameEventType::EyeballBossKilled => {
22523 GameEvent::EyeballBossKilled(EyeballBossKilledEvent::read(stream, definition)?)
22524 }
22525 GameEventType::EyeballBossKiller => {
22526 GameEvent::EyeballBossKiller(EyeballBossKillerEvent::read(stream, definition)?)
22527 }
22528 GameEventType::EyeballBossEscapeImminent => GameEvent::EyeballBossEscapeImminent(
22529 EyeballBossEscapeImminentEvent::read(stream, definition)?,
22530 ),
22531 GameEventType::EyeballBossEscaped => {
22532 GameEvent::EyeballBossEscaped(EyeballBossEscapedEvent::read(stream, definition)?)
22533 }
22534 GameEventType::NpcHurt => GameEvent::NpcHurt(NpcHurtEvent::read(stream, definition)?),
22535 GameEventType::ControlPointTimerUpdated => GameEvent::ControlPointTimerUpdated(
22536 ControlPointTimerUpdatedEvent::read(stream, definition)?,
22537 ),
22538 GameEventType::PlayerHighFiveStart => {
22539 GameEvent::PlayerHighFiveStart(PlayerHighFiveStartEvent::read(stream, definition)?)
22540 }
22541 GameEventType::PlayerHighFiveCancel => GameEvent::PlayerHighFiveCancel(
22542 PlayerHighFiveCancelEvent::read(stream, definition)?,
22543 ),
22544 GameEventType::PlayerHighFiveSuccess => GameEvent::PlayerHighFiveSuccess(
22545 PlayerHighFiveSuccessEvent::read(stream, definition)?,
22546 ),
22547 GameEventType::PlayerBonusPoints => {
22548 GameEvent::PlayerBonusPoints(PlayerBonusPointsEvent::read(stream, definition)?)
22549 }
22550 GameEventType::PlayerUpgraded => {
22551 GameEvent::PlayerUpgraded(PlayerUpgradedEvent::read(stream, definition)?)
22552 }
22553 GameEventType::PlayerBuyback => {
22554 GameEvent::PlayerBuyback(PlayerBuybackEvent::read(stream, definition)?)
22555 }
22556 GameEventType::PlayerUsedPowerUpBottle => GameEvent::PlayerUsedPowerUpBottle(
22557 PlayerUsedPowerUpBottleEvent::read(stream, definition)?,
22558 ),
22559 GameEventType::ChristmasGiftGrab => {
22560 GameEvent::ChristmasGiftGrab(ChristmasGiftGrabEvent::read(stream, definition)?)
22561 }
22562 GameEventType::PlayerKilledAchievementZone => GameEvent::PlayerKilledAchievementZone(
22563 PlayerKilledAchievementZoneEvent::read(stream, definition)?,
22564 ),
22565 GameEventType::PartyUpdated => {
22566 GameEvent::PartyUpdated(PartyUpdatedEvent::read(stream, definition)?)
22567 }
22568 GameEventType::PartyPrefChanged => {
22569 GameEvent::PartyPrefChanged(PartyPrefChangedEvent::read(stream, definition)?)
22570 }
22571 GameEventType::PartyCriteriaChanged => GameEvent::PartyCriteriaChanged(
22572 PartyCriteriaChangedEvent::read(stream, definition)?,
22573 ),
22574 GameEventType::PartyInvitesChanged => {
22575 GameEvent::PartyInvitesChanged(PartyInvitesChangedEvent::read(stream, definition)?)
22576 }
22577 GameEventType::PartyQueueStateChanged => GameEvent::PartyQueueStateChanged(
22578 PartyQueueStateChangedEvent::read(stream, definition)?,
22579 ),
22580 GameEventType::PartyChat => {
22581 GameEvent::PartyChat(PartyChatEvent::read(stream, definition)?)
22582 }
22583 GameEventType::PartyMemberJoin => {
22584 GameEvent::PartyMemberJoin(PartyMemberJoinEvent::read(stream, definition)?)
22585 }
22586 GameEventType::PartyMemberLeave => {
22587 GameEvent::PartyMemberLeave(PartyMemberLeaveEvent::read(stream, definition)?)
22588 }
22589 GameEventType::MatchInvitesUpdated => {
22590 GameEvent::MatchInvitesUpdated(MatchInvitesUpdatedEvent::read(stream, definition)?)
22591 }
22592 GameEventType::LobbyUpdated => {
22593 GameEvent::LobbyUpdated(LobbyUpdatedEvent::read(stream, definition)?)
22594 }
22595 GameEventType::MvmMissionUpdate => {
22596 GameEvent::MvmMissionUpdate(MvmMissionUpdateEvent::read(stream, definition)?)
22597 }
22598 GameEventType::RecalculateHolidays => {
22599 GameEvent::RecalculateHolidays(RecalculateHolidaysEvent::read(stream, definition)?)
22600 }
22601 GameEventType::PlayerCurrencyChanged => GameEvent::PlayerCurrencyChanged(
22602 PlayerCurrencyChangedEvent::read(stream, definition)?,
22603 ),
22604 GameEventType::DoomsdayRocketOpen => {
22605 GameEvent::DoomsdayRocketOpen(DoomsdayRocketOpenEvent::read(stream, definition)?)
22606 }
22607 GameEventType::RemoveNemesisRelationships => GameEvent::RemoveNemesisRelationships(
22608 RemoveNemesisRelationshipsEvent::read(stream, definition)?,
22609 ),
22610 GameEventType::MvmCreditBonusWave => {
22611 GameEvent::MvmCreditBonusWave(MvmCreditBonusWaveEvent::read(stream, definition)?)
22612 }
22613 GameEventType::MvmCreditBonusAll => {
22614 GameEvent::MvmCreditBonusAll(MvmCreditBonusAllEvent::read(stream, definition)?)
22615 }
22616 GameEventType::MvmCreditBonusAllAdvanced => GameEvent::MvmCreditBonusAllAdvanced(
22617 MvmCreditBonusAllAdvancedEvent::read(stream, definition)?,
22618 ),
22619 GameEventType::MvmQuickSentryUpgrade => GameEvent::MvmQuickSentryUpgrade(
22620 MvmQuickSentryUpgradeEvent::read(stream, definition)?,
22621 ),
22622 GameEventType::MvmTankDestroyedByPlayers => GameEvent::MvmTankDestroyedByPlayers(
22623 MvmTankDestroyedByPlayersEvent::read(stream, definition)?,
22624 ),
22625 GameEventType::MvmKillRobotDeliveringBomb => GameEvent::MvmKillRobotDeliveringBomb(
22626 MvmKillRobotDeliveringBombEvent::read(stream, definition)?,
22627 ),
22628 GameEventType::MvmPickupCurrency => {
22629 GameEvent::MvmPickupCurrency(MvmPickupCurrencyEvent::read(stream, definition)?)
22630 }
22631 GameEventType::MvmBombCarrierKilled => GameEvent::MvmBombCarrierKilled(
22632 MvmBombCarrierKilledEvent::read(stream, definition)?,
22633 ),
22634 GameEventType::MvmSentryBusterDetonate => GameEvent::MvmSentryBusterDetonate(
22635 MvmSentryBusterDetonateEvent::read(stream, definition)?,
22636 ),
22637 GameEventType::MvmScoutMarkedForDeath => GameEvent::MvmScoutMarkedForDeath(
22638 MvmScoutMarkedForDeathEvent::read(stream, definition)?,
22639 ),
22640 GameEventType::MvmMedicPowerUpShared => GameEvent::MvmMedicPowerUpShared(
22641 MvmMedicPowerUpSharedEvent::read(stream, definition)?,
22642 ),
22643 GameEventType::MvmBeginWave => {
22644 GameEvent::MvmBeginWave(MvmBeginWaveEvent::read(stream, definition)?)
22645 }
22646 GameEventType::MvmWaveComplete => {
22647 GameEvent::MvmWaveComplete(MvmWaveCompleteEvent::read(stream, definition)?)
22648 }
22649 GameEventType::MvmMissionComplete => {
22650 GameEvent::MvmMissionComplete(MvmMissionCompleteEvent::read(stream, definition)?)
22651 }
22652 GameEventType::MvmBombResetByPlayer => GameEvent::MvmBombResetByPlayer(
22653 MvmBombResetByPlayerEvent::read(stream, definition)?,
22654 ),
22655 GameEventType::MvmBombAlarmTriggered => GameEvent::MvmBombAlarmTriggered(
22656 MvmBombAlarmTriggeredEvent::read(stream, definition)?,
22657 ),
22658 GameEventType::MvmBombDeployResetByPlayer => GameEvent::MvmBombDeployResetByPlayer(
22659 MvmBombDeployResetByPlayerEvent::read(stream, definition)?,
22660 ),
22661 GameEventType::MvmWaveFailed => {
22662 GameEvent::MvmWaveFailed(MvmWaveFailedEvent::read(stream, definition)?)
22663 }
22664 GameEventType::MvmResetStats => {
22665 GameEvent::MvmResetStats(MvmResetStatsEvent::read(stream, definition)?)
22666 }
22667 GameEventType::DamageResisted => {
22668 GameEvent::DamageResisted(DamageResistedEvent::read(stream, definition)?)
22669 }
22670 GameEventType::RevivePlayerNotify => {
22671 GameEvent::RevivePlayerNotify(RevivePlayerNotifyEvent::read(stream, definition)?)
22672 }
22673 GameEventType::RevivePlayerStopped => {
22674 GameEvent::RevivePlayerStopped(RevivePlayerStoppedEvent::read(stream, definition)?)
22675 }
22676 GameEventType::RevivePlayerComplete => GameEvent::RevivePlayerComplete(
22677 RevivePlayerCompleteEvent::read(stream, definition)?,
22678 ),
22679 GameEventType::PlayerTurnedToGhost => {
22680 GameEvent::PlayerTurnedToGhost(PlayerTurnedToGhostEvent::read(stream, definition)?)
22681 }
22682 GameEventType::MedigunShieldBlockedDamage => GameEvent::MedigunShieldBlockedDamage(
22683 MedigunShieldBlockedDamageEvent::read(stream, definition)?,
22684 ),
22685 GameEventType::MvmAdvWaveCompleteNoGates => GameEvent::MvmAdvWaveCompleteNoGates(
22686 MvmAdvWaveCompleteNoGatesEvent::read(stream, definition)?,
22687 ),
22688 GameEventType::MvmSniperHeadshotCurrency => GameEvent::MvmSniperHeadshotCurrency(
22689 MvmSniperHeadshotCurrencyEvent::read(stream, definition)?,
22690 ),
22691 GameEventType::MvmMannhattanPit => {
22692 GameEvent::MvmMannhattanPit(MvmMannhattanPitEvent::read(stream, definition)?)
22693 }
22694 GameEventType::FlagCarriedInDetectionZone => GameEvent::FlagCarriedInDetectionZone(
22695 FlagCarriedInDetectionZoneEvent::read(stream, definition)?,
22696 ),
22697 GameEventType::MvmAdvWaveKilledStunRadio => GameEvent::MvmAdvWaveKilledStunRadio(
22698 MvmAdvWaveKilledStunRadioEvent::read(stream, definition)?,
22699 ),
22700 GameEventType::PlayerDirectHitStun => {
22701 GameEvent::PlayerDirectHitStun(PlayerDirectHitStunEvent::read(stream, definition)?)
22702 }
22703 GameEventType::MvmSentryBusterKilled => GameEvent::MvmSentryBusterKilled(
22704 MvmSentryBusterKilledEvent::read(stream, definition)?,
22705 ),
22706 GameEventType::UpgradesFileChanged => {
22707 GameEvent::UpgradesFileChanged(UpgradesFileChangedEvent::read(stream, definition)?)
22708 }
22709 GameEventType::RdTeamPointsChanged => {
22710 GameEvent::RdTeamPointsChanged(RdTeamPointsChangedEvent::read(stream, definition)?)
22711 }
22712 GameEventType::RdRulesStateChanged => {
22713 GameEvent::RdRulesStateChanged(RdRulesStateChangedEvent::read(stream, definition)?)
22714 }
22715 GameEventType::RdRobotKilled => {
22716 GameEvent::RdRobotKilled(RdRobotKilledEvent::read(stream, definition)?)
22717 }
22718 GameEventType::RdRobotImpact => {
22719 GameEvent::RdRobotImpact(RdRobotImpactEvent::read(stream, definition)?)
22720 }
22721 GameEventType::TeamPlayPreRoundTimeLeft => GameEvent::TeamPlayPreRoundTimeLeft(
22722 TeamPlayPreRoundTimeLeftEvent::read(stream, definition)?,
22723 ),
22724 GameEventType::ParachuteDeploy => {
22725 GameEvent::ParachuteDeploy(ParachuteDeployEvent::read(stream, definition)?)
22726 }
22727 GameEventType::ParachuteHolster => {
22728 GameEvent::ParachuteHolster(ParachuteHolsterEvent::read(stream, definition)?)
22729 }
22730 GameEventType::KillRefillsMeter => {
22731 GameEvent::KillRefillsMeter(KillRefillsMeterEvent::read(stream, definition)?)
22732 }
22733 GameEventType::RpsTauntEvent => {
22734 GameEvent::RpsTauntEvent(RpsTauntEventEvent::read(stream, definition)?)
22735 }
22736 GameEventType::CongaKill => {
22737 GameEvent::CongaKill(CongaKillEvent::read(stream, definition)?)
22738 }
22739 GameEventType::PlayerInitialSpawn => {
22740 GameEvent::PlayerInitialSpawn(PlayerInitialSpawnEvent::read(stream, definition)?)
22741 }
22742 GameEventType::CompetitiveVictory => {
22743 GameEvent::CompetitiveVictory(CompetitiveVictoryEvent::read(stream, definition)?)
22744 }
22745 GameEventType::CompetitiveStatsUpdate => GameEvent::CompetitiveStatsUpdate(
22746 CompetitiveStatsUpdateEvent::read(stream, definition)?,
22747 ),
22748 GameEventType::MiniGameWin => {
22749 GameEvent::MiniGameWin(MiniGameWinEvent::read(stream, definition)?)
22750 }
22751 GameEventType::SentryOnGoActive => {
22752 GameEvent::SentryOnGoActive(SentryOnGoActiveEvent::read(stream, definition)?)
22753 }
22754 GameEventType::DuckXpLevelUp => {
22755 GameEvent::DuckXpLevelUp(DuckXpLevelUpEvent::read(stream, definition)?)
22756 }
22757 GameEventType::QuestLogOpened => {
22758 GameEvent::QuestLogOpened(QuestLogOpenedEvent::read(stream, definition)?)
22759 }
22760 GameEventType::SchemaUpdated => {
22761 GameEvent::SchemaUpdated(SchemaUpdatedEvent::read(stream, definition)?)
22762 }
22763 GameEventType::LocalPlayerPickupWeapon => GameEvent::LocalPlayerPickupWeapon(
22764 LocalPlayerPickupWeaponEvent::read(stream, definition)?,
22765 ),
22766 GameEventType::RdPlayerScorePoints => {
22767 GameEvent::RdPlayerScorePoints(RdPlayerScorePointsEvent::read(stream, definition)?)
22768 }
22769 GameEventType::DemomanDetStickies => {
22770 GameEvent::DemomanDetStickies(DemomanDetStickiesEvent::read(stream, definition)?)
22771 }
22772 GameEventType::QuestObjectiveCompleted => GameEvent::QuestObjectiveCompleted(
22773 QuestObjectiveCompletedEvent::read(stream, definition)?,
22774 ),
22775 GameEventType::PlayerScoreChanged => {
22776 GameEvent::PlayerScoreChanged(PlayerScoreChangedEvent::read(stream, definition)?)
22777 }
22778 GameEventType::KilledCappingPlayer => {
22779 GameEvent::KilledCappingPlayer(KilledCappingPlayerEvent::read(stream, definition)?)
22780 }
22781 GameEventType::EnvironmentalDeath => {
22782 GameEvent::EnvironmentalDeath(EnvironmentalDeathEvent::read(stream, definition)?)
22783 }
22784 GameEventType::ProjectileDirectHit => {
22785 GameEvent::ProjectileDirectHit(ProjectileDirectHitEvent::read(stream, definition)?)
22786 }
22787 GameEventType::PassGet => GameEvent::PassGet(PassGetEvent::read(stream, definition)?),
22788 GameEventType::PassScore => {
22789 GameEvent::PassScore(PassScoreEvent::read(stream, definition)?)
22790 }
22791 GameEventType::PassFree => {
22792 GameEvent::PassFree(PassFreeEvent::read(stream, definition)?)
22793 }
22794 GameEventType::PassPassCaught => {
22795 GameEvent::PassPassCaught(PassPassCaughtEvent::read(stream, definition)?)
22796 }
22797 GameEventType::PassBallStolen => {
22798 GameEvent::PassBallStolen(PassBallStolenEvent::read(stream, definition)?)
22799 }
22800 GameEventType::PassBallBlocked => {
22801 GameEvent::PassBallBlocked(PassBallBlockedEvent::read(stream, definition)?)
22802 }
22803 GameEventType::DamagePrevented => {
22804 GameEvent::DamagePrevented(DamagePreventedEvent::read(stream, definition)?)
22805 }
22806 GameEventType::HalloweenBossKilled => {
22807 GameEvent::HalloweenBossKilled(HalloweenBossKilledEvent::read(stream, definition)?)
22808 }
22809 GameEventType::EscapedLootIsland => {
22810 GameEvent::EscapedLootIsland(EscapedLootIslandEvent::read(stream, definition)?)
22811 }
22812 GameEventType::TaggedPlayerAsIt => {
22813 GameEvent::TaggedPlayerAsIt(TaggedPlayerAsItEvent::read(stream, definition)?)
22814 }
22815 GameEventType::MerasmusStunned => {
22816 GameEvent::MerasmusStunned(MerasmusStunnedEvent::read(stream, definition)?)
22817 }
22818 GameEventType::MerasmusPropFound => {
22819 GameEvent::MerasmusPropFound(MerasmusPropFoundEvent::read(stream, definition)?)
22820 }
22821 GameEventType::HalloweenSkeletonKilled => GameEvent::HalloweenSkeletonKilled(
22822 HalloweenSkeletonKilledEvent::read(stream, definition)?,
22823 ),
22824 GameEventType::SkeletonKilledQuest => {
22825 GameEvent::SkeletonKilledQuest(SkeletonKilledQuestEvent::read(stream, definition)?)
22826 }
22827 GameEventType::SkeletonKingKilledQuest => GameEvent::SkeletonKingKilledQuest(
22828 SkeletonKingKilledQuestEvent::read(stream, definition)?,
22829 ),
22830 GameEventType::EscapeHell => {
22831 GameEvent::EscapeHell(EscapeHellEvent::read(stream, definition)?)
22832 }
22833 GameEventType::CrossSpectralBridge => {
22834 GameEvent::CrossSpectralBridge(CrossSpectralBridgeEvent::read(stream, definition)?)
22835 }
22836 GameEventType::MiniGameWon => {
22837 GameEvent::MiniGameWon(MiniGameWonEvent::read(stream, definition)?)
22838 }
22839 GameEventType::RespawnGhost => {
22840 GameEvent::RespawnGhost(RespawnGhostEvent::read(stream, definition)?)
22841 }
22842 GameEventType::KillInHell => {
22843 GameEvent::KillInHell(KillInHellEvent::read(stream, definition)?)
22844 }
22845 GameEventType::HalloweenDuckCollected => GameEvent::HalloweenDuckCollected(
22846 HalloweenDuckCollectedEvent::read(stream, definition)?,
22847 ),
22848 GameEventType::SpecialScore => {
22849 GameEvent::SpecialScore(SpecialScoreEvent::read(stream, definition)?)
22850 }
22851 GameEventType::TeamLeaderKilled => {
22852 GameEvent::TeamLeaderKilled(TeamLeaderKilledEvent::read(stream, definition)?)
22853 }
22854 GameEventType::HalloweenSoulCollected => GameEvent::HalloweenSoulCollected(
22855 HalloweenSoulCollectedEvent::read(stream, definition)?,
22856 ),
22857 GameEventType::RecalculateTruce => {
22858 GameEvent::RecalculateTruce(RecalculateTruceEvent::read(stream, definition)?)
22859 }
22860 GameEventType::DeadRingerCheatDeath => GameEvent::DeadRingerCheatDeath(
22861 DeadRingerCheatDeathEvent::read(stream, definition)?,
22862 ),
22863 GameEventType::CrossbowHeal => {
22864 GameEvent::CrossbowHeal(CrossbowHealEvent::read(stream, definition)?)
22865 }
22866 GameEventType::DamageMitigated => {
22867 GameEvent::DamageMitigated(DamageMitigatedEvent::read(stream, definition)?)
22868 }
22869 GameEventType::PayloadPushed => {
22870 GameEvent::PayloadPushed(PayloadPushedEvent::read(stream, definition)?)
22871 }
22872 GameEventType::PlayerAbandonedMatch => GameEvent::PlayerAbandonedMatch(
22873 PlayerAbandonedMatchEvent::read(stream, definition)?,
22874 ),
22875 GameEventType::ClDrawline => {
22876 GameEvent::ClDrawline(ClDrawlineEvent::read(stream, definition)?)
22877 }
22878 GameEventType::RestartTimerTime => {
22879 GameEvent::RestartTimerTime(RestartTimerTimeEvent::read(stream, definition)?)
22880 }
22881 GameEventType::WinLimitChanged => {
22882 GameEvent::WinLimitChanged(WinLimitChangedEvent::read(stream, definition)?)
22883 }
22884 GameEventType::WinPanelShowScores => {
22885 GameEvent::WinPanelShowScores(WinPanelShowScoresEvent::read(stream, definition)?)
22886 }
22887 GameEventType::TopStreamsRequestFinished => GameEvent::TopStreamsRequestFinished(
22888 TopStreamsRequestFinishedEvent::read(stream, definition)?,
22889 ),
22890 GameEventType::CompetitiveStateChanged => GameEvent::CompetitiveStateChanged(
22891 CompetitiveStateChangedEvent::read(stream, definition)?,
22892 ),
22893 GameEventType::GlobalWarDataUpdated => GameEvent::GlobalWarDataUpdated(
22894 GlobalWarDataUpdatedEvent::read(stream, definition)?,
22895 ),
22896 GameEventType::StopWatchChanged => {
22897 GameEvent::StopWatchChanged(StopWatchChangedEvent::read(stream, definition)?)
22898 }
22899 GameEventType::DsStop => GameEvent::DsStop(DsStopEvent::read(stream, definition)?),
22900 GameEventType::DsScreenshot => {
22901 GameEvent::DsScreenshot(DsScreenshotEvent::read(stream, definition)?)
22902 }
22903 GameEventType::ShowMatchSummary => {
22904 GameEvent::ShowMatchSummary(ShowMatchSummaryEvent::read(stream, definition)?)
22905 }
22906 GameEventType::ExperienceChanged => {
22907 GameEvent::ExperienceChanged(ExperienceChangedEvent::read(stream, definition)?)
22908 }
22909 GameEventType::BeginXpLerp => {
22910 GameEvent::BeginXpLerp(BeginXpLerpEvent::read(stream, definition)?)
22911 }
22912 GameEventType::MatchmakerStatsUpdated => GameEvent::MatchmakerStatsUpdated(
22913 MatchmakerStatsUpdatedEvent::read(stream, definition)?,
22914 ),
22915 GameEventType::RematchVotePeriodOver => GameEvent::RematchVotePeriodOver(
22916 RematchVotePeriodOverEvent::read(stream, definition)?,
22917 ),
22918 GameEventType::RematchFailedToCreate => GameEvent::RematchFailedToCreate(
22919 RematchFailedToCreateEvent::read(stream, definition)?,
22920 ),
22921 GameEventType::PlayerRematchChange => {
22922 GameEvent::PlayerRematchChange(PlayerRematchChangeEvent::read(stream, definition)?)
22923 }
22924 GameEventType::PingUpdated => {
22925 GameEvent::PingUpdated(PingUpdatedEvent::read(stream, definition)?)
22926 }
22927 GameEventType::MMStatsUpdated => {
22928 GameEvent::MMStatsUpdated(MMStatsUpdatedEvent::read(stream, definition)?)
22929 }
22930 GameEventType::PlayerNextMapVoteChange => GameEvent::PlayerNextMapVoteChange(
22931 PlayerNextMapVoteChangeEvent::read(stream, definition)?,
22932 ),
22933 GameEventType::VoteMapsChanged => {
22934 GameEvent::VoteMapsChanged(VoteMapsChangedEvent::read(stream, definition)?)
22935 }
22936 GameEventType::ProtoDefChanged => {
22937 GameEvent::ProtoDefChanged(ProtoDefChangedEvent::read(stream, definition)?)
22938 }
22939 GameEventType::PlayerDomination => {
22940 GameEvent::PlayerDomination(PlayerDominationEvent::read(stream, definition)?)
22941 }
22942 GameEventType::PlayerRocketPackPushed => GameEvent::PlayerRocketPackPushed(
22943 PlayerRocketPackPushedEvent::read(stream, definition)?,
22944 ),
22945 GameEventType::QuestRequest => {
22946 GameEvent::QuestRequest(QuestRequestEvent::read(stream, definition)?)
22947 }
22948 GameEventType::QuestResponse => {
22949 GameEvent::QuestResponse(QuestResponseEvent::read(stream, definition)?)
22950 }
22951 GameEventType::QuestProgress => {
22952 GameEvent::QuestProgress(QuestProgressEvent::read(stream, definition)?)
22953 }
22954 GameEventType::ProjectileRemoved => {
22955 GameEvent::ProjectileRemoved(ProjectileRemovedEvent::read(stream, definition)?)
22956 }
22957 GameEventType::QuestMapDataChanged => {
22958 GameEvent::QuestMapDataChanged(QuestMapDataChangedEvent::read(stream, definition)?)
22959 }
22960 GameEventType::GasDousedPlayerIgnited => GameEvent::GasDousedPlayerIgnited(
22961 GasDousedPlayerIgnitedEvent::read(stream, definition)?,
22962 ),
22963 GameEventType::QuestTurnInState => {
22964 GameEvent::QuestTurnInState(QuestTurnInStateEvent::read(stream, definition)?)
22965 }
22966 GameEventType::ItemsAcknowledged => {
22967 GameEvent::ItemsAcknowledged(ItemsAcknowledgedEvent::read(stream, definition)?)
22968 }
22969 GameEventType::CapperKilled => {
22970 GameEvent::CapperKilled(CapperKilledEvent::read(stream, definition)?)
22971 }
22972 GameEventType::MainMenuStabilized => {
22973 GameEvent::MainMenuStabilized(MainMenuStabilizedEvent::read(stream, definition)?)
22974 }
22975 GameEventType::WorldStatusChanged => {
22976 GameEvent::WorldStatusChanged(WorldStatusChangedEvent::read(stream, definition)?)
22977 }
22978 GameEventType::HLTVStatus => {
22979 GameEvent::HLTVStatus(HLTVStatusEvent::read(stream, definition)?)
22980 }
22981 GameEventType::HLTVCameraman => {
22982 GameEvent::HLTVCameraman(HLTVCameramanEvent::read(stream, definition)?)
22983 }
22984 GameEventType::HLTVRankCamera => {
22985 GameEvent::HLTVRankCamera(HLTVRankCameraEvent::read(stream, definition)?)
22986 }
22987 GameEventType::HLTVRankEntity => {
22988 GameEvent::HLTVRankEntity(HLTVRankEntityEvent::read(stream, definition)?)
22989 }
22990 GameEventType::HLTVFixed => {
22991 GameEvent::HLTVFixed(HLTVFixedEvent::read(stream, definition)?)
22992 }
22993 GameEventType::HLTVChase => {
22994 GameEvent::HLTVChase(HLTVChaseEvent::read(stream, definition)?)
22995 }
22996 GameEventType::HLTVMessage => {
22997 GameEvent::HLTVMessage(HLTVMessageEvent::read(stream, definition)?)
22998 }
22999 GameEventType::HLTVTitle => {
23000 GameEvent::HLTVTitle(HLTVTitleEvent::read(stream, definition)?)
23001 }
23002 GameEventType::HLTVChat => {
23003 GameEvent::HLTVChat(HLTVChatEvent::read(stream, definition)?)
23004 }
23005 GameEventType::ReplayStartRecord => {
23006 GameEvent::ReplayStartRecord(ReplayStartRecordEvent::read(stream, definition)?)
23007 }
23008 GameEventType::ReplaySessionInfo => {
23009 GameEvent::ReplaySessionInfo(ReplaySessionInfoEvent::read(stream, definition)?)
23010 }
23011 GameEventType::ReplayEndRecord => {
23012 GameEvent::ReplayEndRecord(ReplayEndRecordEvent::read(stream, definition)?)
23013 }
23014 GameEventType::ReplayReplaysAvailable => GameEvent::ReplayReplaysAvailable(
23015 ReplayReplaysAvailableEvent::read(stream, definition)?,
23016 ),
23017 GameEventType::ReplayServerError => {
23018 GameEvent::ReplayServerError(ReplayServerErrorEvent::read(stream, definition)?)
23019 }
23020 GameEventType::Unknown(_) => {
23021 GameEvent::Unknown(RawGameEvent::read(stream, definition)?)
23022 }
23023 })
23024 }
23025 pub fn write(
23026 &self,
23027 stream: &mut BitWriteStream<LittleEndian>,
23028 definition: &GameEventDefinition,
23029 ) -> Result<()> {
23030 match &self {
23031 GameEvent::ServerSpawn(event) => event.write(stream, definition),
23032 GameEvent::ServerChangeLevelFailed(event) => event.write(stream, definition),
23033 GameEvent::ServerShutdown(event) => event.write(stream, definition),
23034 GameEvent::ServerCvar(event) => event.write(stream, definition),
23035 GameEvent::ServerMessage(event) => event.write(stream, definition),
23036 GameEvent::ServerAddBan(event) => event.write(stream, definition),
23037 GameEvent::ServerRemoveBan(event) => event.write(stream, definition),
23038 GameEvent::PlayerConnect(event) => event.write(stream, definition),
23039 GameEvent::PlayerConnectClient(event) => event.write(stream, definition),
23040 GameEvent::PlayerInfo(event) => event.write(stream, definition),
23041 GameEvent::PlayerDisconnect(event) => event.write(stream, definition),
23042 GameEvent::PlayerActivate(event) => event.write(stream, definition),
23043 GameEvent::PlayerSay(event) => event.write(stream, definition),
23044 GameEvent::ClientDisconnect(event) => event.write(stream, definition),
23045 GameEvent::ClientBeginConnect(event) => event.write(stream, definition),
23046 GameEvent::ClientConnected(event) => event.write(stream, definition),
23047 GameEvent::ClientFullConnect(event) => event.write(stream, definition),
23048 GameEvent::HostQuit(event) => event.write(stream, definition),
23049 GameEvent::TeamInfo(event) => event.write(stream, definition),
23050 GameEvent::TeamScore(event) => event.write(stream, definition),
23051 GameEvent::TeamPlayBroadcastAudio(event) => event.write(stream, definition),
23052 GameEvent::PlayerTeam(event) => event.write(stream, definition),
23053 GameEvent::PlayerClass(event) => event.write(stream, definition),
23054 GameEvent::PlayerDeath(event) => event.write(stream, definition),
23055 GameEvent::PlayerHurt(event) => event.write(stream, definition),
23056 GameEvent::PlayerChat(event) => event.write(stream, definition),
23057 GameEvent::PlayerScore(event) => event.write(stream, definition),
23058 GameEvent::PlayerSpawn(event) => event.write(stream, definition),
23059 GameEvent::PlayerShoot(event) => event.write(stream, definition),
23060 GameEvent::PlayerUse(event) => event.write(stream, definition),
23061 GameEvent::PlayerChangeName(event) => event.write(stream, definition),
23062 GameEvent::PlayerHintMessage(event) => event.write(stream, definition),
23063 GameEvent::BasePlayerTeleported(event) => event.write(stream, definition),
23064 GameEvent::GameInit(event) => event.write(stream, definition),
23065 GameEvent::GameNewMap(event) => event.write(stream, definition),
23066 GameEvent::GameStart(event) => event.write(stream, definition),
23067 GameEvent::GameEnd(event) => event.write(stream, definition),
23068 GameEvent::RoundStart(event) => event.write(stream, definition),
23069 GameEvent::RoundEnd(event) => event.write(stream, definition),
23070 GameEvent::GameMessage(event) => event.write(stream, definition),
23071 GameEvent::BreakBreakable(event) => event.write(stream, definition),
23072 GameEvent::BreakProp(event) => event.write(stream, definition),
23073 GameEvent::EntityKilled(event) => event.write(stream, definition),
23074 GameEvent::BonusUpdated(event) => event.write(stream, definition),
23075 GameEvent::AchievementEvent(event) => event.write(stream, definition),
23076 GameEvent::AchievementIncrement(event) => event.write(stream, definition),
23077 GameEvent::PhysgunPickup(event) => event.write(stream, definition),
23078 GameEvent::FlareIgniteNpc(event) => event.write(stream, definition),
23079 GameEvent::HelicopterGrenadePuntMiss(event) => event.write(stream, definition),
23080 GameEvent::UserDataDownloaded(event) => event.write(stream, definition),
23081 GameEvent::RagdollDissolved(event) => event.write(stream, definition),
23082 GameEvent::HLTVChangedMode(event) => event.write(stream, definition),
23083 GameEvent::HLTVChangedTarget(event) => event.write(stream, definition),
23084 GameEvent::VoteEnded(event) => event.write(stream, definition),
23085 GameEvent::VoteStarted(event) => event.write(stream, definition),
23086 GameEvent::VoteChanged(event) => event.write(stream, definition),
23087 GameEvent::VotePassed(event) => event.write(stream, definition),
23088 GameEvent::VoteFailed(event) => event.write(stream, definition),
23089 GameEvent::VoteCast(event) => event.write(stream, definition),
23090 GameEvent::VoteOptions(event) => event.write(stream, definition),
23091 GameEvent::ReplaySaved(event) => event.write(stream, definition),
23092 GameEvent::EnteredPerformanceMode(event) => event.write(stream, definition),
23093 GameEvent::BrowseReplays(event) => event.write(stream, definition),
23094 GameEvent::ReplayYoutubeStats(event) => event.write(stream, definition),
23095 GameEvent::InventoryUpdated(event) => event.write(stream, definition),
23096 GameEvent::CartUpdated(event) => event.write(stream, definition),
23097 GameEvent::StorePriceSheetUpdated(event) => event.write(stream, definition),
23098 GameEvent::EconInventoryConnected(event) => event.write(stream, definition),
23099 GameEvent::ItemSchemaInitialized(event) => event.write(stream, definition),
23100 GameEvent::GcNewSession(event) => event.write(stream, definition),
23101 GameEvent::GcLostSession(event) => event.write(stream, definition),
23102 GameEvent::IntroFinish(event) => event.write(stream, definition),
23103 GameEvent::IntroNextCamera(event) => event.write(stream, definition),
23104 GameEvent::PlayerChangeClass(event) => event.write(stream, definition),
23105 GameEvent::TfMapTimeRemaining(event) => event.write(stream, definition),
23106 GameEvent::TfGameOver(event) => event.write(stream, definition),
23107 GameEvent::CtfFlagCaptured(event) => event.write(stream, definition),
23108 GameEvent::ControlPointInitialized(event) => event.write(stream, definition),
23109 GameEvent::ControlPointUpdateImages(event) => event.write(stream, definition),
23110 GameEvent::ControlPointUpdateLayout(event) => event.write(stream, definition),
23111 GameEvent::ControlPointUpdateCapping(event) => event.write(stream, definition),
23112 GameEvent::ControlPointUpdateOwner(event) => event.write(stream, definition),
23113 GameEvent::ControlPointStartTouch(event) => event.write(stream, definition),
23114 GameEvent::ControlPointEndTouch(event) => event.write(stream, definition),
23115 GameEvent::ControlPointPulseElement(event) => event.write(stream, definition),
23116 GameEvent::ControlPointFakeCapture(event) => event.write(stream, definition),
23117 GameEvent::ControlPointFakeCaptureMultiplier(event) => event.write(stream, definition),
23118 GameEvent::TeamPlayRoundSelected(event) => event.write(stream, definition),
23119 GameEvent::TeamPlayRoundStart(event) => event.write(stream, definition),
23120 GameEvent::TeamPlayRoundActive(event) => event.write(stream, definition),
23121 GameEvent::TeamPlayWaitingBegins(event) => event.write(stream, definition),
23122 GameEvent::TeamPlayWaitingEnds(event) => event.write(stream, definition),
23123 GameEvent::TeamPlayWaitingAboutToEnd(event) => event.write(stream, definition),
23124 GameEvent::TeamPlayRestartRound(event) => event.write(stream, definition),
23125 GameEvent::TeamPlayReadyRestart(event) => event.write(stream, definition),
23126 GameEvent::TeamPlayRoundRestartSeconds(event) => event.write(stream, definition),
23127 GameEvent::TeamPlayTeamReady(event) => event.write(stream, definition),
23128 GameEvent::TeamPlayRoundWin(event) => event.write(stream, definition),
23129 GameEvent::TeamPlayUpdateTimer(event) => event.write(stream, definition),
23130 GameEvent::TeamPlayRoundStalemate(event) => event.write(stream, definition),
23131 GameEvent::TeamPlayOvertimeBegin(event) => event.write(stream, definition),
23132 GameEvent::TeamPlayOvertimeEnd(event) => event.write(stream, definition),
23133 GameEvent::TeamPlaySuddenDeathBegin(event) => event.write(stream, definition),
23134 GameEvent::TeamPlaySuddenDeathEnd(event) => event.write(stream, definition),
23135 GameEvent::TeamPlayGameOver(event) => event.write(stream, definition),
23136 GameEvent::TeamPlayMapTimeRemaining(event) => event.write(stream, definition),
23137 GameEvent::TeamPlayTimerFlash(event) => event.write(stream, definition),
23138 GameEvent::TeamPlayTimerTimeAdded(event) => event.write(stream, definition),
23139 GameEvent::TeamPlayPointStartCapture(event) => event.write(stream, definition),
23140 GameEvent::TeamPlayPointCaptured(event) => event.write(stream, definition),
23141 GameEvent::TeamPlayPointLocked(event) => event.write(stream, definition),
23142 GameEvent::TeamPlayPointUnlocked(event) => event.write(stream, definition),
23143 GameEvent::TeamPlayCaptureBroken(event) => event.write(stream, definition),
23144 GameEvent::TeamPlayCaptureBlocked(event) => event.write(stream, definition),
23145 GameEvent::TeamPlayFlagEvent(event) => event.write(stream, definition),
23146 GameEvent::TeamPlayWinPanel(event) => event.write(stream, definition),
23147 GameEvent::TeamPlayTeamBalancedPlayer(event) => event.write(stream, definition),
23148 GameEvent::TeamPlaySetupFinished(event) => event.write(stream, definition),
23149 GameEvent::TeamPlayAlert(event) => event.write(stream, definition),
23150 GameEvent::TrainingComplete(event) => event.write(stream, definition),
23151 GameEvent::ShowFreezePanel(event) => event.write(stream, definition),
23152 GameEvent::HideFreezePanel(event) => event.write(stream, definition),
23153 GameEvent::FreezeCamStarted(event) => event.write(stream, definition),
23154 GameEvent::LocalPlayerChangeTeam(event) => event.write(stream, definition),
23155 GameEvent::LocalPlayerScoreChanged(event) => event.write(stream, definition),
23156 GameEvent::LocalPlayerChangeClass(event) => event.write(stream, definition),
23157 GameEvent::LocalPlayerRespawn(event) => event.write(stream, definition),
23158 GameEvent::BuildingInfoChanged(event) => event.write(stream, definition),
23159 GameEvent::LocalPlayerChangeDisguise(event) => event.write(stream, definition),
23160 GameEvent::PlayerAccountChanged(event) => event.write(stream, definition),
23161 GameEvent::SpyPdaReset(event) => event.write(stream, definition),
23162 GameEvent::FlagStatusUpdate(event) => event.write(stream, definition),
23163 GameEvent::PlayerStatsUpdated(event) => event.write(stream, definition),
23164 GameEvent::PlayingCommentary(event) => event.write(stream, definition),
23165 GameEvent::PlayerChargeDeployed(event) => event.write(stream, definition),
23166 GameEvent::PlayerBuiltObject(event) => event.write(stream, definition),
23167 GameEvent::PlayerUpgradedObject(event) => event.write(stream, definition),
23168 GameEvent::PlayerCarryObject(event) => event.write(stream, definition),
23169 GameEvent::PlayerDropObject(event) => event.write(stream, definition),
23170 GameEvent::ObjectRemoved(event) => event.write(stream, definition),
23171 GameEvent::ObjectDestroyed(event) => event.write(stream, definition),
23172 GameEvent::ObjectDetonated(event) => event.write(stream, definition),
23173 GameEvent::AchievementEarned(event) => event.write(stream, definition),
23174 GameEvent::SpecTargetUpdated(event) => event.write(stream, definition),
23175 GameEvent::TournamentStateUpdate(event) => event.write(stream, definition),
23176 GameEvent::TournamentEnableCountdown(event) => event.write(stream, definition),
23177 GameEvent::PlayerCalledForMedic(event) => event.write(stream, definition),
23178 GameEvent::PlayerAskedForBall(event) => event.write(stream, definition),
23179 GameEvent::LocalPlayerBecameObserver(event) => event.write(stream, definition),
23180 GameEvent::PlayerIgnitedInv(event) => event.write(stream, definition),
23181 GameEvent::PlayerIgnited(event) => event.write(stream, definition),
23182 GameEvent::PlayerExtinguished(event) => event.write(stream, definition),
23183 GameEvent::PlayerTeleported(event) => event.write(stream, definition),
23184 GameEvent::PlayerHealedMedicCall(event) => event.write(stream, definition),
23185 GameEvent::LocalPlayerChargeReady(event) => event.write(stream, definition),
23186 GameEvent::LocalPlayerWindDown(event) => event.write(stream, definition),
23187 GameEvent::PlayerInvulned(event) => event.write(stream, definition),
23188 GameEvent::EscortSpeed(event) => event.write(stream, definition),
23189 GameEvent::EscortProgress(event) => event.write(stream, definition),
23190 GameEvent::EscortRecede(event) => event.write(stream, definition),
23191 GameEvent::GameUIActivated(event) => event.write(stream, definition),
23192 GameEvent::GameUIHidden(event) => event.write(stream, definition),
23193 GameEvent::PlayerEscortScore(event) => event.write(stream, definition),
23194 GameEvent::PlayerHealOnHit(event) => event.write(stream, definition),
23195 GameEvent::PlayerStealSandvich(event) => event.write(stream, definition),
23196 GameEvent::ShowClassLayout(event) => event.write(stream, definition),
23197 GameEvent::ShowVsPanel(event) => event.write(stream, definition),
23198 GameEvent::PlayerDamaged(event) => event.write(stream, definition),
23199 GameEvent::ArenaPlayerNotification(event) => event.write(stream, definition),
23200 GameEvent::ArenaMatchMaxStreak(event) => event.write(stream, definition),
23201 GameEvent::ArenaRoundStart(event) => event.write(stream, definition),
23202 GameEvent::ArenaWinPanel(event) => event.write(stream, definition),
23203 GameEvent::PveWinPanel(event) => event.write(stream, definition),
23204 GameEvent::AirDash(event) => event.write(stream, definition),
23205 GameEvent::Landed(event) => event.write(stream, definition),
23206 GameEvent::PlayerDamageDodged(event) => event.write(stream, definition),
23207 GameEvent::PlayerStunned(event) => event.write(stream, definition),
23208 GameEvent::ScoutGrandSlam(event) => event.write(stream, definition),
23209 GameEvent::ScoutSlamdollLanded(event) => event.write(stream, definition),
23210 GameEvent::ArrowImpact(event) => event.write(stream, definition),
23211 GameEvent::PlayerJarated(event) => event.write(stream, definition),
23212 GameEvent::PlayerJaratedFade(event) => event.write(stream, definition),
23213 GameEvent::PlayerShieldBlocked(event) => event.write(stream, definition),
23214 GameEvent::PlayerPinned(event) => event.write(stream, definition),
23215 GameEvent::PlayerHealedByMedic(event) => event.write(stream, definition),
23216 GameEvent::PlayerSappedObject(event) => event.write(stream, definition),
23217 GameEvent::ItemFound(event) => event.write(stream, definition),
23218 GameEvent::ShowAnnotation(event) => event.write(stream, definition),
23219 GameEvent::HideAnnotation(event) => event.write(stream, definition),
23220 GameEvent::PostInventoryApplication(event) => event.write(stream, definition),
23221 GameEvent::ControlPointUnlockUpdated(event) => event.write(stream, definition),
23222 GameEvent::DeployBuffBanner(event) => event.write(stream, definition),
23223 GameEvent::PlayerBuff(event) => event.write(stream, definition),
23224 GameEvent::MedicDeath(event) => event.write(stream, definition),
23225 GameEvent::OvertimeNag(event) => event.write(stream, definition),
23226 GameEvent::TeamsChanged(event) => event.write(stream, definition),
23227 GameEvent::HalloweenPumpkinGrab(event) => event.write(stream, definition),
23228 GameEvent::RocketJump(event) => event.write(stream, definition),
23229 GameEvent::RocketJumpLanded(event) => event.write(stream, definition),
23230 GameEvent::StickyJump(event) => event.write(stream, definition),
23231 GameEvent::StickyJumpLanded(event) => event.write(stream, definition),
23232 GameEvent::RocketPackLaunch(event) => event.write(stream, definition),
23233 GameEvent::RocketPackLanded(event) => event.write(stream, definition),
23234 GameEvent::MedicDefended(event) => event.write(stream, definition),
23235 GameEvent::LocalPlayerHealed(event) => event.write(stream, definition),
23236 GameEvent::PlayerDestroyedPipeBomb(event) => event.write(stream, definition),
23237 GameEvent::ObjectDeflected(event) => event.write(stream, definition),
23238 GameEvent::PlayerMvp(event) => event.write(stream, definition),
23239 GameEvent::RaidSpawnMob(event) => event.write(stream, definition),
23240 GameEvent::RaidSpawnSquad(event) => event.write(stream, definition),
23241 GameEvent::NavBlocked(event) => event.write(stream, definition),
23242 GameEvent::PathTrackPassed(event) => event.write(stream, definition),
23243 GameEvent::NumCappersChanged(event) => event.write(stream, definition),
23244 GameEvent::PlayerRegenerate(event) => event.write(stream, definition),
23245 GameEvent::UpdateStatusItem(event) => event.write(stream, definition),
23246 GameEvent::StatsResetRound(event) => event.write(stream, definition),
23247 GameEvent::ScoreStatsAccumulatedUpdate(event) => event.write(stream, definition),
23248 GameEvent::ScoreStatsAccumulatedReset(event) => event.write(stream, definition),
23249 GameEvent::AchievementEarnedLocal(event) => event.write(stream, definition),
23250 GameEvent::PlayerHealed(event) => event.write(stream, definition),
23251 GameEvent::BuildingHealed(event) => event.write(stream, definition),
23252 GameEvent::ItemPickup(event) => event.write(stream, definition),
23253 GameEvent::DuelStatus(event) => event.write(stream, definition),
23254 GameEvent::FishNotice(event) => event.write(stream, definition),
23255 GameEvent::FishNoticeArm(event) => event.write(stream, definition),
23256 GameEvent::SlapNotice(event) => event.write(stream, definition),
23257 GameEvent::ThrowableHit(event) => event.write(stream, definition),
23258 GameEvent::PumpkinLordSummoned(event) => event.write(stream, definition),
23259 GameEvent::PumpkinLordKilled(event) => event.write(stream, definition),
23260 GameEvent::MerasmusSummoned(event) => event.write(stream, definition),
23261 GameEvent::MerasmusKilled(event) => event.write(stream, definition),
23262 GameEvent::MerasmusEscapeWarning(event) => event.write(stream, definition),
23263 GameEvent::MerasmusEscaped(event) => event.write(stream, definition),
23264 GameEvent::EyeballBossSummoned(event) => event.write(stream, definition),
23265 GameEvent::EyeballBossStunned(event) => event.write(stream, definition),
23266 GameEvent::EyeballBossKilled(event) => event.write(stream, definition),
23267 GameEvent::EyeballBossKiller(event) => event.write(stream, definition),
23268 GameEvent::EyeballBossEscapeImminent(event) => event.write(stream, definition),
23269 GameEvent::EyeballBossEscaped(event) => event.write(stream, definition),
23270 GameEvent::NpcHurt(event) => event.write(stream, definition),
23271 GameEvent::ControlPointTimerUpdated(event) => event.write(stream, definition),
23272 GameEvent::PlayerHighFiveStart(event) => event.write(stream, definition),
23273 GameEvent::PlayerHighFiveCancel(event) => event.write(stream, definition),
23274 GameEvent::PlayerHighFiveSuccess(event) => event.write(stream, definition),
23275 GameEvent::PlayerBonusPoints(event) => event.write(stream, definition),
23276 GameEvent::PlayerUpgraded(event) => event.write(stream, definition),
23277 GameEvent::PlayerBuyback(event) => event.write(stream, definition),
23278 GameEvent::PlayerUsedPowerUpBottle(event) => event.write(stream, definition),
23279 GameEvent::ChristmasGiftGrab(event) => event.write(stream, definition),
23280 GameEvent::PlayerKilledAchievementZone(event) => event.write(stream, definition),
23281 GameEvent::PartyUpdated(event) => event.write(stream, definition),
23282 GameEvent::PartyPrefChanged(event) => event.write(stream, definition),
23283 GameEvent::PartyCriteriaChanged(event) => event.write(stream, definition),
23284 GameEvent::PartyInvitesChanged(event) => event.write(stream, definition),
23285 GameEvent::PartyQueueStateChanged(event) => event.write(stream, definition),
23286 GameEvent::PartyChat(event) => event.write(stream, definition),
23287 GameEvent::PartyMemberJoin(event) => event.write(stream, definition),
23288 GameEvent::PartyMemberLeave(event) => event.write(stream, definition),
23289 GameEvent::MatchInvitesUpdated(event) => event.write(stream, definition),
23290 GameEvent::LobbyUpdated(event) => event.write(stream, definition),
23291 GameEvent::MvmMissionUpdate(event) => event.write(stream, definition),
23292 GameEvent::RecalculateHolidays(event) => event.write(stream, definition),
23293 GameEvent::PlayerCurrencyChanged(event) => event.write(stream, definition),
23294 GameEvent::DoomsdayRocketOpen(event) => event.write(stream, definition),
23295 GameEvent::RemoveNemesisRelationships(event) => event.write(stream, definition),
23296 GameEvent::MvmCreditBonusWave(event) => event.write(stream, definition),
23297 GameEvent::MvmCreditBonusAll(event) => event.write(stream, definition),
23298 GameEvent::MvmCreditBonusAllAdvanced(event) => event.write(stream, definition),
23299 GameEvent::MvmQuickSentryUpgrade(event) => event.write(stream, definition),
23300 GameEvent::MvmTankDestroyedByPlayers(event) => event.write(stream, definition),
23301 GameEvent::MvmKillRobotDeliveringBomb(event) => event.write(stream, definition),
23302 GameEvent::MvmPickupCurrency(event) => event.write(stream, definition),
23303 GameEvent::MvmBombCarrierKilled(event) => event.write(stream, definition),
23304 GameEvent::MvmSentryBusterDetonate(event) => event.write(stream, definition),
23305 GameEvent::MvmScoutMarkedForDeath(event) => event.write(stream, definition),
23306 GameEvent::MvmMedicPowerUpShared(event) => event.write(stream, definition),
23307 GameEvent::MvmBeginWave(event) => event.write(stream, definition),
23308 GameEvent::MvmWaveComplete(event) => event.write(stream, definition),
23309 GameEvent::MvmMissionComplete(event) => event.write(stream, definition),
23310 GameEvent::MvmBombResetByPlayer(event) => event.write(stream, definition),
23311 GameEvent::MvmBombAlarmTriggered(event) => event.write(stream, definition),
23312 GameEvent::MvmBombDeployResetByPlayer(event) => event.write(stream, definition),
23313 GameEvent::MvmWaveFailed(event) => event.write(stream, definition),
23314 GameEvent::MvmResetStats(event) => event.write(stream, definition),
23315 GameEvent::DamageResisted(event) => event.write(stream, definition),
23316 GameEvent::RevivePlayerNotify(event) => event.write(stream, definition),
23317 GameEvent::RevivePlayerStopped(event) => event.write(stream, definition),
23318 GameEvent::RevivePlayerComplete(event) => event.write(stream, definition),
23319 GameEvent::PlayerTurnedToGhost(event) => event.write(stream, definition),
23320 GameEvent::MedigunShieldBlockedDamage(event) => event.write(stream, definition),
23321 GameEvent::MvmAdvWaveCompleteNoGates(event) => event.write(stream, definition),
23322 GameEvent::MvmSniperHeadshotCurrency(event) => event.write(stream, definition),
23323 GameEvent::MvmMannhattanPit(event) => event.write(stream, definition),
23324 GameEvent::FlagCarriedInDetectionZone(event) => event.write(stream, definition),
23325 GameEvent::MvmAdvWaveKilledStunRadio(event) => event.write(stream, definition),
23326 GameEvent::PlayerDirectHitStun(event) => event.write(stream, definition),
23327 GameEvent::MvmSentryBusterKilled(event) => event.write(stream, definition),
23328 GameEvent::UpgradesFileChanged(event) => event.write(stream, definition),
23329 GameEvent::RdTeamPointsChanged(event) => event.write(stream, definition),
23330 GameEvent::RdRulesStateChanged(event) => event.write(stream, definition),
23331 GameEvent::RdRobotKilled(event) => event.write(stream, definition),
23332 GameEvent::RdRobotImpact(event) => event.write(stream, definition),
23333 GameEvent::TeamPlayPreRoundTimeLeft(event) => event.write(stream, definition),
23334 GameEvent::ParachuteDeploy(event) => event.write(stream, definition),
23335 GameEvent::ParachuteHolster(event) => event.write(stream, definition),
23336 GameEvent::KillRefillsMeter(event) => event.write(stream, definition),
23337 GameEvent::RpsTauntEvent(event) => event.write(stream, definition),
23338 GameEvent::CongaKill(event) => event.write(stream, definition),
23339 GameEvent::PlayerInitialSpawn(event) => event.write(stream, definition),
23340 GameEvent::CompetitiveVictory(event) => event.write(stream, definition),
23341 GameEvent::CompetitiveStatsUpdate(event) => event.write(stream, definition),
23342 GameEvent::MiniGameWin(event) => event.write(stream, definition),
23343 GameEvent::SentryOnGoActive(event) => event.write(stream, definition),
23344 GameEvent::DuckXpLevelUp(event) => event.write(stream, definition),
23345 GameEvent::QuestLogOpened(event) => event.write(stream, definition),
23346 GameEvent::SchemaUpdated(event) => event.write(stream, definition),
23347 GameEvent::LocalPlayerPickupWeapon(event) => event.write(stream, definition),
23348 GameEvent::RdPlayerScorePoints(event) => event.write(stream, definition),
23349 GameEvent::DemomanDetStickies(event) => event.write(stream, definition),
23350 GameEvent::QuestObjectiveCompleted(event) => event.write(stream, definition),
23351 GameEvent::PlayerScoreChanged(event) => event.write(stream, definition),
23352 GameEvent::KilledCappingPlayer(event) => event.write(stream, definition),
23353 GameEvent::EnvironmentalDeath(event) => event.write(stream, definition),
23354 GameEvent::ProjectileDirectHit(event) => event.write(stream, definition),
23355 GameEvent::PassGet(event) => event.write(stream, definition),
23356 GameEvent::PassScore(event) => event.write(stream, definition),
23357 GameEvent::PassFree(event) => event.write(stream, definition),
23358 GameEvent::PassPassCaught(event) => event.write(stream, definition),
23359 GameEvent::PassBallStolen(event) => event.write(stream, definition),
23360 GameEvent::PassBallBlocked(event) => event.write(stream, definition),
23361 GameEvent::DamagePrevented(event) => event.write(stream, definition),
23362 GameEvent::HalloweenBossKilled(event) => event.write(stream, definition),
23363 GameEvent::EscapedLootIsland(event) => event.write(stream, definition),
23364 GameEvent::TaggedPlayerAsIt(event) => event.write(stream, definition),
23365 GameEvent::MerasmusStunned(event) => event.write(stream, definition),
23366 GameEvent::MerasmusPropFound(event) => event.write(stream, definition),
23367 GameEvent::HalloweenSkeletonKilled(event) => event.write(stream, definition),
23368 GameEvent::SkeletonKilledQuest(event) => event.write(stream, definition),
23369 GameEvent::SkeletonKingKilledQuest(event) => event.write(stream, definition),
23370 GameEvent::EscapeHell(event) => event.write(stream, definition),
23371 GameEvent::CrossSpectralBridge(event) => event.write(stream, definition),
23372 GameEvent::MiniGameWon(event) => event.write(stream, definition),
23373 GameEvent::RespawnGhost(event) => event.write(stream, definition),
23374 GameEvent::KillInHell(event) => event.write(stream, definition),
23375 GameEvent::HalloweenDuckCollected(event) => event.write(stream, definition),
23376 GameEvent::SpecialScore(event) => event.write(stream, definition),
23377 GameEvent::TeamLeaderKilled(event) => event.write(stream, definition),
23378 GameEvent::HalloweenSoulCollected(event) => event.write(stream, definition),
23379 GameEvent::RecalculateTruce(event) => event.write(stream, definition),
23380 GameEvent::DeadRingerCheatDeath(event) => event.write(stream, definition),
23381 GameEvent::CrossbowHeal(event) => event.write(stream, definition),
23382 GameEvent::DamageMitigated(event) => event.write(stream, definition),
23383 GameEvent::PayloadPushed(event) => event.write(stream, definition),
23384 GameEvent::PlayerAbandonedMatch(event) => event.write(stream, definition),
23385 GameEvent::ClDrawline(event) => event.write(stream, definition),
23386 GameEvent::RestartTimerTime(event) => event.write(stream, definition),
23387 GameEvent::WinLimitChanged(event) => event.write(stream, definition),
23388 GameEvent::WinPanelShowScores(event) => event.write(stream, definition),
23389 GameEvent::TopStreamsRequestFinished(event) => event.write(stream, definition),
23390 GameEvent::CompetitiveStateChanged(event) => event.write(stream, definition),
23391 GameEvent::GlobalWarDataUpdated(event) => event.write(stream, definition),
23392 GameEvent::StopWatchChanged(event) => event.write(stream, definition),
23393 GameEvent::DsStop(event) => event.write(stream, definition),
23394 GameEvent::DsScreenshot(event) => event.write(stream, definition),
23395 GameEvent::ShowMatchSummary(event) => event.write(stream, definition),
23396 GameEvent::ExperienceChanged(event) => event.write(stream, definition),
23397 GameEvent::BeginXpLerp(event) => event.write(stream, definition),
23398 GameEvent::MatchmakerStatsUpdated(event) => event.write(stream, definition),
23399 GameEvent::RematchVotePeriodOver(event) => event.write(stream, definition),
23400 GameEvent::RematchFailedToCreate(event) => event.write(stream, definition),
23401 GameEvent::PlayerRematchChange(event) => event.write(stream, definition),
23402 GameEvent::PingUpdated(event) => event.write(stream, definition),
23403 GameEvent::MMStatsUpdated(event) => event.write(stream, definition),
23404 GameEvent::PlayerNextMapVoteChange(event) => event.write(stream, definition),
23405 GameEvent::VoteMapsChanged(event) => event.write(stream, definition),
23406 GameEvent::ProtoDefChanged(event) => event.write(stream, definition),
23407 GameEvent::PlayerDomination(event) => event.write(stream, definition),
23408 GameEvent::PlayerRocketPackPushed(event) => event.write(stream, definition),
23409 GameEvent::QuestRequest(event) => event.write(stream, definition),
23410 GameEvent::QuestResponse(event) => event.write(stream, definition),
23411 GameEvent::QuestProgress(event) => event.write(stream, definition),
23412 GameEvent::ProjectileRemoved(event) => event.write(stream, definition),
23413 GameEvent::QuestMapDataChanged(event) => event.write(stream, definition),
23414 GameEvent::GasDousedPlayerIgnited(event) => event.write(stream, definition),
23415 GameEvent::QuestTurnInState(event) => event.write(stream, definition),
23416 GameEvent::ItemsAcknowledged(event) => event.write(stream, definition),
23417 GameEvent::CapperKilled(event) => event.write(stream, definition),
23418 GameEvent::MainMenuStabilized(event) => event.write(stream, definition),
23419 GameEvent::WorldStatusChanged(event) => event.write(stream, definition),
23420 GameEvent::HLTVStatus(event) => event.write(stream, definition),
23421 GameEvent::HLTVCameraman(event) => event.write(stream, definition),
23422 GameEvent::HLTVRankCamera(event) => event.write(stream, definition),
23423 GameEvent::HLTVRankEntity(event) => event.write(stream, definition),
23424 GameEvent::HLTVFixed(event) => event.write(stream, definition),
23425 GameEvent::HLTVChase(event) => event.write(stream, definition),
23426 GameEvent::HLTVMessage(event) => event.write(stream, definition),
23427 GameEvent::HLTVTitle(event) => event.write(stream, definition),
23428 GameEvent::HLTVChat(event) => event.write(stream, definition),
23429 GameEvent::ReplayStartRecord(event) => event.write(stream, definition),
23430 GameEvent::ReplaySessionInfo(event) => event.write(stream, definition),
23431 GameEvent::ReplayEndRecord(event) => event.write(stream, definition),
23432 GameEvent::ReplayReplaysAvailable(event) => event.write(stream, definition),
23433 GameEvent::ReplayServerError(event) => event.write(stream, definition),
23434 GameEvent::Unknown(raw) => Ok(raw.write(stream)?),
23435 }
23436 }
23437 pub fn event_type(&self) -> GameEventType {
23438 match &self {
23439 GameEvent::ServerSpawn(_) => GameEventType::ServerSpawn,
23440 GameEvent::ServerChangeLevelFailed(_) => GameEventType::ServerChangeLevelFailed,
23441 GameEvent::ServerShutdown(_) => GameEventType::ServerShutdown,
23442 GameEvent::ServerCvar(_) => GameEventType::ServerCvar,
23443 GameEvent::ServerMessage(_) => GameEventType::ServerMessage,
23444 GameEvent::ServerAddBan(_) => GameEventType::ServerAddBan,
23445 GameEvent::ServerRemoveBan(_) => GameEventType::ServerRemoveBan,
23446 GameEvent::PlayerConnect(_) => GameEventType::PlayerConnect,
23447 GameEvent::PlayerConnectClient(_) => GameEventType::PlayerConnectClient,
23448 GameEvent::PlayerInfo(_) => GameEventType::PlayerInfo,
23449 GameEvent::PlayerDisconnect(_) => GameEventType::PlayerDisconnect,
23450 GameEvent::PlayerActivate(_) => GameEventType::PlayerActivate,
23451 GameEvent::PlayerSay(_) => GameEventType::PlayerSay,
23452 GameEvent::ClientDisconnect(_) => GameEventType::ClientDisconnect,
23453 GameEvent::ClientBeginConnect(_) => GameEventType::ClientBeginConnect,
23454 GameEvent::ClientConnected(_) => GameEventType::ClientConnected,
23455 GameEvent::ClientFullConnect(_) => GameEventType::ClientFullConnect,
23456 GameEvent::HostQuit(_) => GameEventType::HostQuit,
23457 GameEvent::TeamInfo(_) => GameEventType::TeamInfo,
23458 GameEvent::TeamScore(_) => GameEventType::TeamScore,
23459 GameEvent::TeamPlayBroadcastAudio(_) => GameEventType::TeamPlayBroadcastAudio,
23460 GameEvent::PlayerTeam(_) => GameEventType::PlayerTeam,
23461 GameEvent::PlayerClass(_) => GameEventType::PlayerClass,
23462 GameEvent::PlayerDeath(_) => GameEventType::PlayerDeath,
23463 GameEvent::PlayerHurt(_) => GameEventType::PlayerHurt,
23464 GameEvent::PlayerChat(_) => GameEventType::PlayerChat,
23465 GameEvent::PlayerScore(_) => GameEventType::PlayerScore,
23466 GameEvent::PlayerSpawn(_) => GameEventType::PlayerSpawn,
23467 GameEvent::PlayerShoot(_) => GameEventType::PlayerShoot,
23468 GameEvent::PlayerUse(_) => GameEventType::PlayerUse,
23469 GameEvent::PlayerChangeName(_) => GameEventType::PlayerChangeName,
23470 GameEvent::PlayerHintMessage(_) => GameEventType::PlayerHintMessage,
23471 GameEvent::BasePlayerTeleported(_) => GameEventType::BasePlayerTeleported,
23472 GameEvent::GameInit(_) => GameEventType::GameInit,
23473 GameEvent::GameNewMap(_) => GameEventType::GameNewMap,
23474 GameEvent::GameStart(_) => GameEventType::GameStart,
23475 GameEvent::GameEnd(_) => GameEventType::GameEnd,
23476 GameEvent::RoundStart(_) => GameEventType::RoundStart,
23477 GameEvent::RoundEnd(_) => GameEventType::RoundEnd,
23478 GameEvent::GameMessage(_) => GameEventType::GameMessage,
23479 GameEvent::BreakBreakable(_) => GameEventType::BreakBreakable,
23480 GameEvent::BreakProp(_) => GameEventType::BreakProp,
23481 GameEvent::EntityKilled(_) => GameEventType::EntityKilled,
23482 GameEvent::BonusUpdated(_) => GameEventType::BonusUpdated,
23483 GameEvent::AchievementEvent(_) => GameEventType::AchievementEvent,
23484 GameEvent::AchievementIncrement(_) => GameEventType::AchievementIncrement,
23485 GameEvent::PhysgunPickup(_) => GameEventType::PhysgunPickup,
23486 GameEvent::FlareIgniteNpc(_) => GameEventType::FlareIgniteNpc,
23487 GameEvent::HelicopterGrenadePuntMiss(_) => GameEventType::HelicopterGrenadePuntMiss,
23488 GameEvent::UserDataDownloaded(_) => GameEventType::UserDataDownloaded,
23489 GameEvent::RagdollDissolved(_) => GameEventType::RagdollDissolved,
23490 GameEvent::HLTVChangedMode(_) => GameEventType::HLTVChangedMode,
23491 GameEvent::HLTVChangedTarget(_) => GameEventType::HLTVChangedTarget,
23492 GameEvent::VoteEnded(_) => GameEventType::VoteEnded,
23493 GameEvent::VoteStarted(_) => GameEventType::VoteStarted,
23494 GameEvent::VoteChanged(_) => GameEventType::VoteChanged,
23495 GameEvent::VotePassed(_) => GameEventType::VotePassed,
23496 GameEvent::VoteFailed(_) => GameEventType::VoteFailed,
23497 GameEvent::VoteCast(_) => GameEventType::VoteCast,
23498 GameEvent::VoteOptions(_) => GameEventType::VoteOptions,
23499 GameEvent::ReplaySaved(_) => GameEventType::ReplaySaved,
23500 GameEvent::EnteredPerformanceMode(_) => GameEventType::EnteredPerformanceMode,
23501 GameEvent::BrowseReplays(_) => GameEventType::BrowseReplays,
23502 GameEvent::ReplayYoutubeStats(_) => GameEventType::ReplayYoutubeStats,
23503 GameEvent::InventoryUpdated(_) => GameEventType::InventoryUpdated,
23504 GameEvent::CartUpdated(_) => GameEventType::CartUpdated,
23505 GameEvent::StorePriceSheetUpdated(_) => GameEventType::StorePriceSheetUpdated,
23506 GameEvent::EconInventoryConnected(_) => GameEventType::EconInventoryConnected,
23507 GameEvent::ItemSchemaInitialized(_) => GameEventType::ItemSchemaInitialized,
23508 GameEvent::GcNewSession(_) => GameEventType::GcNewSession,
23509 GameEvent::GcLostSession(_) => GameEventType::GcLostSession,
23510 GameEvent::IntroFinish(_) => GameEventType::IntroFinish,
23511 GameEvent::IntroNextCamera(_) => GameEventType::IntroNextCamera,
23512 GameEvent::PlayerChangeClass(_) => GameEventType::PlayerChangeClass,
23513 GameEvent::TfMapTimeRemaining(_) => GameEventType::TfMapTimeRemaining,
23514 GameEvent::TfGameOver(_) => GameEventType::TfGameOver,
23515 GameEvent::CtfFlagCaptured(_) => GameEventType::CtfFlagCaptured,
23516 GameEvent::ControlPointInitialized(_) => GameEventType::ControlPointInitialized,
23517 GameEvent::ControlPointUpdateImages(_) => GameEventType::ControlPointUpdateImages,
23518 GameEvent::ControlPointUpdateLayout(_) => GameEventType::ControlPointUpdateLayout,
23519 GameEvent::ControlPointUpdateCapping(_) => GameEventType::ControlPointUpdateCapping,
23520 GameEvent::ControlPointUpdateOwner(_) => GameEventType::ControlPointUpdateOwner,
23521 GameEvent::ControlPointStartTouch(_) => GameEventType::ControlPointStartTouch,
23522 GameEvent::ControlPointEndTouch(_) => GameEventType::ControlPointEndTouch,
23523 GameEvent::ControlPointPulseElement(_) => GameEventType::ControlPointPulseElement,
23524 GameEvent::ControlPointFakeCapture(_) => GameEventType::ControlPointFakeCapture,
23525 GameEvent::ControlPointFakeCaptureMultiplier(_) => {
23526 GameEventType::ControlPointFakeCaptureMultiplier
23527 }
23528 GameEvent::TeamPlayRoundSelected(_) => GameEventType::TeamPlayRoundSelected,
23529 GameEvent::TeamPlayRoundStart(_) => GameEventType::TeamPlayRoundStart,
23530 GameEvent::TeamPlayRoundActive(_) => GameEventType::TeamPlayRoundActive,
23531 GameEvent::TeamPlayWaitingBegins(_) => GameEventType::TeamPlayWaitingBegins,
23532 GameEvent::TeamPlayWaitingEnds(_) => GameEventType::TeamPlayWaitingEnds,
23533 GameEvent::TeamPlayWaitingAboutToEnd(_) => GameEventType::TeamPlayWaitingAboutToEnd,
23534 GameEvent::TeamPlayRestartRound(_) => GameEventType::TeamPlayRestartRound,
23535 GameEvent::TeamPlayReadyRestart(_) => GameEventType::TeamPlayReadyRestart,
23536 GameEvent::TeamPlayRoundRestartSeconds(_) => GameEventType::TeamPlayRoundRestartSeconds,
23537 GameEvent::TeamPlayTeamReady(_) => GameEventType::TeamPlayTeamReady,
23538 GameEvent::TeamPlayRoundWin(_) => GameEventType::TeamPlayRoundWin,
23539 GameEvent::TeamPlayUpdateTimer(_) => GameEventType::TeamPlayUpdateTimer,
23540 GameEvent::TeamPlayRoundStalemate(_) => GameEventType::TeamPlayRoundStalemate,
23541 GameEvent::TeamPlayOvertimeBegin(_) => GameEventType::TeamPlayOvertimeBegin,
23542 GameEvent::TeamPlayOvertimeEnd(_) => GameEventType::TeamPlayOvertimeEnd,
23543 GameEvent::TeamPlaySuddenDeathBegin(_) => GameEventType::TeamPlaySuddenDeathBegin,
23544 GameEvent::TeamPlaySuddenDeathEnd(_) => GameEventType::TeamPlaySuddenDeathEnd,
23545 GameEvent::TeamPlayGameOver(_) => GameEventType::TeamPlayGameOver,
23546 GameEvent::TeamPlayMapTimeRemaining(_) => GameEventType::TeamPlayMapTimeRemaining,
23547 GameEvent::TeamPlayTimerFlash(_) => GameEventType::TeamPlayTimerFlash,
23548 GameEvent::TeamPlayTimerTimeAdded(_) => GameEventType::TeamPlayTimerTimeAdded,
23549 GameEvent::TeamPlayPointStartCapture(_) => GameEventType::TeamPlayPointStartCapture,
23550 GameEvent::TeamPlayPointCaptured(_) => GameEventType::TeamPlayPointCaptured,
23551 GameEvent::TeamPlayPointLocked(_) => GameEventType::TeamPlayPointLocked,
23552 GameEvent::TeamPlayPointUnlocked(_) => GameEventType::TeamPlayPointUnlocked,
23553 GameEvent::TeamPlayCaptureBroken(_) => GameEventType::TeamPlayCaptureBroken,
23554 GameEvent::TeamPlayCaptureBlocked(_) => GameEventType::TeamPlayCaptureBlocked,
23555 GameEvent::TeamPlayFlagEvent(_) => GameEventType::TeamPlayFlagEvent,
23556 GameEvent::TeamPlayWinPanel(_) => GameEventType::TeamPlayWinPanel,
23557 GameEvent::TeamPlayTeamBalancedPlayer(_) => GameEventType::TeamPlayTeamBalancedPlayer,
23558 GameEvent::TeamPlaySetupFinished(_) => GameEventType::TeamPlaySetupFinished,
23559 GameEvent::TeamPlayAlert(_) => GameEventType::TeamPlayAlert,
23560 GameEvent::TrainingComplete(_) => GameEventType::TrainingComplete,
23561 GameEvent::ShowFreezePanel(_) => GameEventType::ShowFreezePanel,
23562 GameEvent::HideFreezePanel(_) => GameEventType::HideFreezePanel,
23563 GameEvent::FreezeCamStarted(_) => GameEventType::FreezeCamStarted,
23564 GameEvent::LocalPlayerChangeTeam(_) => GameEventType::LocalPlayerChangeTeam,
23565 GameEvent::LocalPlayerScoreChanged(_) => GameEventType::LocalPlayerScoreChanged,
23566 GameEvent::LocalPlayerChangeClass(_) => GameEventType::LocalPlayerChangeClass,
23567 GameEvent::LocalPlayerRespawn(_) => GameEventType::LocalPlayerRespawn,
23568 GameEvent::BuildingInfoChanged(_) => GameEventType::BuildingInfoChanged,
23569 GameEvent::LocalPlayerChangeDisguise(_) => GameEventType::LocalPlayerChangeDisguise,
23570 GameEvent::PlayerAccountChanged(_) => GameEventType::PlayerAccountChanged,
23571 GameEvent::SpyPdaReset(_) => GameEventType::SpyPdaReset,
23572 GameEvent::FlagStatusUpdate(_) => GameEventType::FlagStatusUpdate,
23573 GameEvent::PlayerStatsUpdated(_) => GameEventType::PlayerStatsUpdated,
23574 GameEvent::PlayingCommentary(_) => GameEventType::PlayingCommentary,
23575 GameEvent::PlayerChargeDeployed(_) => GameEventType::PlayerChargeDeployed,
23576 GameEvent::PlayerBuiltObject(_) => GameEventType::PlayerBuiltObject,
23577 GameEvent::PlayerUpgradedObject(_) => GameEventType::PlayerUpgradedObject,
23578 GameEvent::PlayerCarryObject(_) => GameEventType::PlayerCarryObject,
23579 GameEvent::PlayerDropObject(_) => GameEventType::PlayerDropObject,
23580 GameEvent::ObjectRemoved(_) => GameEventType::ObjectRemoved,
23581 GameEvent::ObjectDestroyed(_) => GameEventType::ObjectDestroyed,
23582 GameEvent::ObjectDetonated(_) => GameEventType::ObjectDetonated,
23583 GameEvent::AchievementEarned(_) => GameEventType::AchievementEarned,
23584 GameEvent::SpecTargetUpdated(_) => GameEventType::SpecTargetUpdated,
23585 GameEvent::TournamentStateUpdate(_) => GameEventType::TournamentStateUpdate,
23586 GameEvent::TournamentEnableCountdown(_) => GameEventType::TournamentEnableCountdown,
23587 GameEvent::PlayerCalledForMedic(_) => GameEventType::PlayerCalledForMedic,
23588 GameEvent::PlayerAskedForBall(_) => GameEventType::PlayerAskedForBall,
23589 GameEvent::LocalPlayerBecameObserver(_) => GameEventType::LocalPlayerBecameObserver,
23590 GameEvent::PlayerIgnitedInv(_) => GameEventType::PlayerIgnitedInv,
23591 GameEvent::PlayerIgnited(_) => GameEventType::PlayerIgnited,
23592 GameEvent::PlayerExtinguished(_) => GameEventType::PlayerExtinguished,
23593 GameEvent::PlayerTeleported(_) => GameEventType::PlayerTeleported,
23594 GameEvent::PlayerHealedMedicCall(_) => GameEventType::PlayerHealedMedicCall,
23595 GameEvent::LocalPlayerChargeReady(_) => GameEventType::LocalPlayerChargeReady,
23596 GameEvent::LocalPlayerWindDown(_) => GameEventType::LocalPlayerWindDown,
23597 GameEvent::PlayerInvulned(_) => GameEventType::PlayerInvulned,
23598 GameEvent::EscortSpeed(_) => GameEventType::EscortSpeed,
23599 GameEvent::EscortProgress(_) => GameEventType::EscortProgress,
23600 GameEvent::EscortRecede(_) => GameEventType::EscortRecede,
23601 GameEvent::GameUIActivated(_) => GameEventType::GameUIActivated,
23602 GameEvent::GameUIHidden(_) => GameEventType::GameUIHidden,
23603 GameEvent::PlayerEscortScore(_) => GameEventType::PlayerEscortScore,
23604 GameEvent::PlayerHealOnHit(_) => GameEventType::PlayerHealOnHit,
23605 GameEvent::PlayerStealSandvich(_) => GameEventType::PlayerStealSandvich,
23606 GameEvent::ShowClassLayout(_) => GameEventType::ShowClassLayout,
23607 GameEvent::ShowVsPanel(_) => GameEventType::ShowVsPanel,
23608 GameEvent::PlayerDamaged(_) => GameEventType::PlayerDamaged,
23609 GameEvent::ArenaPlayerNotification(_) => GameEventType::ArenaPlayerNotification,
23610 GameEvent::ArenaMatchMaxStreak(_) => GameEventType::ArenaMatchMaxStreak,
23611 GameEvent::ArenaRoundStart(_) => GameEventType::ArenaRoundStart,
23612 GameEvent::ArenaWinPanel(_) => GameEventType::ArenaWinPanel,
23613 GameEvent::PveWinPanel(_) => GameEventType::PveWinPanel,
23614 GameEvent::AirDash(_) => GameEventType::AirDash,
23615 GameEvent::Landed(_) => GameEventType::Landed,
23616 GameEvent::PlayerDamageDodged(_) => GameEventType::PlayerDamageDodged,
23617 GameEvent::PlayerStunned(_) => GameEventType::PlayerStunned,
23618 GameEvent::ScoutGrandSlam(_) => GameEventType::ScoutGrandSlam,
23619 GameEvent::ScoutSlamdollLanded(_) => GameEventType::ScoutSlamdollLanded,
23620 GameEvent::ArrowImpact(_) => GameEventType::ArrowImpact,
23621 GameEvent::PlayerJarated(_) => GameEventType::PlayerJarated,
23622 GameEvent::PlayerJaratedFade(_) => GameEventType::PlayerJaratedFade,
23623 GameEvent::PlayerShieldBlocked(_) => GameEventType::PlayerShieldBlocked,
23624 GameEvent::PlayerPinned(_) => GameEventType::PlayerPinned,
23625 GameEvent::PlayerHealedByMedic(_) => GameEventType::PlayerHealedByMedic,
23626 GameEvent::PlayerSappedObject(_) => GameEventType::PlayerSappedObject,
23627 GameEvent::ItemFound(_) => GameEventType::ItemFound,
23628 GameEvent::ShowAnnotation(_) => GameEventType::ShowAnnotation,
23629 GameEvent::HideAnnotation(_) => GameEventType::HideAnnotation,
23630 GameEvent::PostInventoryApplication(_) => GameEventType::PostInventoryApplication,
23631 GameEvent::ControlPointUnlockUpdated(_) => GameEventType::ControlPointUnlockUpdated,
23632 GameEvent::DeployBuffBanner(_) => GameEventType::DeployBuffBanner,
23633 GameEvent::PlayerBuff(_) => GameEventType::PlayerBuff,
23634 GameEvent::MedicDeath(_) => GameEventType::MedicDeath,
23635 GameEvent::OvertimeNag(_) => GameEventType::OvertimeNag,
23636 GameEvent::TeamsChanged(_) => GameEventType::TeamsChanged,
23637 GameEvent::HalloweenPumpkinGrab(_) => GameEventType::HalloweenPumpkinGrab,
23638 GameEvent::RocketJump(_) => GameEventType::RocketJump,
23639 GameEvent::RocketJumpLanded(_) => GameEventType::RocketJumpLanded,
23640 GameEvent::StickyJump(_) => GameEventType::StickyJump,
23641 GameEvent::StickyJumpLanded(_) => GameEventType::StickyJumpLanded,
23642 GameEvent::RocketPackLaunch(_) => GameEventType::RocketPackLaunch,
23643 GameEvent::RocketPackLanded(_) => GameEventType::RocketPackLanded,
23644 GameEvent::MedicDefended(_) => GameEventType::MedicDefended,
23645 GameEvent::LocalPlayerHealed(_) => GameEventType::LocalPlayerHealed,
23646 GameEvent::PlayerDestroyedPipeBomb(_) => GameEventType::PlayerDestroyedPipeBomb,
23647 GameEvent::ObjectDeflected(_) => GameEventType::ObjectDeflected,
23648 GameEvent::PlayerMvp(_) => GameEventType::PlayerMvp,
23649 GameEvent::RaidSpawnMob(_) => GameEventType::RaidSpawnMob,
23650 GameEvent::RaidSpawnSquad(_) => GameEventType::RaidSpawnSquad,
23651 GameEvent::NavBlocked(_) => GameEventType::NavBlocked,
23652 GameEvent::PathTrackPassed(_) => GameEventType::PathTrackPassed,
23653 GameEvent::NumCappersChanged(_) => GameEventType::NumCappersChanged,
23654 GameEvent::PlayerRegenerate(_) => GameEventType::PlayerRegenerate,
23655 GameEvent::UpdateStatusItem(_) => GameEventType::UpdateStatusItem,
23656 GameEvent::StatsResetRound(_) => GameEventType::StatsResetRound,
23657 GameEvent::ScoreStatsAccumulatedUpdate(_) => GameEventType::ScoreStatsAccumulatedUpdate,
23658 GameEvent::ScoreStatsAccumulatedReset(_) => GameEventType::ScoreStatsAccumulatedReset,
23659 GameEvent::AchievementEarnedLocal(_) => GameEventType::AchievementEarnedLocal,
23660 GameEvent::PlayerHealed(_) => GameEventType::PlayerHealed,
23661 GameEvent::BuildingHealed(_) => GameEventType::BuildingHealed,
23662 GameEvent::ItemPickup(_) => GameEventType::ItemPickup,
23663 GameEvent::DuelStatus(_) => GameEventType::DuelStatus,
23664 GameEvent::FishNotice(_) => GameEventType::FishNotice,
23665 GameEvent::FishNoticeArm(_) => GameEventType::FishNoticeArm,
23666 GameEvent::SlapNotice(_) => GameEventType::SlapNotice,
23667 GameEvent::ThrowableHit(_) => GameEventType::ThrowableHit,
23668 GameEvent::PumpkinLordSummoned(_) => GameEventType::PumpkinLordSummoned,
23669 GameEvent::PumpkinLordKilled(_) => GameEventType::PumpkinLordKilled,
23670 GameEvent::MerasmusSummoned(_) => GameEventType::MerasmusSummoned,
23671 GameEvent::MerasmusKilled(_) => GameEventType::MerasmusKilled,
23672 GameEvent::MerasmusEscapeWarning(_) => GameEventType::MerasmusEscapeWarning,
23673 GameEvent::MerasmusEscaped(_) => GameEventType::MerasmusEscaped,
23674 GameEvent::EyeballBossSummoned(_) => GameEventType::EyeballBossSummoned,
23675 GameEvent::EyeballBossStunned(_) => GameEventType::EyeballBossStunned,
23676 GameEvent::EyeballBossKilled(_) => GameEventType::EyeballBossKilled,
23677 GameEvent::EyeballBossKiller(_) => GameEventType::EyeballBossKiller,
23678 GameEvent::EyeballBossEscapeImminent(_) => GameEventType::EyeballBossEscapeImminent,
23679 GameEvent::EyeballBossEscaped(_) => GameEventType::EyeballBossEscaped,
23680 GameEvent::NpcHurt(_) => GameEventType::NpcHurt,
23681 GameEvent::ControlPointTimerUpdated(_) => GameEventType::ControlPointTimerUpdated,
23682 GameEvent::PlayerHighFiveStart(_) => GameEventType::PlayerHighFiveStart,
23683 GameEvent::PlayerHighFiveCancel(_) => GameEventType::PlayerHighFiveCancel,
23684 GameEvent::PlayerHighFiveSuccess(_) => GameEventType::PlayerHighFiveSuccess,
23685 GameEvent::PlayerBonusPoints(_) => GameEventType::PlayerBonusPoints,
23686 GameEvent::PlayerUpgraded(_) => GameEventType::PlayerUpgraded,
23687 GameEvent::PlayerBuyback(_) => GameEventType::PlayerBuyback,
23688 GameEvent::PlayerUsedPowerUpBottle(_) => GameEventType::PlayerUsedPowerUpBottle,
23689 GameEvent::ChristmasGiftGrab(_) => GameEventType::ChristmasGiftGrab,
23690 GameEvent::PlayerKilledAchievementZone(_) => GameEventType::PlayerKilledAchievementZone,
23691 GameEvent::PartyUpdated(_) => GameEventType::PartyUpdated,
23692 GameEvent::PartyPrefChanged(_) => GameEventType::PartyPrefChanged,
23693 GameEvent::PartyCriteriaChanged(_) => GameEventType::PartyCriteriaChanged,
23694 GameEvent::PartyInvitesChanged(_) => GameEventType::PartyInvitesChanged,
23695 GameEvent::PartyQueueStateChanged(_) => GameEventType::PartyQueueStateChanged,
23696 GameEvent::PartyChat(_) => GameEventType::PartyChat,
23697 GameEvent::PartyMemberJoin(_) => GameEventType::PartyMemberJoin,
23698 GameEvent::PartyMemberLeave(_) => GameEventType::PartyMemberLeave,
23699 GameEvent::MatchInvitesUpdated(_) => GameEventType::MatchInvitesUpdated,
23700 GameEvent::LobbyUpdated(_) => GameEventType::LobbyUpdated,
23701 GameEvent::MvmMissionUpdate(_) => GameEventType::MvmMissionUpdate,
23702 GameEvent::RecalculateHolidays(_) => GameEventType::RecalculateHolidays,
23703 GameEvent::PlayerCurrencyChanged(_) => GameEventType::PlayerCurrencyChanged,
23704 GameEvent::DoomsdayRocketOpen(_) => GameEventType::DoomsdayRocketOpen,
23705 GameEvent::RemoveNemesisRelationships(_) => GameEventType::RemoveNemesisRelationships,
23706 GameEvent::MvmCreditBonusWave(_) => GameEventType::MvmCreditBonusWave,
23707 GameEvent::MvmCreditBonusAll(_) => GameEventType::MvmCreditBonusAll,
23708 GameEvent::MvmCreditBonusAllAdvanced(_) => GameEventType::MvmCreditBonusAllAdvanced,
23709 GameEvent::MvmQuickSentryUpgrade(_) => GameEventType::MvmQuickSentryUpgrade,
23710 GameEvent::MvmTankDestroyedByPlayers(_) => GameEventType::MvmTankDestroyedByPlayers,
23711 GameEvent::MvmKillRobotDeliveringBomb(_) => GameEventType::MvmKillRobotDeliveringBomb,
23712 GameEvent::MvmPickupCurrency(_) => GameEventType::MvmPickupCurrency,
23713 GameEvent::MvmBombCarrierKilled(_) => GameEventType::MvmBombCarrierKilled,
23714 GameEvent::MvmSentryBusterDetonate(_) => GameEventType::MvmSentryBusterDetonate,
23715 GameEvent::MvmScoutMarkedForDeath(_) => GameEventType::MvmScoutMarkedForDeath,
23716 GameEvent::MvmMedicPowerUpShared(_) => GameEventType::MvmMedicPowerUpShared,
23717 GameEvent::MvmBeginWave(_) => GameEventType::MvmBeginWave,
23718 GameEvent::MvmWaveComplete(_) => GameEventType::MvmWaveComplete,
23719 GameEvent::MvmMissionComplete(_) => GameEventType::MvmMissionComplete,
23720 GameEvent::MvmBombResetByPlayer(_) => GameEventType::MvmBombResetByPlayer,
23721 GameEvent::MvmBombAlarmTriggered(_) => GameEventType::MvmBombAlarmTriggered,
23722 GameEvent::MvmBombDeployResetByPlayer(_) => GameEventType::MvmBombDeployResetByPlayer,
23723 GameEvent::MvmWaveFailed(_) => GameEventType::MvmWaveFailed,
23724 GameEvent::MvmResetStats(_) => GameEventType::MvmResetStats,
23725 GameEvent::DamageResisted(_) => GameEventType::DamageResisted,
23726 GameEvent::RevivePlayerNotify(_) => GameEventType::RevivePlayerNotify,
23727 GameEvent::RevivePlayerStopped(_) => GameEventType::RevivePlayerStopped,
23728 GameEvent::RevivePlayerComplete(_) => GameEventType::RevivePlayerComplete,
23729 GameEvent::PlayerTurnedToGhost(_) => GameEventType::PlayerTurnedToGhost,
23730 GameEvent::MedigunShieldBlockedDamage(_) => GameEventType::MedigunShieldBlockedDamage,
23731 GameEvent::MvmAdvWaveCompleteNoGates(_) => GameEventType::MvmAdvWaveCompleteNoGates,
23732 GameEvent::MvmSniperHeadshotCurrency(_) => GameEventType::MvmSniperHeadshotCurrency,
23733 GameEvent::MvmMannhattanPit(_) => GameEventType::MvmMannhattanPit,
23734 GameEvent::FlagCarriedInDetectionZone(_) => GameEventType::FlagCarriedInDetectionZone,
23735 GameEvent::MvmAdvWaveKilledStunRadio(_) => GameEventType::MvmAdvWaveKilledStunRadio,
23736 GameEvent::PlayerDirectHitStun(_) => GameEventType::PlayerDirectHitStun,
23737 GameEvent::MvmSentryBusterKilled(_) => GameEventType::MvmSentryBusterKilled,
23738 GameEvent::UpgradesFileChanged(_) => GameEventType::UpgradesFileChanged,
23739 GameEvent::RdTeamPointsChanged(_) => GameEventType::RdTeamPointsChanged,
23740 GameEvent::RdRulesStateChanged(_) => GameEventType::RdRulesStateChanged,
23741 GameEvent::RdRobotKilled(_) => GameEventType::RdRobotKilled,
23742 GameEvent::RdRobotImpact(_) => GameEventType::RdRobotImpact,
23743 GameEvent::TeamPlayPreRoundTimeLeft(_) => GameEventType::TeamPlayPreRoundTimeLeft,
23744 GameEvent::ParachuteDeploy(_) => GameEventType::ParachuteDeploy,
23745 GameEvent::ParachuteHolster(_) => GameEventType::ParachuteHolster,
23746 GameEvent::KillRefillsMeter(_) => GameEventType::KillRefillsMeter,
23747 GameEvent::RpsTauntEvent(_) => GameEventType::RpsTauntEvent,
23748 GameEvent::CongaKill(_) => GameEventType::CongaKill,
23749 GameEvent::PlayerInitialSpawn(_) => GameEventType::PlayerInitialSpawn,
23750 GameEvent::CompetitiveVictory(_) => GameEventType::CompetitiveVictory,
23751 GameEvent::CompetitiveStatsUpdate(_) => GameEventType::CompetitiveStatsUpdate,
23752 GameEvent::MiniGameWin(_) => GameEventType::MiniGameWin,
23753 GameEvent::SentryOnGoActive(_) => GameEventType::SentryOnGoActive,
23754 GameEvent::DuckXpLevelUp(_) => GameEventType::DuckXpLevelUp,
23755 GameEvent::QuestLogOpened(_) => GameEventType::QuestLogOpened,
23756 GameEvent::SchemaUpdated(_) => GameEventType::SchemaUpdated,
23757 GameEvent::LocalPlayerPickupWeapon(_) => GameEventType::LocalPlayerPickupWeapon,
23758 GameEvent::RdPlayerScorePoints(_) => GameEventType::RdPlayerScorePoints,
23759 GameEvent::DemomanDetStickies(_) => GameEventType::DemomanDetStickies,
23760 GameEvent::QuestObjectiveCompleted(_) => GameEventType::QuestObjectiveCompleted,
23761 GameEvent::PlayerScoreChanged(_) => GameEventType::PlayerScoreChanged,
23762 GameEvent::KilledCappingPlayer(_) => GameEventType::KilledCappingPlayer,
23763 GameEvent::EnvironmentalDeath(_) => GameEventType::EnvironmentalDeath,
23764 GameEvent::ProjectileDirectHit(_) => GameEventType::ProjectileDirectHit,
23765 GameEvent::PassGet(_) => GameEventType::PassGet,
23766 GameEvent::PassScore(_) => GameEventType::PassScore,
23767 GameEvent::PassFree(_) => GameEventType::PassFree,
23768 GameEvent::PassPassCaught(_) => GameEventType::PassPassCaught,
23769 GameEvent::PassBallStolen(_) => GameEventType::PassBallStolen,
23770 GameEvent::PassBallBlocked(_) => GameEventType::PassBallBlocked,
23771 GameEvent::DamagePrevented(_) => GameEventType::DamagePrevented,
23772 GameEvent::HalloweenBossKilled(_) => GameEventType::HalloweenBossKilled,
23773 GameEvent::EscapedLootIsland(_) => GameEventType::EscapedLootIsland,
23774 GameEvent::TaggedPlayerAsIt(_) => GameEventType::TaggedPlayerAsIt,
23775 GameEvent::MerasmusStunned(_) => GameEventType::MerasmusStunned,
23776 GameEvent::MerasmusPropFound(_) => GameEventType::MerasmusPropFound,
23777 GameEvent::HalloweenSkeletonKilled(_) => GameEventType::HalloweenSkeletonKilled,
23778 GameEvent::SkeletonKilledQuest(_) => GameEventType::SkeletonKilledQuest,
23779 GameEvent::SkeletonKingKilledQuest(_) => GameEventType::SkeletonKingKilledQuest,
23780 GameEvent::EscapeHell(_) => GameEventType::EscapeHell,
23781 GameEvent::CrossSpectralBridge(_) => GameEventType::CrossSpectralBridge,
23782 GameEvent::MiniGameWon(_) => GameEventType::MiniGameWon,
23783 GameEvent::RespawnGhost(_) => GameEventType::RespawnGhost,
23784 GameEvent::KillInHell(_) => GameEventType::KillInHell,
23785 GameEvent::HalloweenDuckCollected(_) => GameEventType::HalloweenDuckCollected,
23786 GameEvent::SpecialScore(_) => GameEventType::SpecialScore,
23787 GameEvent::TeamLeaderKilled(_) => GameEventType::TeamLeaderKilled,
23788 GameEvent::HalloweenSoulCollected(_) => GameEventType::HalloweenSoulCollected,
23789 GameEvent::RecalculateTruce(_) => GameEventType::RecalculateTruce,
23790 GameEvent::DeadRingerCheatDeath(_) => GameEventType::DeadRingerCheatDeath,
23791 GameEvent::CrossbowHeal(_) => GameEventType::CrossbowHeal,
23792 GameEvent::DamageMitigated(_) => GameEventType::DamageMitigated,
23793 GameEvent::PayloadPushed(_) => GameEventType::PayloadPushed,
23794 GameEvent::PlayerAbandonedMatch(_) => GameEventType::PlayerAbandonedMatch,
23795 GameEvent::ClDrawline(_) => GameEventType::ClDrawline,
23796 GameEvent::RestartTimerTime(_) => GameEventType::RestartTimerTime,
23797 GameEvent::WinLimitChanged(_) => GameEventType::WinLimitChanged,
23798 GameEvent::WinPanelShowScores(_) => GameEventType::WinPanelShowScores,
23799 GameEvent::TopStreamsRequestFinished(_) => GameEventType::TopStreamsRequestFinished,
23800 GameEvent::CompetitiveStateChanged(_) => GameEventType::CompetitiveStateChanged,
23801 GameEvent::GlobalWarDataUpdated(_) => GameEventType::GlobalWarDataUpdated,
23802 GameEvent::StopWatchChanged(_) => GameEventType::StopWatchChanged,
23803 GameEvent::DsStop(_) => GameEventType::DsStop,
23804 GameEvent::DsScreenshot(_) => GameEventType::DsScreenshot,
23805 GameEvent::ShowMatchSummary(_) => GameEventType::ShowMatchSummary,
23806 GameEvent::ExperienceChanged(_) => GameEventType::ExperienceChanged,
23807 GameEvent::BeginXpLerp(_) => GameEventType::BeginXpLerp,
23808 GameEvent::MatchmakerStatsUpdated(_) => GameEventType::MatchmakerStatsUpdated,
23809 GameEvent::RematchVotePeriodOver(_) => GameEventType::RematchVotePeriodOver,
23810 GameEvent::RematchFailedToCreate(_) => GameEventType::RematchFailedToCreate,
23811 GameEvent::PlayerRematchChange(_) => GameEventType::PlayerRematchChange,
23812 GameEvent::PingUpdated(_) => GameEventType::PingUpdated,
23813 GameEvent::MMStatsUpdated(_) => GameEventType::MMStatsUpdated,
23814 GameEvent::PlayerNextMapVoteChange(_) => GameEventType::PlayerNextMapVoteChange,
23815 GameEvent::VoteMapsChanged(_) => GameEventType::VoteMapsChanged,
23816 GameEvent::ProtoDefChanged(_) => GameEventType::ProtoDefChanged,
23817 GameEvent::PlayerDomination(_) => GameEventType::PlayerDomination,
23818 GameEvent::PlayerRocketPackPushed(_) => GameEventType::PlayerRocketPackPushed,
23819 GameEvent::QuestRequest(_) => GameEventType::QuestRequest,
23820 GameEvent::QuestResponse(_) => GameEventType::QuestResponse,
23821 GameEvent::QuestProgress(_) => GameEventType::QuestProgress,
23822 GameEvent::ProjectileRemoved(_) => GameEventType::ProjectileRemoved,
23823 GameEvent::QuestMapDataChanged(_) => GameEventType::QuestMapDataChanged,
23824 GameEvent::GasDousedPlayerIgnited(_) => GameEventType::GasDousedPlayerIgnited,
23825 GameEvent::QuestTurnInState(_) => GameEventType::QuestTurnInState,
23826 GameEvent::ItemsAcknowledged(_) => GameEventType::ItemsAcknowledged,
23827 GameEvent::CapperKilled(_) => GameEventType::CapperKilled,
23828 GameEvent::MainMenuStabilized(_) => GameEventType::MainMenuStabilized,
23829 GameEvent::WorldStatusChanged(_) => GameEventType::WorldStatusChanged,
23830 GameEvent::HLTVStatus(_) => GameEventType::HLTVStatus,
23831 GameEvent::HLTVCameraman(_) => GameEventType::HLTVCameraman,
23832 GameEvent::HLTVRankCamera(_) => GameEventType::HLTVRankCamera,
23833 GameEvent::HLTVRankEntity(_) => GameEventType::HLTVRankEntity,
23834 GameEvent::HLTVFixed(_) => GameEventType::HLTVFixed,
23835 GameEvent::HLTVChase(_) => GameEventType::HLTVChase,
23836 GameEvent::HLTVMessage(_) => GameEventType::HLTVMessage,
23837 GameEvent::HLTVTitle(_) => GameEventType::HLTVTitle,
23838 GameEvent::HLTVChat(_) => GameEventType::HLTVChat,
23839 GameEvent::ReplayStartRecord(_) => GameEventType::ReplayStartRecord,
23840 GameEvent::ReplaySessionInfo(_) => GameEventType::ReplaySessionInfo,
23841 GameEvent::ReplayEndRecord(_) => GameEventType::ReplayEndRecord,
23842 GameEvent::ReplayReplaysAvailable(_) => GameEventType::ReplayReplaysAvailable,
23843 GameEvent::ReplayServerError(_) => GameEventType::ReplayServerError,
23844 GameEvent::Unknown(raw) => raw.event_type.clone(),
23845 }
23846 }
23847}
23848pub fn get_sizes() -> fnv::FnvHashMap<&'static str, usize> {
23849 [
23850 ("ServerSpawn", size_of::<ServerSpawnEvent>()),
23851 (
23852 "ServerChangeLevelFailed",
23853 size_of::<ServerChangeLevelFailedEvent>(),
23854 ),
23855 ("ServerShutdown", size_of::<ServerShutdownEvent>()),
23856 ("ServerCvar", size_of::<ServerCvarEvent>()),
23857 ("ServerMessage", size_of::<ServerMessageEvent>()),
23858 ("ServerAddBan", size_of::<ServerAddBanEvent>()),
23859 ("ServerRemoveBan", size_of::<ServerRemoveBanEvent>()),
23860 ("PlayerConnect", size_of::<PlayerConnectEvent>()),
23861 ("PlayerConnectClient", size_of::<PlayerConnectClientEvent>()),
23862 ("PlayerInfo", size_of::<PlayerInfoEvent>()),
23863 ("PlayerDisconnect", size_of::<PlayerDisconnectEvent>()),
23864 ("PlayerActivate", size_of::<PlayerActivateEvent>()),
23865 ("PlayerSay", size_of::<PlayerSayEvent>()),
23866 ("ClientDisconnect", size_of::<ClientDisconnectEvent>()),
23867 ("ClientBeginConnect", size_of::<ClientBeginConnectEvent>()),
23868 ("ClientConnected", size_of::<ClientConnectedEvent>()),
23869 ("ClientFullConnect", size_of::<ClientFullConnectEvent>()),
23870 ("HostQuit", size_of::<HostQuitEvent>()),
23871 ("TeamInfo", size_of::<TeamInfoEvent>()),
23872 ("TeamScore", size_of::<TeamScoreEvent>()),
23873 (
23874 "TeamPlayBroadcastAudio",
23875 size_of::<TeamPlayBroadcastAudioEvent>(),
23876 ),
23877 ("PlayerTeam", size_of::<PlayerTeamEvent>()),
23878 ("PlayerClass", size_of::<PlayerClassEvent>()),
23879 ("PlayerDeath", size_of::<PlayerDeathEvent>()),
23880 ("PlayerHurt", size_of::<PlayerHurtEvent>()),
23881 ("PlayerChat", size_of::<PlayerChatEvent>()),
23882 ("PlayerScore", size_of::<PlayerScoreEvent>()),
23883 ("PlayerSpawn", size_of::<PlayerSpawnEvent>()),
23884 ("PlayerShoot", size_of::<PlayerShootEvent>()),
23885 ("PlayerUse", size_of::<PlayerUseEvent>()),
23886 ("PlayerChangeName", size_of::<PlayerChangeNameEvent>()),
23887 ("PlayerHintMessage", size_of::<PlayerHintMessageEvent>()),
23888 (
23889 "BasePlayerTeleported",
23890 size_of::<BasePlayerTeleportedEvent>(),
23891 ),
23892 ("GameInit", size_of::<GameInitEvent>()),
23893 ("GameNewMap", size_of::<GameNewMapEvent>()),
23894 ("GameStart", size_of::<GameStartEvent>()),
23895 ("GameEnd", size_of::<GameEndEvent>()),
23896 ("RoundStart", size_of::<RoundStartEvent>()),
23897 ("RoundEnd", size_of::<RoundEndEvent>()),
23898 ("GameMessage", size_of::<GameMessageEvent>()),
23899 ("BreakBreakable", size_of::<BreakBreakableEvent>()),
23900 ("BreakProp", size_of::<BreakPropEvent>()),
23901 ("EntityKilled", size_of::<EntityKilledEvent>()),
23902 ("BonusUpdated", size_of::<BonusUpdatedEvent>()),
23903 ("AchievementEvent", size_of::<AchievementEventEvent>()),
23904 (
23905 "AchievementIncrement",
23906 size_of::<AchievementIncrementEvent>(),
23907 ),
23908 ("PhysgunPickup", size_of::<PhysgunPickupEvent>()),
23909 ("FlareIgniteNpc", size_of::<FlareIgniteNpcEvent>()),
23910 (
23911 "HelicopterGrenadePuntMiss",
23912 size_of::<HelicopterGrenadePuntMissEvent>(),
23913 ),
23914 ("UserDataDownloaded", size_of::<UserDataDownloadedEvent>()),
23915 ("RagdollDissolved", size_of::<RagdollDissolvedEvent>()),
23916 ("HLTVChangedMode", size_of::<HLTVChangedModeEvent>()),
23917 ("HLTVChangedTarget", size_of::<HLTVChangedTargetEvent>()),
23918 ("VoteEnded", size_of::<VoteEndedEvent>()),
23919 ("VoteStarted", size_of::<VoteStartedEvent>()),
23920 ("VoteChanged", size_of::<VoteChangedEvent>()),
23921 ("VotePassed", size_of::<VotePassedEvent>()),
23922 ("VoteFailed", size_of::<VoteFailedEvent>()),
23923 ("VoteCast", size_of::<VoteCastEvent>()),
23924 ("VoteOptions", size_of::<VoteOptionsEvent>()),
23925 ("ReplaySaved", size_of::<ReplaySavedEvent>()),
23926 (
23927 "EnteredPerformanceMode",
23928 size_of::<EnteredPerformanceModeEvent>(),
23929 ),
23930 ("BrowseReplays", size_of::<BrowseReplaysEvent>()),
23931 ("ReplayYoutubeStats", size_of::<ReplayYoutubeStatsEvent>()),
23932 ("InventoryUpdated", size_of::<InventoryUpdatedEvent>()),
23933 ("CartUpdated", size_of::<CartUpdatedEvent>()),
23934 (
23935 "StorePriceSheetUpdated",
23936 size_of::<StorePriceSheetUpdatedEvent>(),
23937 ),
23938 (
23939 "EconInventoryConnected",
23940 size_of::<EconInventoryConnectedEvent>(),
23941 ),
23942 (
23943 "ItemSchemaInitialized",
23944 size_of::<ItemSchemaInitializedEvent>(),
23945 ),
23946 ("GcNewSession", size_of::<GcNewSessionEvent>()),
23947 ("GcLostSession", size_of::<GcLostSessionEvent>()),
23948 ("IntroFinish", size_of::<IntroFinishEvent>()),
23949 ("IntroNextCamera", size_of::<IntroNextCameraEvent>()),
23950 ("PlayerChangeClass", size_of::<PlayerChangeClassEvent>()),
23951 ("TfMapTimeRemaining", size_of::<TfMapTimeRemainingEvent>()),
23952 ("TfGameOver", size_of::<TfGameOverEvent>()),
23953 ("CtfFlagCaptured", size_of::<CtfFlagCapturedEvent>()),
23954 (
23955 "ControlPointInitialized",
23956 size_of::<ControlPointInitializedEvent>(),
23957 ),
23958 (
23959 "ControlPointUpdateImages",
23960 size_of::<ControlPointUpdateImagesEvent>(),
23961 ),
23962 (
23963 "ControlPointUpdateLayout",
23964 size_of::<ControlPointUpdateLayoutEvent>(),
23965 ),
23966 (
23967 "ControlPointUpdateCapping",
23968 size_of::<ControlPointUpdateCappingEvent>(),
23969 ),
23970 (
23971 "ControlPointUpdateOwner",
23972 size_of::<ControlPointUpdateOwnerEvent>(),
23973 ),
23974 (
23975 "ControlPointStartTouch",
23976 size_of::<ControlPointStartTouchEvent>(),
23977 ),
23978 (
23979 "ControlPointEndTouch",
23980 size_of::<ControlPointEndTouchEvent>(),
23981 ),
23982 (
23983 "ControlPointPulseElement",
23984 size_of::<ControlPointPulseElementEvent>(),
23985 ),
23986 (
23987 "ControlPointFakeCapture",
23988 size_of::<ControlPointFakeCaptureEvent>(),
23989 ),
23990 (
23991 "ControlPointFakeCaptureMultiplier",
23992 size_of::<ControlPointFakeCaptureMultiplierEvent>(),
23993 ),
23994 (
23995 "TeamPlayRoundSelected",
23996 size_of::<TeamPlayRoundSelectedEvent>(),
23997 ),
23998 ("TeamPlayRoundStart", size_of::<TeamPlayRoundStartEvent>()),
23999 ("TeamPlayRoundActive", size_of::<TeamPlayRoundActiveEvent>()),
24000 (
24001 "TeamPlayWaitingBegins",
24002 size_of::<TeamPlayWaitingBeginsEvent>(),
24003 ),
24004 ("TeamPlayWaitingEnds", size_of::<TeamPlayWaitingEndsEvent>()),
24005 (
24006 "TeamPlayWaitingAboutToEnd",
24007 size_of::<TeamPlayWaitingAboutToEndEvent>(),
24008 ),
24009 (
24010 "TeamPlayRestartRound",
24011 size_of::<TeamPlayRestartRoundEvent>(),
24012 ),
24013 (
24014 "TeamPlayReadyRestart",
24015 size_of::<TeamPlayReadyRestartEvent>(),
24016 ),
24017 (
24018 "TeamPlayRoundRestartSeconds",
24019 size_of::<TeamPlayRoundRestartSecondsEvent>(),
24020 ),
24021 ("TeamPlayTeamReady", size_of::<TeamPlayTeamReadyEvent>()),
24022 ("TeamPlayRoundWin", size_of::<TeamPlayRoundWinEvent>()),
24023 ("TeamPlayUpdateTimer", size_of::<TeamPlayUpdateTimerEvent>()),
24024 (
24025 "TeamPlayRoundStalemate",
24026 size_of::<TeamPlayRoundStalemateEvent>(),
24027 ),
24028 (
24029 "TeamPlayOvertimeBegin",
24030 size_of::<TeamPlayOvertimeBeginEvent>(),
24031 ),
24032 ("TeamPlayOvertimeEnd", size_of::<TeamPlayOvertimeEndEvent>()),
24033 (
24034 "TeamPlaySuddenDeathBegin",
24035 size_of::<TeamPlaySuddenDeathBeginEvent>(),
24036 ),
24037 (
24038 "TeamPlaySuddenDeathEnd",
24039 size_of::<TeamPlaySuddenDeathEndEvent>(),
24040 ),
24041 ("TeamPlayGameOver", size_of::<TeamPlayGameOverEvent>()),
24042 (
24043 "TeamPlayMapTimeRemaining",
24044 size_of::<TeamPlayMapTimeRemainingEvent>(),
24045 ),
24046 ("TeamPlayTimerFlash", size_of::<TeamPlayTimerFlashEvent>()),
24047 (
24048 "TeamPlayTimerTimeAdded",
24049 size_of::<TeamPlayTimerTimeAddedEvent>(),
24050 ),
24051 (
24052 "TeamPlayPointStartCapture",
24053 size_of::<TeamPlayPointStartCaptureEvent>(),
24054 ),
24055 (
24056 "TeamPlayPointCaptured",
24057 size_of::<TeamPlayPointCapturedEvent>(),
24058 ),
24059 ("TeamPlayPointLocked", size_of::<TeamPlayPointLockedEvent>()),
24060 (
24061 "TeamPlayPointUnlocked",
24062 size_of::<TeamPlayPointUnlockedEvent>(),
24063 ),
24064 (
24065 "TeamPlayCaptureBroken",
24066 size_of::<TeamPlayCaptureBrokenEvent>(),
24067 ),
24068 (
24069 "TeamPlayCaptureBlocked",
24070 size_of::<TeamPlayCaptureBlockedEvent>(),
24071 ),
24072 ("TeamPlayFlagEvent", size_of::<TeamPlayFlagEventEvent>()),
24073 ("TeamPlayWinPanel", size_of::<TeamPlayWinPanelEvent>()),
24074 (
24075 "TeamPlayTeamBalancedPlayer",
24076 size_of::<TeamPlayTeamBalancedPlayerEvent>(),
24077 ),
24078 (
24079 "TeamPlaySetupFinished",
24080 size_of::<TeamPlaySetupFinishedEvent>(),
24081 ),
24082 ("TeamPlayAlert", size_of::<TeamPlayAlertEvent>()),
24083 ("TrainingComplete", size_of::<TrainingCompleteEvent>()),
24084 ("ShowFreezePanel", size_of::<ShowFreezePanelEvent>()),
24085 ("HideFreezePanel", size_of::<HideFreezePanelEvent>()),
24086 ("FreezeCamStarted", size_of::<FreezeCamStartedEvent>()),
24087 (
24088 "LocalPlayerChangeTeam",
24089 size_of::<LocalPlayerChangeTeamEvent>(),
24090 ),
24091 (
24092 "LocalPlayerScoreChanged",
24093 size_of::<LocalPlayerScoreChangedEvent>(),
24094 ),
24095 (
24096 "LocalPlayerChangeClass",
24097 size_of::<LocalPlayerChangeClassEvent>(),
24098 ),
24099 ("LocalPlayerRespawn", size_of::<LocalPlayerRespawnEvent>()),
24100 ("BuildingInfoChanged", size_of::<BuildingInfoChangedEvent>()),
24101 (
24102 "LocalPlayerChangeDisguise",
24103 size_of::<LocalPlayerChangeDisguiseEvent>(),
24104 ),
24105 (
24106 "PlayerAccountChanged",
24107 size_of::<PlayerAccountChangedEvent>(),
24108 ),
24109 ("SpyPdaReset", size_of::<SpyPdaResetEvent>()),
24110 ("FlagStatusUpdate", size_of::<FlagStatusUpdateEvent>()),
24111 ("PlayerStatsUpdated", size_of::<PlayerStatsUpdatedEvent>()),
24112 ("PlayingCommentary", size_of::<PlayingCommentaryEvent>()),
24113 (
24114 "PlayerChargeDeployed",
24115 size_of::<PlayerChargeDeployedEvent>(),
24116 ),
24117 ("PlayerBuiltObject", size_of::<PlayerBuiltObjectEvent>()),
24118 (
24119 "PlayerUpgradedObject",
24120 size_of::<PlayerUpgradedObjectEvent>(),
24121 ),
24122 ("PlayerCarryObject", size_of::<PlayerCarryObjectEvent>()),
24123 ("PlayerDropObject", size_of::<PlayerDropObjectEvent>()),
24124 ("ObjectRemoved", size_of::<ObjectRemovedEvent>()),
24125 ("ObjectDestroyed", size_of::<ObjectDestroyedEvent>()),
24126 ("ObjectDetonated", size_of::<ObjectDetonatedEvent>()),
24127 ("AchievementEarned", size_of::<AchievementEarnedEvent>()),
24128 ("SpecTargetUpdated", size_of::<SpecTargetUpdatedEvent>()),
24129 (
24130 "TournamentStateUpdate",
24131 size_of::<TournamentStateUpdateEvent>(),
24132 ),
24133 (
24134 "TournamentEnableCountdown",
24135 size_of::<TournamentEnableCountdownEvent>(),
24136 ),
24137 (
24138 "PlayerCalledForMedic",
24139 size_of::<PlayerCalledForMedicEvent>(),
24140 ),
24141 ("PlayerAskedForBall", size_of::<PlayerAskedForBallEvent>()),
24142 (
24143 "LocalPlayerBecameObserver",
24144 size_of::<LocalPlayerBecameObserverEvent>(),
24145 ),
24146 ("PlayerIgnitedInv", size_of::<PlayerIgnitedInvEvent>()),
24147 ("PlayerIgnited", size_of::<PlayerIgnitedEvent>()),
24148 ("PlayerExtinguished", size_of::<PlayerExtinguishedEvent>()),
24149 ("PlayerTeleported", size_of::<PlayerTeleportedEvent>()),
24150 (
24151 "PlayerHealedMedicCall",
24152 size_of::<PlayerHealedMedicCallEvent>(),
24153 ),
24154 (
24155 "LocalPlayerChargeReady",
24156 size_of::<LocalPlayerChargeReadyEvent>(),
24157 ),
24158 ("LocalPlayerWindDown", size_of::<LocalPlayerWindDownEvent>()),
24159 ("PlayerInvulned", size_of::<PlayerInvulnedEvent>()),
24160 ("EscortSpeed", size_of::<EscortSpeedEvent>()),
24161 ("EscortProgress", size_of::<EscortProgressEvent>()),
24162 ("EscortRecede", size_of::<EscortRecedeEvent>()),
24163 ("GameUIActivated", size_of::<GameUIActivatedEvent>()),
24164 ("GameUIHidden", size_of::<GameUIHiddenEvent>()),
24165 ("PlayerEscortScore", size_of::<PlayerEscortScoreEvent>()),
24166 ("PlayerHealOnHit", size_of::<PlayerHealOnHitEvent>()),
24167 ("PlayerStealSandvich", size_of::<PlayerStealSandvichEvent>()),
24168 ("ShowClassLayout", size_of::<ShowClassLayoutEvent>()),
24169 ("ShowVsPanel", size_of::<ShowVsPanelEvent>()),
24170 ("PlayerDamaged", size_of::<PlayerDamagedEvent>()),
24171 (
24172 "ArenaPlayerNotification",
24173 size_of::<ArenaPlayerNotificationEvent>(),
24174 ),
24175 ("ArenaMatchMaxStreak", size_of::<ArenaMatchMaxStreakEvent>()),
24176 ("ArenaRoundStart", size_of::<ArenaRoundStartEvent>()),
24177 ("ArenaWinPanel", size_of::<ArenaWinPanelEvent>()),
24178 ("PveWinPanel", size_of::<PveWinPanelEvent>()),
24179 ("AirDash", size_of::<AirDashEvent>()),
24180 ("Landed", size_of::<LandedEvent>()),
24181 ("PlayerDamageDodged", size_of::<PlayerDamageDodgedEvent>()),
24182 ("PlayerStunned", size_of::<PlayerStunnedEvent>()),
24183 ("ScoutGrandSlam", size_of::<ScoutGrandSlamEvent>()),
24184 ("ScoutSlamdollLanded", size_of::<ScoutSlamdollLandedEvent>()),
24185 ("ArrowImpact", size_of::<ArrowImpactEvent>()),
24186 ("PlayerJarated", size_of::<PlayerJaratedEvent>()),
24187 ("PlayerJaratedFade", size_of::<PlayerJaratedFadeEvent>()),
24188 ("PlayerShieldBlocked", size_of::<PlayerShieldBlockedEvent>()),
24189 ("PlayerPinned", size_of::<PlayerPinnedEvent>()),
24190 ("PlayerHealedByMedic", size_of::<PlayerHealedByMedicEvent>()),
24191 ("PlayerSappedObject", size_of::<PlayerSappedObjectEvent>()),
24192 ("ItemFound", size_of::<ItemFoundEvent>()),
24193 ("ShowAnnotation", size_of::<ShowAnnotationEvent>()),
24194 ("HideAnnotation", size_of::<HideAnnotationEvent>()),
24195 (
24196 "PostInventoryApplication",
24197 size_of::<PostInventoryApplicationEvent>(),
24198 ),
24199 (
24200 "ControlPointUnlockUpdated",
24201 size_of::<ControlPointUnlockUpdatedEvent>(),
24202 ),
24203 ("DeployBuffBanner", size_of::<DeployBuffBannerEvent>()),
24204 ("PlayerBuff", size_of::<PlayerBuffEvent>()),
24205 ("MedicDeath", size_of::<MedicDeathEvent>()),
24206 ("OvertimeNag", size_of::<OvertimeNagEvent>()),
24207 ("TeamsChanged", size_of::<TeamsChangedEvent>()),
24208 (
24209 "HalloweenPumpkinGrab",
24210 size_of::<HalloweenPumpkinGrabEvent>(),
24211 ),
24212 ("RocketJump", size_of::<RocketJumpEvent>()),
24213 ("RocketJumpLanded", size_of::<RocketJumpLandedEvent>()),
24214 ("StickyJump", size_of::<StickyJumpEvent>()),
24215 ("StickyJumpLanded", size_of::<StickyJumpLandedEvent>()),
24216 ("RocketPackLaunch", size_of::<RocketPackLaunchEvent>()),
24217 ("RocketPackLanded", size_of::<RocketPackLandedEvent>()),
24218 ("MedicDefended", size_of::<MedicDefendedEvent>()),
24219 ("LocalPlayerHealed", size_of::<LocalPlayerHealedEvent>()),
24220 (
24221 "PlayerDestroyedPipeBomb",
24222 size_of::<PlayerDestroyedPipeBombEvent>(),
24223 ),
24224 ("ObjectDeflected", size_of::<ObjectDeflectedEvent>()),
24225 ("PlayerMvp", size_of::<PlayerMvpEvent>()),
24226 ("RaidSpawnMob", size_of::<RaidSpawnMobEvent>()),
24227 ("RaidSpawnSquad", size_of::<RaidSpawnSquadEvent>()),
24228 ("NavBlocked", size_of::<NavBlockedEvent>()),
24229 ("PathTrackPassed", size_of::<PathTrackPassedEvent>()),
24230 ("NumCappersChanged", size_of::<NumCappersChangedEvent>()),
24231 ("PlayerRegenerate", size_of::<PlayerRegenerateEvent>()),
24232 ("UpdateStatusItem", size_of::<UpdateStatusItemEvent>()),
24233 ("StatsResetRound", size_of::<StatsResetRoundEvent>()),
24234 (
24235 "ScoreStatsAccumulatedUpdate",
24236 size_of::<ScoreStatsAccumulatedUpdateEvent>(),
24237 ),
24238 (
24239 "ScoreStatsAccumulatedReset",
24240 size_of::<ScoreStatsAccumulatedResetEvent>(),
24241 ),
24242 (
24243 "AchievementEarnedLocal",
24244 size_of::<AchievementEarnedLocalEvent>(),
24245 ),
24246 ("PlayerHealed", size_of::<PlayerHealedEvent>()),
24247 ("BuildingHealed", size_of::<BuildingHealedEvent>()),
24248 ("ItemPickup", size_of::<ItemPickupEvent>()),
24249 ("DuelStatus", size_of::<DuelStatusEvent>()),
24250 ("FishNotice", size_of::<FishNoticeEvent>()),
24251 ("FishNoticeArm", size_of::<FishNoticeArmEvent>()),
24252 ("SlapNotice", size_of::<SlapNoticeEvent>()),
24253 ("ThrowableHit", size_of::<ThrowableHitEvent>()),
24254 ("PumpkinLordSummoned", size_of::<PumpkinLordSummonedEvent>()),
24255 ("PumpkinLordKilled", size_of::<PumpkinLordKilledEvent>()),
24256 ("MerasmusSummoned", size_of::<MerasmusSummonedEvent>()),
24257 ("MerasmusKilled", size_of::<MerasmusKilledEvent>()),
24258 (
24259 "MerasmusEscapeWarning",
24260 size_of::<MerasmusEscapeWarningEvent>(),
24261 ),
24262 ("MerasmusEscaped", size_of::<MerasmusEscapedEvent>()),
24263 ("EyeballBossSummoned", size_of::<EyeballBossSummonedEvent>()),
24264 ("EyeballBossStunned", size_of::<EyeballBossStunnedEvent>()),
24265 ("EyeballBossKilled", size_of::<EyeballBossKilledEvent>()),
24266 ("EyeballBossKiller", size_of::<EyeballBossKillerEvent>()),
24267 (
24268 "EyeballBossEscapeImminent",
24269 size_of::<EyeballBossEscapeImminentEvent>(),
24270 ),
24271 ("EyeballBossEscaped", size_of::<EyeballBossEscapedEvent>()),
24272 ("NpcHurt", size_of::<NpcHurtEvent>()),
24273 (
24274 "ControlPointTimerUpdated",
24275 size_of::<ControlPointTimerUpdatedEvent>(),
24276 ),
24277 ("PlayerHighFiveStart", size_of::<PlayerHighFiveStartEvent>()),
24278 (
24279 "PlayerHighFiveCancel",
24280 size_of::<PlayerHighFiveCancelEvent>(),
24281 ),
24282 (
24283 "PlayerHighFiveSuccess",
24284 size_of::<PlayerHighFiveSuccessEvent>(),
24285 ),
24286 ("PlayerBonusPoints", size_of::<PlayerBonusPointsEvent>()),
24287 ("PlayerUpgraded", size_of::<PlayerUpgradedEvent>()),
24288 ("PlayerBuyback", size_of::<PlayerBuybackEvent>()),
24289 (
24290 "PlayerUsedPowerUpBottle",
24291 size_of::<PlayerUsedPowerUpBottleEvent>(),
24292 ),
24293 ("ChristmasGiftGrab", size_of::<ChristmasGiftGrabEvent>()),
24294 (
24295 "PlayerKilledAchievementZone",
24296 size_of::<PlayerKilledAchievementZoneEvent>(),
24297 ),
24298 ("PartyUpdated", size_of::<PartyUpdatedEvent>()),
24299 ("PartyPrefChanged", size_of::<PartyPrefChangedEvent>()),
24300 (
24301 "PartyCriteriaChanged",
24302 size_of::<PartyCriteriaChangedEvent>(),
24303 ),
24304 ("PartyInvitesChanged", size_of::<PartyInvitesChangedEvent>()),
24305 (
24306 "PartyQueueStateChanged",
24307 size_of::<PartyQueueStateChangedEvent>(),
24308 ),
24309 ("PartyChat", size_of::<PartyChatEvent>()),
24310 ("PartyMemberJoin", size_of::<PartyMemberJoinEvent>()),
24311 ("PartyMemberLeave", size_of::<PartyMemberLeaveEvent>()),
24312 ("MatchInvitesUpdated", size_of::<MatchInvitesUpdatedEvent>()),
24313 ("LobbyUpdated", size_of::<LobbyUpdatedEvent>()),
24314 ("MvmMissionUpdate", size_of::<MvmMissionUpdateEvent>()),
24315 ("RecalculateHolidays", size_of::<RecalculateHolidaysEvent>()),
24316 (
24317 "PlayerCurrencyChanged",
24318 size_of::<PlayerCurrencyChangedEvent>(),
24319 ),
24320 ("DoomsdayRocketOpen", size_of::<DoomsdayRocketOpenEvent>()),
24321 (
24322 "RemoveNemesisRelationships",
24323 size_of::<RemoveNemesisRelationshipsEvent>(),
24324 ),
24325 ("MvmCreditBonusWave", size_of::<MvmCreditBonusWaveEvent>()),
24326 ("MvmCreditBonusAll", size_of::<MvmCreditBonusAllEvent>()),
24327 (
24328 "MvmCreditBonusAllAdvanced",
24329 size_of::<MvmCreditBonusAllAdvancedEvent>(),
24330 ),
24331 (
24332 "MvmQuickSentryUpgrade",
24333 size_of::<MvmQuickSentryUpgradeEvent>(),
24334 ),
24335 (
24336 "MvmTankDestroyedByPlayers",
24337 size_of::<MvmTankDestroyedByPlayersEvent>(),
24338 ),
24339 (
24340 "MvmKillRobotDeliveringBomb",
24341 size_of::<MvmKillRobotDeliveringBombEvent>(),
24342 ),
24343 ("MvmPickupCurrency", size_of::<MvmPickupCurrencyEvent>()),
24344 (
24345 "MvmBombCarrierKilled",
24346 size_of::<MvmBombCarrierKilledEvent>(),
24347 ),
24348 (
24349 "MvmSentryBusterDetonate",
24350 size_of::<MvmSentryBusterDetonateEvent>(),
24351 ),
24352 (
24353 "MvmScoutMarkedForDeath",
24354 size_of::<MvmScoutMarkedForDeathEvent>(),
24355 ),
24356 (
24357 "MvmMedicPowerUpShared",
24358 size_of::<MvmMedicPowerUpSharedEvent>(),
24359 ),
24360 ("MvmBeginWave", size_of::<MvmBeginWaveEvent>()),
24361 ("MvmWaveComplete", size_of::<MvmWaveCompleteEvent>()),
24362 ("MvmMissionComplete", size_of::<MvmMissionCompleteEvent>()),
24363 (
24364 "MvmBombResetByPlayer",
24365 size_of::<MvmBombResetByPlayerEvent>(),
24366 ),
24367 (
24368 "MvmBombAlarmTriggered",
24369 size_of::<MvmBombAlarmTriggeredEvent>(),
24370 ),
24371 (
24372 "MvmBombDeployResetByPlayer",
24373 size_of::<MvmBombDeployResetByPlayerEvent>(),
24374 ),
24375 ("MvmWaveFailed", size_of::<MvmWaveFailedEvent>()),
24376 ("MvmResetStats", size_of::<MvmResetStatsEvent>()),
24377 ("DamageResisted", size_of::<DamageResistedEvent>()),
24378 ("RevivePlayerNotify", size_of::<RevivePlayerNotifyEvent>()),
24379 ("RevivePlayerStopped", size_of::<RevivePlayerStoppedEvent>()),
24380 (
24381 "RevivePlayerComplete",
24382 size_of::<RevivePlayerCompleteEvent>(),
24383 ),
24384 ("PlayerTurnedToGhost", size_of::<PlayerTurnedToGhostEvent>()),
24385 (
24386 "MedigunShieldBlockedDamage",
24387 size_of::<MedigunShieldBlockedDamageEvent>(),
24388 ),
24389 (
24390 "MvmAdvWaveCompleteNoGates",
24391 size_of::<MvmAdvWaveCompleteNoGatesEvent>(),
24392 ),
24393 (
24394 "MvmSniperHeadshotCurrency",
24395 size_of::<MvmSniperHeadshotCurrencyEvent>(),
24396 ),
24397 ("MvmMannhattanPit", size_of::<MvmMannhattanPitEvent>()),
24398 (
24399 "FlagCarriedInDetectionZone",
24400 size_of::<FlagCarriedInDetectionZoneEvent>(),
24401 ),
24402 (
24403 "MvmAdvWaveKilledStunRadio",
24404 size_of::<MvmAdvWaveKilledStunRadioEvent>(),
24405 ),
24406 ("PlayerDirectHitStun", size_of::<PlayerDirectHitStunEvent>()),
24407 (
24408 "MvmSentryBusterKilled",
24409 size_of::<MvmSentryBusterKilledEvent>(),
24410 ),
24411 ("UpgradesFileChanged", size_of::<UpgradesFileChangedEvent>()),
24412 ("RdTeamPointsChanged", size_of::<RdTeamPointsChangedEvent>()),
24413 ("RdRulesStateChanged", size_of::<RdRulesStateChangedEvent>()),
24414 ("RdRobotKilled", size_of::<RdRobotKilledEvent>()),
24415 ("RdRobotImpact", size_of::<RdRobotImpactEvent>()),
24416 (
24417 "TeamPlayPreRoundTimeLeft",
24418 size_of::<TeamPlayPreRoundTimeLeftEvent>(),
24419 ),
24420 ("ParachuteDeploy", size_of::<ParachuteDeployEvent>()),
24421 ("ParachuteHolster", size_of::<ParachuteHolsterEvent>()),
24422 ("KillRefillsMeter", size_of::<KillRefillsMeterEvent>()),
24423 ("RpsTauntEvent", size_of::<RpsTauntEventEvent>()),
24424 ("CongaKill", size_of::<CongaKillEvent>()),
24425 ("PlayerInitialSpawn", size_of::<PlayerInitialSpawnEvent>()),
24426 ("CompetitiveVictory", size_of::<CompetitiveVictoryEvent>()),
24427 (
24428 "CompetitiveStatsUpdate",
24429 size_of::<CompetitiveStatsUpdateEvent>(),
24430 ),
24431 ("MiniGameWin", size_of::<MiniGameWinEvent>()),
24432 ("SentryOnGoActive", size_of::<SentryOnGoActiveEvent>()),
24433 ("DuckXpLevelUp", size_of::<DuckXpLevelUpEvent>()),
24434 ("QuestLogOpened", size_of::<QuestLogOpenedEvent>()),
24435 ("SchemaUpdated", size_of::<SchemaUpdatedEvent>()),
24436 (
24437 "LocalPlayerPickupWeapon",
24438 size_of::<LocalPlayerPickupWeaponEvent>(),
24439 ),
24440 ("RdPlayerScorePoints", size_of::<RdPlayerScorePointsEvent>()),
24441 ("DemomanDetStickies", size_of::<DemomanDetStickiesEvent>()),
24442 (
24443 "QuestObjectiveCompleted",
24444 size_of::<QuestObjectiveCompletedEvent>(),
24445 ),
24446 ("PlayerScoreChanged", size_of::<PlayerScoreChangedEvent>()),
24447 ("KilledCappingPlayer", size_of::<KilledCappingPlayerEvent>()),
24448 ("EnvironmentalDeath", size_of::<EnvironmentalDeathEvent>()),
24449 ("ProjectileDirectHit", size_of::<ProjectileDirectHitEvent>()),
24450 ("PassGet", size_of::<PassGetEvent>()),
24451 ("PassScore", size_of::<PassScoreEvent>()),
24452 ("PassFree", size_of::<PassFreeEvent>()),
24453 ("PassPassCaught", size_of::<PassPassCaughtEvent>()),
24454 ("PassBallStolen", size_of::<PassBallStolenEvent>()),
24455 ("PassBallBlocked", size_of::<PassBallBlockedEvent>()),
24456 ("DamagePrevented", size_of::<DamagePreventedEvent>()),
24457 ("HalloweenBossKilled", size_of::<HalloweenBossKilledEvent>()),
24458 ("EscapedLootIsland", size_of::<EscapedLootIslandEvent>()),
24459 ("TaggedPlayerAsIt", size_of::<TaggedPlayerAsItEvent>()),
24460 ("MerasmusStunned", size_of::<MerasmusStunnedEvent>()),
24461 ("MerasmusPropFound", size_of::<MerasmusPropFoundEvent>()),
24462 (
24463 "HalloweenSkeletonKilled",
24464 size_of::<HalloweenSkeletonKilledEvent>(),
24465 ),
24466 ("SkeletonKilledQuest", size_of::<SkeletonKilledQuestEvent>()),
24467 (
24468 "SkeletonKingKilledQuest",
24469 size_of::<SkeletonKingKilledQuestEvent>(),
24470 ),
24471 ("EscapeHell", size_of::<EscapeHellEvent>()),
24472 ("CrossSpectralBridge", size_of::<CrossSpectralBridgeEvent>()),
24473 ("MiniGameWon", size_of::<MiniGameWonEvent>()),
24474 ("RespawnGhost", size_of::<RespawnGhostEvent>()),
24475 ("KillInHell", size_of::<KillInHellEvent>()),
24476 (
24477 "HalloweenDuckCollected",
24478 size_of::<HalloweenDuckCollectedEvent>(),
24479 ),
24480 ("SpecialScore", size_of::<SpecialScoreEvent>()),
24481 ("TeamLeaderKilled", size_of::<TeamLeaderKilledEvent>()),
24482 (
24483 "HalloweenSoulCollected",
24484 size_of::<HalloweenSoulCollectedEvent>(),
24485 ),
24486 ("RecalculateTruce", size_of::<RecalculateTruceEvent>()),
24487 (
24488 "DeadRingerCheatDeath",
24489 size_of::<DeadRingerCheatDeathEvent>(),
24490 ),
24491 ("CrossbowHeal", size_of::<CrossbowHealEvent>()),
24492 ("DamageMitigated", size_of::<DamageMitigatedEvent>()),
24493 ("PayloadPushed", size_of::<PayloadPushedEvent>()),
24494 (
24495 "PlayerAbandonedMatch",
24496 size_of::<PlayerAbandonedMatchEvent>(),
24497 ),
24498 ("ClDrawline", size_of::<ClDrawlineEvent>()),
24499 ("RestartTimerTime", size_of::<RestartTimerTimeEvent>()),
24500 ("WinLimitChanged", size_of::<WinLimitChangedEvent>()),
24501 ("WinPanelShowScores", size_of::<WinPanelShowScoresEvent>()),
24502 (
24503 "TopStreamsRequestFinished",
24504 size_of::<TopStreamsRequestFinishedEvent>(),
24505 ),
24506 (
24507 "CompetitiveStateChanged",
24508 size_of::<CompetitiveStateChangedEvent>(),
24509 ),
24510 (
24511 "GlobalWarDataUpdated",
24512 size_of::<GlobalWarDataUpdatedEvent>(),
24513 ),
24514 ("StopWatchChanged", size_of::<StopWatchChangedEvent>()),
24515 ("DsStop", size_of::<DsStopEvent>()),
24516 ("DsScreenshot", size_of::<DsScreenshotEvent>()),
24517 ("ShowMatchSummary", size_of::<ShowMatchSummaryEvent>()),
24518 ("ExperienceChanged", size_of::<ExperienceChangedEvent>()),
24519 ("BeginXpLerp", size_of::<BeginXpLerpEvent>()),
24520 (
24521 "MatchmakerStatsUpdated",
24522 size_of::<MatchmakerStatsUpdatedEvent>(),
24523 ),
24524 (
24525 "RematchVotePeriodOver",
24526 size_of::<RematchVotePeriodOverEvent>(),
24527 ),
24528 (
24529 "RematchFailedToCreate",
24530 size_of::<RematchFailedToCreateEvent>(),
24531 ),
24532 ("PlayerRematchChange", size_of::<PlayerRematchChangeEvent>()),
24533 ("PingUpdated", size_of::<PingUpdatedEvent>()),
24534 ("MMStatsUpdated", size_of::<MMStatsUpdatedEvent>()),
24535 (
24536 "PlayerNextMapVoteChange",
24537 size_of::<PlayerNextMapVoteChangeEvent>(),
24538 ),
24539 ("VoteMapsChanged", size_of::<VoteMapsChangedEvent>()),
24540 ("ProtoDefChanged", size_of::<ProtoDefChangedEvent>()),
24541 ("PlayerDomination", size_of::<PlayerDominationEvent>()),
24542 (
24543 "PlayerRocketPackPushed",
24544 size_of::<PlayerRocketPackPushedEvent>(),
24545 ),
24546 ("QuestRequest", size_of::<QuestRequestEvent>()),
24547 ("QuestResponse", size_of::<QuestResponseEvent>()),
24548 ("QuestProgress", size_of::<QuestProgressEvent>()),
24549 ("ProjectileRemoved", size_of::<ProjectileRemovedEvent>()),
24550 ("QuestMapDataChanged", size_of::<QuestMapDataChangedEvent>()),
24551 (
24552 "GasDousedPlayerIgnited",
24553 size_of::<GasDousedPlayerIgnitedEvent>(),
24554 ),
24555 ("QuestTurnInState", size_of::<QuestTurnInStateEvent>()),
24556 ("ItemsAcknowledged", size_of::<ItemsAcknowledgedEvent>()),
24557 ("CapperKilled", size_of::<CapperKilledEvent>()),
24558 ("MainMenuStabilized", size_of::<MainMenuStabilizedEvent>()),
24559 ("WorldStatusChanged", size_of::<WorldStatusChangedEvent>()),
24560 ("HLTVStatus", size_of::<HLTVStatusEvent>()),
24561 ("HLTVCameraman", size_of::<HLTVCameramanEvent>()),
24562 ("HLTVRankCamera", size_of::<HLTVRankCameraEvent>()),
24563 ("HLTVRankEntity", size_of::<HLTVRankEntityEvent>()),
24564 ("HLTVFixed", size_of::<HLTVFixedEvent>()),
24565 ("HLTVChase", size_of::<HLTVChaseEvent>()),
24566 ("HLTVMessage", size_of::<HLTVMessageEvent>()),
24567 ("HLTVTitle", size_of::<HLTVTitleEvent>()),
24568 ("HLTVChat", size_of::<HLTVChatEvent>()),
24569 ("ReplayStartRecord", size_of::<ReplayStartRecordEvent>()),
24570 ("ReplaySessionInfo", size_of::<ReplaySessionInfoEvent>()),
24571 ("ReplayEndRecord", size_of::<ReplayEndRecordEvent>()),
24572 (
24573 "ReplayReplaysAvailable",
24574 size_of::<ReplayReplaysAvailableEvent>(),
24575 ),
24576 ("ReplayServerError", size_of::<ReplayServerErrorEvent>()),
24577 ]
24578 .iter()
24579 .copied()
24580 .collect()
24581}