1#![allow(dead_code)]
4#![allow(unused_imports)]
5
6pub mod rlbot {
7 #![allow(dead_code)]
8 #![allow(unused_imports)]
9
10 use std::{cmp::Ordering, mem};
11
12 use self::flatbuffers::EndianScalar;
13 use flatbuffers;
14 pub mod flat {
15 #![allow(dead_code)]
16 #![allow(unused_imports)]
17
18 use std::{cmp::Ordering, mem};
19
20 use self::flatbuffers::EndianScalar;
21 use flatbuffers;
22
23 #[allow(non_camel_case_types)]
24 #[repr(i8)]
25 #[derive(Clone, Copy, PartialEq, Debug)]
26 pub enum TileState {
27 Unknown = 0,
28 Filled = 1,
30 Damaged = 2,
32 Open = 3,
34 }
35
36 const ENUM_MIN_TILE_STATE: i8 = 0;
37 const ENUM_MAX_TILE_STATE: i8 = 3;
38
39 impl<'a> flatbuffers::Follow<'a> for TileState {
40 type Inner = Self;
41 #[inline]
42 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
43 flatbuffers::read_scalar_at::<Self>(buf, loc)
44 }
45 }
46
47 impl flatbuffers::EndianScalar for TileState {
48 #[inline]
49 fn to_little_endian(self) -> Self {
50 let n = i8::to_le(self as i8);
51 let p = &n as *const i8 as *const TileState;
52 unsafe { *p }
53 }
54 #[inline]
55 fn from_little_endian(self) -> Self {
56 let n = i8::from_le(self as i8);
57 let p = &n as *const i8 as *const TileState;
58 unsafe { *p }
59 }
60 }
61
62 impl flatbuffers::Push for TileState {
63 type Output = TileState;
64 #[inline]
65 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
66 flatbuffers::emplace_scalar::<TileState>(dst, *self);
67 }
68 }
69
70 #[allow(non_camel_case_types)]
71 const ENUM_VALUES_TILE_STATE: [TileState; 4] = [
72 TileState::Unknown,
73 TileState::Filled,
74 TileState::Damaged,
75 TileState::Open,
76 ];
77
78 #[allow(non_camel_case_types)]
79 const ENUM_NAMES_TILE_STATE: [&'static str; 4] = ["Unknown", "Filled", "Damaged", "Open"];
80
81 pub fn enum_name_tile_state(e: TileState) -> &'static str {
82 let index: usize = e as usize;
83 ENUM_NAMES_TILE_STATE[index]
84 }
85
86 #[allow(non_camel_case_types)]
87 #[repr(i8)]
88 #[derive(Clone, Copy, PartialEq, Debug)]
89 pub enum RenderType {
90 DrawLine2D = 1,
91 DrawLine3D = 2,
92 DrawLine2D_3D = 3,
93 DrawRect2D = 4,
94 DrawRect3D = 5,
95 DrawString2D = 6,
96 DrawString3D = 7,
97 DrawCenteredRect3D = 8,
98 }
99
100 const ENUM_MIN_RENDER_TYPE: i8 = 1;
101 const ENUM_MAX_RENDER_TYPE: i8 = 8;
102
103 impl<'a> flatbuffers::Follow<'a> for RenderType {
104 type Inner = Self;
105 #[inline]
106 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
107 flatbuffers::read_scalar_at::<Self>(buf, loc)
108 }
109 }
110
111 impl flatbuffers::EndianScalar for RenderType {
112 #[inline]
113 fn to_little_endian(self) -> Self {
114 let n = i8::to_le(self as i8);
115 let p = &n as *const i8 as *const RenderType;
116 unsafe { *p }
117 }
118 #[inline]
119 fn from_little_endian(self) -> Self {
120 let n = i8::from_le(self as i8);
121 let p = &n as *const i8 as *const RenderType;
122 unsafe { *p }
123 }
124 }
125
126 impl flatbuffers::Push for RenderType {
127 type Output = RenderType;
128 #[inline]
129 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
130 flatbuffers::emplace_scalar::<RenderType>(dst, *self);
131 }
132 }
133
134 #[allow(non_camel_case_types)]
135 const ENUM_VALUES_RENDER_TYPE: [RenderType; 8] = [
136 RenderType::DrawLine2D,
137 RenderType::DrawLine3D,
138 RenderType::DrawLine2D_3D,
139 RenderType::DrawRect2D,
140 RenderType::DrawRect3D,
141 RenderType::DrawString2D,
142 RenderType::DrawString3D,
143 RenderType::DrawCenteredRect3D,
144 ];
145
146 #[allow(non_camel_case_types)]
147 const ENUM_NAMES_RENDER_TYPE: [&'static str; 8] = [
148 "DrawLine2D",
149 "DrawLine3D",
150 "DrawLine2D_3D",
151 "DrawRect2D",
152 "DrawRect3D",
153 "DrawString2D",
154 "DrawString3D",
155 "DrawCenteredRect3D",
156 ];
157
158 pub fn enum_name_render_type(e: RenderType) -> &'static str {
159 let index: usize = e as usize - RenderType::DrawLine2D as usize;
160 ENUM_NAMES_RENDER_TYPE[index]
161 }
162
163 #[allow(non_camel_case_types)]
164 #[repr(i8)]
165 #[derive(Clone, Copy, PartialEq, Debug)]
166 pub enum QuickChatSelection {
167 Information_IGotIt = 0,
168 Information_NeedBoost = 1,
169 Information_TakeTheShot = 2,
170 Information_Defending = 3,
171 Information_GoForIt = 4,
172 Information_Centering = 5,
173 Information_AllYours = 6,
174 Information_InPosition = 7,
175 Information_Incoming = 8,
176 Compliments_NiceShot = 9,
177 Compliments_GreatPass = 10,
178 Compliments_Thanks = 11,
179 Compliments_WhatASave = 12,
180 Compliments_NiceOne = 13,
181 Compliments_WhatAPlay = 14,
182 Compliments_GreatClear = 15,
183 Compliments_NiceBlock = 16,
184 Reactions_OMG = 17,
185 Reactions_Noooo = 18,
186 Reactions_Wow = 19,
187 Reactions_CloseOne = 20,
188 Reactions_NoWay = 21,
189 Reactions_HolyCow = 22,
190 Reactions_Whew = 23,
191 Reactions_Siiiick = 24,
192 Reactions_Calculated = 25,
193 Reactions_Savage = 26,
194 Reactions_Okay = 27,
195 Apologies_Cursing = 28,
196 Apologies_NoProblem = 29,
197 Apologies_Whoops = 30,
198 Apologies_Sorry = 31,
199 Apologies_MyBad = 32,
200 Apologies_Oops = 33,
201 Apologies_MyFault = 34,
202 PostGame_Gg = 35,
203 PostGame_WellPlayed = 36,
204 PostGame_ThatWasFun = 37,
205 PostGame_Rematch = 38,
206 PostGame_OneMoreGame = 39,
207 PostGame_WhatAGame = 40,
208 PostGame_NiceMoves = 41,
209 PostGame_EverybodyDance = 42,
210 MaxPysonixQuickChatPresets = 43,
212 Custom_Toxic_WasteCPU = 44,
214 Custom_Toxic_GitGut = 45,
216 Custom_Toxic_DeAlloc = 46,
218 Custom_Toxic_404NoSkill = 47,
220 Custom_Toxic_CatchVirus = 48,
222 Custom_Useful_Passing = 49,
224 Custom_Useful_Faking = 50,
226 Custom_Useful_Demoing = 51,
228 Custom_Useful_Bumping = 52,
230 Custom_Compliments_TinyChances = 53,
232 Custom_Compliments_SkillLevel = 54,
234 Custom_Compliments_proud = 55,
236 Custom_Compliments_GC = 56,
238 Custom_Compliments_Pro = 57,
240 }
241
242 const ENUM_MIN_QUICK_CHAT_SELECTION: i8 = 0;
243 const ENUM_MAX_QUICK_CHAT_SELECTION: i8 = 57;
244
245 impl<'a> flatbuffers::Follow<'a> for QuickChatSelection {
246 type Inner = Self;
247 #[inline]
248 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
249 flatbuffers::read_scalar_at::<Self>(buf, loc)
250 }
251 }
252
253 impl flatbuffers::EndianScalar for QuickChatSelection {
254 #[inline]
255 fn to_little_endian(self) -> Self {
256 let n = i8::to_le(self as i8);
257 let p = &n as *const i8 as *const QuickChatSelection;
258 unsafe { *p }
259 }
260 #[inline]
261 fn from_little_endian(self) -> Self {
262 let n = i8::from_le(self as i8);
263 let p = &n as *const i8 as *const QuickChatSelection;
264 unsafe { *p }
265 }
266 }
267
268 impl flatbuffers::Push for QuickChatSelection {
269 type Output = QuickChatSelection;
270 #[inline]
271 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
272 flatbuffers::emplace_scalar::<QuickChatSelection>(dst, *self);
273 }
274 }
275
276 #[allow(non_camel_case_types)]
277 const ENUM_VALUES_QUICK_CHAT_SELECTION: [QuickChatSelection; 58] = [
278 QuickChatSelection::Information_IGotIt,
279 QuickChatSelection::Information_NeedBoost,
280 QuickChatSelection::Information_TakeTheShot,
281 QuickChatSelection::Information_Defending,
282 QuickChatSelection::Information_GoForIt,
283 QuickChatSelection::Information_Centering,
284 QuickChatSelection::Information_AllYours,
285 QuickChatSelection::Information_InPosition,
286 QuickChatSelection::Information_Incoming,
287 QuickChatSelection::Compliments_NiceShot,
288 QuickChatSelection::Compliments_GreatPass,
289 QuickChatSelection::Compliments_Thanks,
290 QuickChatSelection::Compliments_WhatASave,
291 QuickChatSelection::Compliments_NiceOne,
292 QuickChatSelection::Compliments_WhatAPlay,
293 QuickChatSelection::Compliments_GreatClear,
294 QuickChatSelection::Compliments_NiceBlock,
295 QuickChatSelection::Reactions_OMG,
296 QuickChatSelection::Reactions_Noooo,
297 QuickChatSelection::Reactions_Wow,
298 QuickChatSelection::Reactions_CloseOne,
299 QuickChatSelection::Reactions_NoWay,
300 QuickChatSelection::Reactions_HolyCow,
301 QuickChatSelection::Reactions_Whew,
302 QuickChatSelection::Reactions_Siiiick,
303 QuickChatSelection::Reactions_Calculated,
304 QuickChatSelection::Reactions_Savage,
305 QuickChatSelection::Reactions_Okay,
306 QuickChatSelection::Apologies_Cursing,
307 QuickChatSelection::Apologies_NoProblem,
308 QuickChatSelection::Apologies_Whoops,
309 QuickChatSelection::Apologies_Sorry,
310 QuickChatSelection::Apologies_MyBad,
311 QuickChatSelection::Apologies_Oops,
312 QuickChatSelection::Apologies_MyFault,
313 QuickChatSelection::PostGame_Gg,
314 QuickChatSelection::PostGame_WellPlayed,
315 QuickChatSelection::PostGame_ThatWasFun,
316 QuickChatSelection::PostGame_Rematch,
317 QuickChatSelection::PostGame_OneMoreGame,
318 QuickChatSelection::PostGame_WhatAGame,
319 QuickChatSelection::PostGame_NiceMoves,
320 QuickChatSelection::PostGame_EverybodyDance,
321 QuickChatSelection::MaxPysonixQuickChatPresets,
322 QuickChatSelection::Custom_Toxic_WasteCPU,
323 QuickChatSelection::Custom_Toxic_GitGut,
324 QuickChatSelection::Custom_Toxic_DeAlloc,
325 QuickChatSelection::Custom_Toxic_404NoSkill,
326 QuickChatSelection::Custom_Toxic_CatchVirus,
327 QuickChatSelection::Custom_Useful_Passing,
328 QuickChatSelection::Custom_Useful_Faking,
329 QuickChatSelection::Custom_Useful_Demoing,
330 QuickChatSelection::Custom_Useful_Bumping,
331 QuickChatSelection::Custom_Compliments_TinyChances,
332 QuickChatSelection::Custom_Compliments_SkillLevel,
333 QuickChatSelection::Custom_Compliments_proud,
334 QuickChatSelection::Custom_Compliments_GC,
335 QuickChatSelection::Custom_Compliments_Pro,
336 ];
337
338 #[allow(non_camel_case_types)]
339 const ENUM_NAMES_QUICK_CHAT_SELECTION: [&'static str; 58] = [
340 "Information_IGotIt",
341 "Information_NeedBoost",
342 "Information_TakeTheShot",
343 "Information_Defending",
344 "Information_GoForIt",
345 "Information_Centering",
346 "Information_AllYours",
347 "Information_InPosition",
348 "Information_Incoming",
349 "Compliments_NiceShot",
350 "Compliments_GreatPass",
351 "Compliments_Thanks",
352 "Compliments_WhatASave",
353 "Compliments_NiceOne",
354 "Compliments_WhatAPlay",
355 "Compliments_GreatClear",
356 "Compliments_NiceBlock",
357 "Reactions_OMG",
358 "Reactions_Noooo",
359 "Reactions_Wow",
360 "Reactions_CloseOne",
361 "Reactions_NoWay",
362 "Reactions_HolyCow",
363 "Reactions_Whew",
364 "Reactions_Siiiick",
365 "Reactions_Calculated",
366 "Reactions_Savage",
367 "Reactions_Okay",
368 "Apologies_Cursing",
369 "Apologies_NoProblem",
370 "Apologies_Whoops",
371 "Apologies_Sorry",
372 "Apologies_MyBad",
373 "Apologies_Oops",
374 "Apologies_MyFault",
375 "PostGame_Gg",
376 "PostGame_WellPlayed",
377 "PostGame_ThatWasFun",
378 "PostGame_Rematch",
379 "PostGame_OneMoreGame",
380 "PostGame_WhatAGame",
381 "PostGame_NiceMoves",
382 "PostGame_EverybodyDance",
383 "MaxPysonixQuickChatPresets",
384 "Custom_Toxic_WasteCPU",
385 "Custom_Toxic_GitGut",
386 "Custom_Toxic_DeAlloc",
387 "Custom_Toxic_404NoSkill",
388 "Custom_Toxic_CatchVirus",
389 "Custom_Useful_Passing",
390 "Custom_Useful_Faking",
391 "Custom_Useful_Demoing",
392 "Custom_Useful_Bumping",
393 "Custom_Compliments_TinyChances",
394 "Custom_Compliments_SkillLevel",
395 "Custom_Compliments_proud",
396 "Custom_Compliments_GC",
397 "Custom_Compliments_Pro",
398 ];
399
400 pub fn enum_name_quick_chat_selection(e: QuickChatSelection) -> &'static str {
401 let index: usize = e as usize;
402 ENUM_NAMES_QUICK_CHAT_SELECTION[index]
403 }
404
405 #[allow(non_camel_case_types)]
406 #[repr(u8)]
407 #[derive(Clone, Copy, PartialEq, Debug)]
408 pub enum PlayerClass {
409 NONE = 0,
410 RLBotPlayer = 1,
411 HumanPlayer = 2,
412 PsyonixBotPlayer = 3,
413 PartyMemberBotPlayer = 4,
414 }
415
416 const ENUM_MIN_PLAYER_CLASS: u8 = 0;
417 const ENUM_MAX_PLAYER_CLASS: u8 = 4;
418
419 impl<'a> flatbuffers::Follow<'a> for PlayerClass {
420 type Inner = Self;
421 #[inline]
422 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
423 flatbuffers::read_scalar_at::<Self>(buf, loc)
424 }
425 }
426
427 impl flatbuffers::EndianScalar for PlayerClass {
428 #[inline]
429 fn to_little_endian(self) -> Self {
430 let n = u8::to_le(self as u8);
431 let p = &n as *const u8 as *const PlayerClass;
432 unsafe { *p }
433 }
434 #[inline]
435 fn from_little_endian(self) -> Self {
436 let n = u8::from_le(self as u8);
437 let p = &n as *const u8 as *const PlayerClass;
438 unsafe { *p }
439 }
440 }
441
442 impl flatbuffers::Push for PlayerClass {
443 type Output = PlayerClass;
444 #[inline]
445 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
446 flatbuffers::emplace_scalar::<PlayerClass>(dst, *self);
447 }
448 }
449
450 #[allow(non_camel_case_types)]
451 const ENUM_VALUES_PLAYER_CLASS: [PlayerClass; 5] = [
452 PlayerClass::NONE,
453 PlayerClass::RLBotPlayer,
454 PlayerClass::HumanPlayer,
455 PlayerClass::PsyonixBotPlayer,
456 PlayerClass::PartyMemberBotPlayer,
457 ];
458
459 #[allow(non_camel_case_types)]
460 const ENUM_NAMES_PLAYER_CLASS: [&'static str; 5] = [
461 "NONE",
462 "RLBotPlayer",
463 "HumanPlayer",
464 "PsyonixBotPlayer",
465 "PartyMemberBotPlayer",
466 ];
467
468 pub fn enum_name_player_class(e: PlayerClass) -> &'static str {
469 let index: usize = e as usize;
470 ENUM_NAMES_PLAYER_CLASS[index]
471 }
472
473 pub struct PlayerClassUnionTableOffset {}
474 #[allow(non_camel_case_types)]
475 #[repr(i8)]
476 #[derive(Clone, Copy, PartialEq, Debug)]
477 pub enum GameMode {
478 Soccer = 0,
479 Hoops = 1,
480 Dropshot = 2,
481 Hockey = 3,
482 Rumble = 4,
483 }
484
485 const ENUM_MIN_GAME_MODE: i8 = 0;
486 const ENUM_MAX_GAME_MODE: i8 = 4;
487
488 impl<'a> flatbuffers::Follow<'a> for GameMode {
489 type Inner = Self;
490 #[inline]
491 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
492 flatbuffers::read_scalar_at::<Self>(buf, loc)
493 }
494 }
495
496 impl flatbuffers::EndianScalar for GameMode {
497 #[inline]
498 fn to_little_endian(self) -> Self {
499 let n = i8::to_le(self as i8);
500 let p = &n as *const i8 as *const GameMode;
501 unsafe { *p }
502 }
503 #[inline]
504 fn from_little_endian(self) -> Self {
505 let n = i8::from_le(self as i8);
506 let p = &n as *const i8 as *const GameMode;
507 unsafe { *p }
508 }
509 }
510
511 impl flatbuffers::Push for GameMode {
512 type Output = GameMode;
513 #[inline]
514 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
515 flatbuffers::emplace_scalar::<GameMode>(dst, *self);
516 }
517 }
518
519 #[allow(non_camel_case_types)]
520 const ENUM_VALUES_GAME_MODE: [GameMode; 5] = [
521 GameMode::Soccer,
522 GameMode::Hoops,
523 GameMode::Dropshot,
524 GameMode::Hockey,
525 GameMode::Rumble,
526 ];
527
528 #[allow(non_camel_case_types)]
529 const ENUM_NAMES_GAME_MODE: [&'static str; 5] =
530 ["Soccer", "Hoops", "Dropshot", "Hockey", "Rumble"];
531
532 pub fn enum_name_game_mode(e: GameMode) -> &'static str {
533 let index: usize = e as usize;
534 ENUM_NAMES_GAME_MODE[index]
535 }
536
537 #[allow(non_camel_case_types)]
538 #[repr(i8)]
539 #[derive(Clone, Copy, PartialEq, Debug)]
540 pub enum GameMap {
541 DFHStadium = 0,
542 Mannfield = 1,
543 ChampionsField = 2,
544 UrbanCentral = 3,
545 BeckwithPark = 4,
546 UtopiaColiseum = 5,
547 Wasteland = 6,
548 NeoTokyo = 7,
549 AquaDome = 8,
550 StarbaseArc = 9,
551 Farmstead = 10,
552 SaltyShores = 11,
553 DFHStadium_Stormy = 12,
554 DFHStadium_Day = 13,
555 Mannfield_Stormy = 14,
556 Mannfield_Night = 15,
557 ChampionsField_Day = 16,
558 BeckwithPark_Stormy = 17,
559 BeckwithPark_Midnight = 18,
560 UrbanCentral_Night = 19,
561 UrbanCentral_Dawn = 20,
562 UtopiaColiseum_Dusk = 21,
563 DFHStadium_Snowy = 22,
564 Mannfield_Snowy = 23,
565 UtopiaColiseum_Snowy = 24,
566 Badlands = 25,
567 Badlands_Night = 26,
568 TokyoUnderpass = 27,
569 Arctagon = 28,
570 Pillars = 29,
571 Cosmic = 30,
572 DoubleGoal = 31,
573 Octagon = 32,
574 Underpass = 33,
575 UtopiaRetro = 34,
576 Hoops_DunkHouse = 35,
577 DropShot_Core707 = 36,
578 ThrowbackStadium = 37,
579 }
580
581 const ENUM_MIN_GAME_MAP: i8 = 0;
582 const ENUM_MAX_GAME_MAP: i8 = 37;
583
584 impl<'a> flatbuffers::Follow<'a> for GameMap {
585 type Inner = Self;
586 #[inline]
587 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
588 flatbuffers::read_scalar_at::<Self>(buf, loc)
589 }
590 }
591
592 impl flatbuffers::EndianScalar for GameMap {
593 #[inline]
594 fn to_little_endian(self) -> Self {
595 let n = i8::to_le(self as i8);
596 let p = &n as *const i8 as *const GameMap;
597 unsafe { *p }
598 }
599 #[inline]
600 fn from_little_endian(self) -> Self {
601 let n = i8::from_le(self as i8);
602 let p = &n as *const i8 as *const GameMap;
603 unsafe { *p }
604 }
605 }
606
607 impl flatbuffers::Push for GameMap {
608 type Output = GameMap;
609 #[inline]
610 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
611 flatbuffers::emplace_scalar::<GameMap>(dst, *self);
612 }
613 }
614
615 #[allow(non_camel_case_types)]
616 const ENUM_VALUES_GAME_MAP: [GameMap; 38] = [
617 GameMap::DFHStadium,
618 GameMap::Mannfield,
619 GameMap::ChampionsField,
620 GameMap::UrbanCentral,
621 GameMap::BeckwithPark,
622 GameMap::UtopiaColiseum,
623 GameMap::Wasteland,
624 GameMap::NeoTokyo,
625 GameMap::AquaDome,
626 GameMap::StarbaseArc,
627 GameMap::Farmstead,
628 GameMap::SaltyShores,
629 GameMap::DFHStadium_Stormy,
630 GameMap::DFHStadium_Day,
631 GameMap::Mannfield_Stormy,
632 GameMap::Mannfield_Night,
633 GameMap::ChampionsField_Day,
634 GameMap::BeckwithPark_Stormy,
635 GameMap::BeckwithPark_Midnight,
636 GameMap::UrbanCentral_Night,
637 GameMap::UrbanCentral_Dawn,
638 GameMap::UtopiaColiseum_Dusk,
639 GameMap::DFHStadium_Snowy,
640 GameMap::Mannfield_Snowy,
641 GameMap::UtopiaColiseum_Snowy,
642 GameMap::Badlands,
643 GameMap::Badlands_Night,
644 GameMap::TokyoUnderpass,
645 GameMap::Arctagon,
646 GameMap::Pillars,
647 GameMap::Cosmic,
648 GameMap::DoubleGoal,
649 GameMap::Octagon,
650 GameMap::Underpass,
651 GameMap::UtopiaRetro,
652 GameMap::Hoops_DunkHouse,
653 GameMap::DropShot_Core707,
654 GameMap::ThrowbackStadium,
655 ];
656
657 #[allow(non_camel_case_types)]
658 const ENUM_NAMES_GAME_MAP: [&'static str; 38] = [
659 "DFHStadium",
660 "Mannfield",
661 "ChampionsField",
662 "UrbanCentral",
663 "BeckwithPark",
664 "UtopiaColiseum",
665 "Wasteland",
666 "NeoTokyo",
667 "AquaDome",
668 "StarbaseArc",
669 "Farmstead",
670 "SaltyShores",
671 "DFHStadium_Stormy",
672 "DFHStadium_Day",
673 "Mannfield_Stormy",
674 "Mannfield_Night",
675 "ChampionsField_Day",
676 "BeckwithPark_Stormy",
677 "BeckwithPark_Midnight",
678 "UrbanCentral_Night",
679 "UrbanCentral_Dawn",
680 "UtopiaColiseum_Dusk",
681 "DFHStadium_Snowy",
682 "Mannfield_Snowy",
683 "UtopiaColiseum_Snowy",
684 "Badlands",
685 "Badlands_Night",
686 "TokyoUnderpass",
687 "Arctagon",
688 "Pillars",
689 "Cosmic",
690 "DoubleGoal",
691 "Octagon",
692 "Underpass",
693 "UtopiaRetro",
694 "Hoops_DunkHouse",
695 "DropShot_Core707",
696 "ThrowbackStadium",
697 ];
698
699 pub fn enum_name_game_map(e: GameMap) -> &'static str {
700 let index: usize = e as usize;
701 ENUM_NAMES_GAME_MAP[index]
702 }
703
704 #[allow(non_camel_case_types)]
705 #[repr(i8)]
706 #[derive(Clone, Copy, PartialEq, Debug)]
707 pub enum MatchLength {
708 Five_Minutes = 0,
709 Ten_Minutes = 1,
710 Twenty_Minutes = 2,
711 Unlimited = 3,
712 }
713
714 const ENUM_MIN_MATCH_LENGTH: i8 = 0;
715 const ENUM_MAX_MATCH_LENGTH: i8 = 3;
716
717 impl<'a> flatbuffers::Follow<'a> for MatchLength {
718 type Inner = Self;
719 #[inline]
720 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
721 flatbuffers::read_scalar_at::<Self>(buf, loc)
722 }
723 }
724
725 impl flatbuffers::EndianScalar for MatchLength {
726 #[inline]
727 fn to_little_endian(self) -> Self {
728 let n = i8::to_le(self as i8);
729 let p = &n as *const i8 as *const MatchLength;
730 unsafe { *p }
731 }
732 #[inline]
733 fn from_little_endian(self) -> Self {
734 let n = i8::from_le(self as i8);
735 let p = &n as *const i8 as *const MatchLength;
736 unsafe { *p }
737 }
738 }
739
740 impl flatbuffers::Push for MatchLength {
741 type Output = MatchLength;
742 #[inline]
743 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
744 flatbuffers::emplace_scalar::<MatchLength>(dst, *self);
745 }
746 }
747
748 #[allow(non_camel_case_types)]
749 const ENUM_VALUES_MATCH_LENGTH: [MatchLength; 4] = [
750 MatchLength::Five_Minutes,
751 MatchLength::Ten_Minutes,
752 MatchLength::Twenty_Minutes,
753 MatchLength::Unlimited,
754 ];
755
756 #[allow(non_camel_case_types)]
757 const ENUM_NAMES_MATCH_LENGTH: [&'static str; 4] =
758 ["Five_Minutes", "Ten_Minutes", "Twenty_Minutes", "Unlimited"];
759
760 pub fn enum_name_match_length(e: MatchLength) -> &'static str {
761 let index: usize = e as usize;
762 ENUM_NAMES_MATCH_LENGTH[index]
763 }
764
765 #[allow(non_camel_case_types)]
766 #[repr(i8)]
767 #[derive(Clone, Copy, PartialEq, Debug)]
768 pub enum MaxScore {
769 Unlimited = 0,
770 One_Goal = 1,
771 Three_Goals = 2,
772 Five_Goals = 3,
773 }
774
775 const ENUM_MIN_MAX_SCORE: i8 = 0;
776 const ENUM_MAX_MAX_SCORE: i8 = 3;
777
778 impl<'a> flatbuffers::Follow<'a> for MaxScore {
779 type Inner = Self;
780 #[inline]
781 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
782 flatbuffers::read_scalar_at::<Self>(buf, loc)
783 }
784 }
785
786 impl flatbuffers::EndianScalar for MaxScore {
787 #[inline]
788 fn to_little_endian(self) -> Self {
789 let n = i8::to_le(self as i8);
790 let p = &n as *const i8 as *const MaxScore;
791 unsafe { *p }
792 }
793 #[inline]
794 fn from_little_endian(self) -> Self {
795 let n = i8::from_le(self as i8);
796 let p = &n as *const i8 as *const MaxScore;
797 unsafe { *p }
798 }
799 }
800
801 impl flatbuffers::Push for MaxScore {
802 type Output = MaxScore;
803 #[inline]
804 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
805 flatbuffers::emplace_scalar::<MaxScore>(dst, *self);
806 }
807 }
808
809 #[allow(non_camel_case_types)]
810 const ENUM_VALUES_MAX_SCORE: [MaxScore; 4] = [
811 MaxScore::Unlimited,
812 MaxScore::One_Goal,
813 MaxScore::Three_Goals,
814 MaxScore::Five_Goals,
815 ];
816
817 #[allow(non_camel_case_types)]
818 const ENUM_NAMES_MAX_SCORE: [&'static str; 4] =
819 ["Unlimited", "One_Goal", "Three_Goals", "Five_Goals"];
820
821 pub fn enum_name_max_score(e: MaxScore) -> &'static str {
822 let index: usize = e as usize;
823 ENUM_NAMES_MAX_SCORE[index]
824 }
825
826 #[allow(non_camel_case_types)]
827 #[repr(i8)]
828 #[derive(Clone, Copy, PartialEq, Debug)]
829 pub enum OvertimeOption {
830 Unlimited = 0,
831 Five_Max_First_Score = 1,
832 Five_Max_Random_Team = 2,
833 }
834
835 const ENUM_MIN_OVERTIME_OPTION: i8 = 0;
836 const ENUM_MAX_OVERTIME_OPTION: i8 = 2;
837
838 impl<'a> flatbuffers::Follow<'a> for OvertimeOption {
839 type Inner = Self;
840 #[inline]
841 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
842 flatbuffers::read_scalar_at::<Self>(buf, loc)
843 }
844 }
845
846 impl flatbuffers::EndianScalar for OvertimeOption {
847 #[inline]
848 fn to_little_endian(self) -> Self {
849 let n = i8::to_le(self as i8);
850 let p = &n as *const i8 as *const OvertimeOption;
851 unsafe { *p }
852 }
853 #[inline]
854 fn from_little_endian(self) -> Self {
855 let n = i8::from_le(self as i8);
856 let p = &n as *const i8 as *const OvertimeOption;
857 unsafe { *p }
858 }
859 }
860
861 impl flatbuffers::Push for OvertimeOption {
862 type Output = OvertimeOption;
863 #[inline]
864 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
865 flatbuffers::emplace_scalar::<OvertimeOption>(dst, *self);
866 }
867 }
868
869 #[allow(non_camel_case_types)]
870 const ENUM_VALUES_OVERTIME_OPTION: [OvertimeOption; 3] = [
871 OvertimeOption::Unlimited,
872 OvertimeOption::Five_Max_First_Score,
873 OvertimeOption::Five_Max_Random_Team,
874 ];
875
876 #[allow(non_camel_case_types)]
877 const ENUM_NAMES_OVERTIME_OPTION: [&'static str; 3] =
878 ["Unlimited", "Five_Max_First_Score", "Five_Max_Random_Team"];
879
880 pub fn enum_name_overtime_option(e: OvertimeOption) -> &'static str {
881 let index: usize = e as usize;
882 ENUM_NAMES_OVERTIME_OPTION[index]
883 }
884
885 #[allow(non_camel_case_types)]
886 #[repr(i8)]
887 #[derive(Clone, Copy, PartialEq, Debug)]
888 pub enum SeriesLengthOption {
889 Unlimited = 0,
890 Three_Games = 1,
891 Five_Games = 2,
892 Seven_Games = 3,
893 }
894
895 const ENUM_MIN_SERIES_LENGTH_OPTION: i8 = 0;
896 const ENUM_MAX_SERIES_LENGTH_OPTION: i8 = 3;
897
898 impl<'a> flatbuffers::Follow<'a> for SeriesLengthOption {
899 type Inner = Self;
900 #[inline]
901 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
902 flatbuffers::read_scalar_at::<Self>(buf, loc)
903 }
904 }
905
906 impl flatbuffers::EndianScalar for SeriesLengthOption {
907 #[inline]
908 fn to_little_endian(self) -> Self {
909 let n = i8::to_le(self as i8);
910 let p = &n as *const i8 as *const SeriesLengthOption;
911 unsafe { *p }
912 }
913 #[inline]
914 fn from_little_endian(self) -> Self {
915 let n = i8::from_le(self as i8);
916 let p = &n as *const i8 as *const SeriesLengthOption;
917 unsafe { *p }
918 }
919 }
920
921 impl flatbuffers::Push for SeriesLengthOption {
922 type Output = SeriesLengthOption;
923 #[inline]
924 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
925 flatbuffers::emplace_scalar::<SeriesLengthOption>(dst, *self);
926 }
927 }
928
929 #[allow(non_camel_case_types)]
930 const ENUM_VALUES_SERIES_LENGTH_OPTION: [SeriesLengthOption; 4] = [
931 SeriesLengthOption::Unlimited,
932 SeriesLengthOption::Three_Games,
933 SeriesLengthOption::Five_Games,
934 SeriesLengthOption::Seven_Games,
935 ];
936
937 #[allow(non_camel_case_types)]
938 const ENUM_NAMES_SERIES_LENGTH_OPTION: [&'static str; 4] =
939 ["Unlimited", "Three_Games", "Five_Games", "Seven_Games"];
940
941 pub fn enum_name_series_length_option(e: SeriesLengthOption) -> &'static str {
942 let index: usize = e as usize;
943 ENUM_NAMES_SERIES_LENGTH_OPTION[index]
944 }
945
946 #[allow(non_camel_case_types)]
947 #[repr(i8)]
948 #[derive(Clone, Copy, PartialEq, Debug)]
949 pub enum GameSpeedOption {
950 Default = 0,
951 Slo_Mo = 1,
952 Time_Warp = 2,
953 }
954
955 const ENUM_MIN_GAME_SPEED_OPTION: i8 = 0;
956 const ENUM_MAX_GAME_SPEED_OPTION: i8 = 2;
957
958 impl<'a> flatbuffers::Follow<'a> for GameSpeedOption {
959 type Inner = Self;
960 #[inline]
961 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
962 flatbuffers::read_scalar_at::<Self>(buf, loc)
963 }
964 }
965
966 impl flatbuffers::EndianScalar for GameSpeedOption {
967 #[inline]
968 fn to_little_endian(self) -> Self {
969 let n = i8::to_le(self as i8);
970 let p = &n as *const i8 as *const GameSpeedOption;
971 unsafe { *p }
972 }
973 #[inline]
974 fn from_little_endian(self) -> Self {
975 let n = i8::from_le(self as i8);
976 let p = &n as *const i8 as *const GameSpeedOption;
977 unsafe { *p }
978 }
979 }
980
981 impl flatbuffers::Push for GameSpeedOption {
982 type Output = GameSpeedOption;
983 #[inline]
984 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
985 flatbuffers::emplace_scalar::<GameSpeedOption>(dst, *self);
986 }
987 }
988
989 #[allow(non_camel_case_types)]
990 const ENUM_VALUES_GAME_SPEED_OPTION: [GameSpeedOption; 3] = [
991 GameSpeedOption::Default,
992 GameSpeedOption::Slo_Mo,
993 GameSpeedOption::Time_Warp,
994 ];
995
996 #[allow(non_camel_case_types)]
997 const ENUM_NAMES_GAME_SPEED_OPTION: [&'static str; 3] = ["Default", "Slo_Mo", "Time_Warp"];
998
999 pub fn enum_name_game_speed_option(e: GameSpeedOption) -> &'static str {
1000 let index: usize = e as usize;
1001 ENUM_NAMES_GAME_SPEED_OPTION[index]
1002 }
1003
1004 #[allow(non_camel_case_types)]
1005 #[repr(i8)]
1006 #[derive(Clone, Copy, PartialEq, Debug)]
1007 pub enum BallMaxSpeedOption {
1008 Default = 0,
1009 Slow = 1,
1010 Fast = 2,
1011 Super_Fast = 3,
1012 }
1013
1014 const ENUM_MIN_BALL_MAX_SPEED_OPTION: i8 = 0;
1015 const ENUM_MAX_BALL_MAX_SPEED_OPTION: i8 = 3;
1016
1017 impl<'a> flatbuffers::Follow<'a> for BallMaxSpeedOption {
1018 type Inner = Self;
1019 #[inline]
1020 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1021 flatbuffers::read_scalar_at::<Self>(buf, loc)
1022 }
1023 }
1024
1025 impl flatbuffers::EndianScalar for BallMaxSpeedOption {
1026 #[inline]
1027 fn to_little_endian(self) -> Self {
1028 let n = i8::to_le(self as i8);
1029 let p = &n as *const i8 as *const BallMaxSpeedOption;
1030 unsafe { *p }
1031 }
1032 #[inline]
1033 fn from_little_endian(self) -> Self {
1034 let n = i8::from_le(self as i8);
1035 let p = &n as *const i8 as *const BallMaxSpeedOption;
1036 unsafe { *p }
1037 }
1038 }
1039
1040 impl flatbuffers::Push for BallMaxSpeedOption {
1041 type Output = BallMaxSpeedOption;
1042 #[inline]
1043 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1044 flatbuffers::emplace_scalar::<BallMaxSpeedOption>(dst, *self);
1045 }
1046 }
1047
1048 #[allow(non_camel_case_types)]
1049 const ENUM_VALUES_BALL_MAX_SPEED_OPTION: [BallMaxSpeedOption; 4] = [
1050 BallMaxSpeedOption::Default,
1051 BallMaxSpeedOption::Slow,
1052 BallMaxSpeedOption::Fast,
1053 BallMaxSpeedOption::Super_Fast,
1054 ];
1055
1056 #[allow(non_camel_case_types)]
1057 const ENUM_NAMES_BALL_MAX_SPEED_OPTION: [&'static str; 4] =
1058 ["Default", "Slow", "Fast", "Super_Fast"];
1059
1060 pub fn enum_name_ball_max_speed_option(e: BallMaxSpeedOption) -> &'static str {
1061 let index: usize = e as usize;
1062 ENUM_NAMES_BALL_MAX_SPEED_OPTION[index]
1063 }
1064
1065 #[allow(non_camel_case_types)]
1066 #[repr(i8)]
1067 #[derive(Clone, Copy, PartialEq, Debug)]
1068 pub enum BallTypeOption {
1069 Default = 0,
1070 Cube = 1,
1071 Puck = 2,
1072 Basketball = 3,
1073 }
1074
1075 const ENUM_MIN_BALL_TYPE_OPTION: i8 = 0;
1076 const ENUM_MAX_BALL_TYPE_OPTION: i8 = 3;
1077
1078 impl<'a> flatbuffers::Follow<'a> for BallTypeOption {
1079 type Inner = Self;
1080 #[inline]
1081 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1082 flatbuffers::read_scalar_at::<Self>(buf, loc)
1083 }
1084 }
1085
1086 impl flatbuffers::EndianScalar for BallTypeOption {
1087 #[inline]
1088 fn to_little_endian(self) -> Self {
1089 let n = i8::to_le(self as i8);
1090 let p = &n as *const i8 as *const BallTypeOption;
1091 unsafe { *p }
1092 }
1093 #[inline]
1094 fn from_little_endian(self) -> Self {
1095 let n = i8::from_le(self as i8);
1096 let p = &n as *const i8 as *const BallTypeOption;
1097 unsafe { *p }
1098 }
1099 }
1100
1101 impl flatbuffers::Push for BallTypeOption {
1102 type Output = BallTypeOption;
1103 #[inline]
1104 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1105 flatbuffers::emplace_scalar::<BallTypeOption>(dst, *self);
1106 }
1107 }
1108
1109 #[allow(non_camel_case_types)]
1110 const ENUM_VALUES_BALL_TYPE_OPTION: [BallTypeOption; 4] = [
1111 BallTypeOption::Default,
1112 BallTypeOption::Cube,
1113 BallTypeOption::Puck,
1114 BallTypeOption::Basketball,
1115 ];
1116
1117 #[allow(non_camel_case_types)]
1118 const ENUM_NAMES_BALL_TYPE_OPTION: [&'static str; 4] =
1119 ["Default", "Cube", "Puck", "Basketball"];
1120
1121 pub fn enum_name_ball_type_option(e: BallTypeOption) -> &'static str {
1122 let index: usize = e as usize;
1123 ENUM_NAMES_BALL_TYPE_OPTION[index]
1124 }
1125
1126 #[allow(non_camel_case_types)]
1127 #[repr(i8)]
1128 #[derive(Clone, Copy, PartialEq, Debug)]
1129 pub enum BallWeightOption {
1130 Default = 0,
1131 Light = 1,
1132 Heavy = 2,
1133 Super_Light = 3,
1134 }
1135
1136 const ENUM_MIN_BALL_WEIGHT_OPTION: i8 = 0;
1137 const ENUM_MAX_BALL_WEIGHT_OPTION: i8 = 3;
1138
1139 impl<'a> flatbuffers::Follow<'a> for BallWeightOption {
1140 type Inner = Self;
1141 #[inline]
1142 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1143 flatbuffers::read_scalar_at::<Self>(buf, loc)
1144 }
1145 }
1146
1147 impl flatbuffers::EndianScalar for BallWeightOption {
1148 #[inline]
1149 fn to_little_endian(self) -> Self {
1150 let n = i8::to_le(self as i8);
1151 let p = &n as *const i8 as *const BallWeightOption;
1152 unsafe { *p }
1153 }
1154 #[inline]
1155 fn from_little_endian(self) -> Self {
1156 let n = i8::from_le(self as i8);
1157 let p = &n as *const i8 as *const BallWeightOption;
1158 unsafe { *p }
1159 }
1160 }
1161
1162 impl flatbuffers::Push for BallWeightOption {
1163 type Output = BallWeightOption;
1164 #[inline]
1165 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1166 flatbuffers::emplace_scalar::<BallWeightOption>(dst, *self);
1167 }
1168 }
1169
1170 #[allow(non_camel_case_types)]
1171 const ENUM_VALUES_BALL_WEIGHT_OPTION: [BallWeightOption; 4] = [
1172 BallWeightOption::Default,
1173 BallWeightOption::Light,
1174 BallWeightOption::Heavy,
1175 BallWeightOption::Super_Light,
1176 ];
1177
1178 #[allow(non_camel_case_types)]
1179 const ENUM_NAMES_BALL_WEIGHT_OPTION: [&'static str; 4] =
1180 ["Default", "Light", "Heavy", "Super_Light"];
1181
1182 pub fn enum_name_ball_weight_option(e: BallWeightOption) -> &'static str {
1183 let index: usize = e as usize;
1184 ENUM_NAMES_BALL_WEIGHT_OPTION[index]
1185 }
1186
1187 #[allow(non_camel_case_types)]
1188 #[repr(i8)]
1189 #[derive(Clone, Copy, PartialEq, Debug)]
1190 pub enum BallSizeOption {
1191 Default = 0,
1192 Small = 1,
1193 Large = 2,
1194 Gigantic = 3,
1195 }
1196
1197 const ENUM_MIN_BALL_SIZE_OPTION: i8 = 0;
1198 const ENUM_MAX_BALL_SIZE_OPTION: i8 = 3;
1199
1200 impl<'a> flatbuffers::Follow<'a> for BallSizeOption {
1201 type Inner = Self;
1202 #[inline]
1203 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1204 flatbuffers::read_scalar_at::<Self>(buf, loc)
1205 }
1206 }
1207
1208 impl flatbuffers::EndianScalar for BallSizeOption {
1209 #[inline]
1210 fn to_little_endian(self) -> Self {
1211 let n = i8::to_le(self as i8);
1212 let p = &n as *const i8 as *const BallSizeOption;
1213 unsafe { *p }
1214 }
1215 #[inline]
1216 fn from_little_endian(self) -> Self {
1217 let n = i8::from_le(self as i8);
1218 let p = &n as *const i8 as *const BallSizeOption;
1219 unsafe { *p }
1220 }
1221 }
1222
1223 impl flatbuffers::Push for BallSizeOption {
1224 type Output = BallSizeOption;
1225 #[inline]
1226 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1227 flatbuffers::emplace_scalar::<BallSizeOption>(dst, *self);
1228 }
1229 }
1230
1231 #[allow(non_camel_case_types)]
1232 const ENUM_VALUES_BALL_SIZE_OPTION: [BallSizeOption; 4] = [
1233 BallSizeOption::Default,
1234 BallSizeOption::Small,
1235 BallSizeOption::Large,
1236 BallSizeOption::Gigantic,
1237 ];
1238
1239 #[allow(non_camel_case_types)]
1240 const ENUM_NAMES_BALL_SIZE_OPTION: [&'static str; 4] =
1241 ["Default", "Small", "Large", "Gigantic"];
1242
1243 pub fn enum_name_ball_size_option(e: BallSizeOption) -> &'static str {
1244 let index: usize = e as usize;
1245 ENUM_NAMES_BALL_SIZE_OPTION[index]
1246 }
1247
1248 #[allow(non_camel_case_types)]
1249 #[repr(i8)]
1250 #[derive(Clone, Copy, PartialEq, Debug)]
1251 pub enum BallBouncinessOption {
1252 Default = 0,
1253 Low = 1,
1254 High = 2,
1255 Super_High = 3,
1256 }
1257
1258 const ENUM_MIN_BALL_BOUNCINESS_OPTION: i8 = 0;
1259 const ENUM_MAX_BALL_BOUNCINESS_OPTION: i8 = 3;
1260
1261 impl<'a> flatbuffers::Follow<'a> for BallBouncinessOption {
1262 type Inner = Self;
1263 #[inline]
1264 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1265 flatbuffers::read_scalar_at::<Self>(buf, loc)
1266 }
1267 }
1268
1269 impl flatbuffers::EndianScalar for BallBouncinessOption {
1270 #[inline]
1271 fn to_little_endian(self) -> Self {
1272 let n = i8::to_le(self as i8);
1273 let p = &n as *const i8 as *const BallBouncinessOption;
1274 unsafe { *p }
1275 }
1276 #[inline]
1277 fn from_little_endian(self) -> Self {
1278 let n = i8::from_le(self as i8);
1279 let p = &n as *const i8 as *const BallBouncinessOption;
1280 unsafe { *p }
1281 }
1282 }
1283
1284 impl flatbuffers::Push for BallBouncinessOption {
1285 type Output = BallBouncinessOption;
1286 #[inline]
1287 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1288 flatbuffers::emplace_scalar::<BallBouncinessOption>(dst, *self);
1289 }
1290 }
1291
1292 #[allow(non_camel_case_types)]
1293 const ENUM_VALUES_BALL_BOUNCINESS_OPTION: [BallBouncinessOption; 4] = [
1294 BallBouncinessOption::Default,
1295 BallBouncinessOption::Low,
1296 BallBouncinessOption::High,
1297 BallBouncinessOption::Super_High,
1298 ];
1299
1300 #[allow(non_camel_case_types)]
1301 const ENUM_NAMES_BALL_BOUNCINESS_OPTION: [&'static str; 4] =
1302 ["Default", "Low", "High", "Super_High"];
1303
1304 pub fn enum_name_ball_bounciness_option(e: BallBouncinessOption) -> &'static str {
1305 let index: usize = e as usize;
1306 ENUM_NAMES_BALL_BOUNCINESS_OPTION[index]
1307 }
1308
1309 #[allow(non_camel_case_types)]
1310 #[repr(i8)]
1311 #[derive(Clone, Copy, PartialEq, Debug)]
1312 pub enum BoostOption {
1313 Normal_Boost = 0,
1314 Unlimited_Boost = 1,
1315 Slow_Recharge = 2,
1316 Rapid_Recharge = 3,
1317 No_Boost = 4,
1318 }
1319
1320 const ENUM_MIN_BOOST_OPTION: i8 = 0;
1321 const ENUM_MAX_BOOST_OPTION: i8 = 4;
1322
1323 impl<'a> flatbuffers::Follow<'a> for BoostOption {
1324 type Inner = Self;
1325 #[inline]
1326 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1327 flatbuffers::read_scalar_at::<Self>(buf, loc)
1328 }
1329 }
1330
1331 impl flatbuffers::EndianScalar for BoostOption {
1332 #[inline]
1333 fn to_little_endian(self) -> Self {
1334 let n = i8::to_le(self as i8);
1335 let p = &n as *const i8 as *const BoostOption;
1336 unsafe { *p }
1337 }
1338 #[inline]
1339 fn from_little_endian(self) -> Self {
1340 let n = i8::from_le(self as i8);
1341 let p = &n as *const i8 as *const BoostOption;
1342 unsafe { *p }
1343 }
1344 }
1345
1346 impl flatbuffers::Push for BoostOption {
1347 type Output = BoostOption;
1348 #[inline]
1349 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1350 flatbuffers::emplace_scalar::<BoostOption>(dst, *self);
1351 }
1352 }
1353
1354 #[allow(non_camel_case_types)]
1355 const ENUM_VALUES_BOOST_OPTION: [BoostOption; 5] = [
1356 BoostOption::Normal_Boost,
1357 BoostOption::Unlimited_Boost,
1358 BoostOption::Slow_Recharge,
1359 BoostOption::Rapid_Recharge,
1360 BoostOption::No_Boost,
1361 ];
1362
1363 #[allow(non_camel_case_types)]
1364 const ENUM_NAMES_BOOST_OPTION: [&'static str; 5] = [
1365 "Normal_Boost",
1366 "Unlimited_Boost",
1367 "Slow_Recharge",
1368 "Rapid_Recharge",
1369 "No_Boost",
1370 ];
1371
1372 pub fn enum_name_boost_option(e: BoostOption) -> &'static str {
1373 let index: usize = e as usize;
1374 ENUM_NAMES_BOOST_OPTION[index]
1375 }
1376
1377 #[allow(non_camel_case_types)]
1378 #[repr(i8)]
1379 #[derive(Clone, Copy, PartialEq, Debug)]
1380 pub enum RumbleOption {
1381 None = 0,
1382 Default = 1,
1383 Slow = 2,
1384 Civilized = 3,
1385 Destruction_Derby = 4,
1386 Spring_Loaded = 5,
1387 Spikes_Only = 6,
1388 }
1389
1390 const ENUM_MIN_RUMBLE_OPTION: i8 = 0;
1391 const ENUM_MAX_RUMBLE_OPTION: i8 = 6;
1392
1393 impl<'a> flatbuffers::Follow<'a> for RumbleOption {
1394 type Inner = Self;
1395 #[inline]
1396 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1397 flatbuffers::read_scalar_at::<Self>(buf, loc)
1398 }
1399 }
1400
1401 impl flatbuffers::EndianScalar for RumbleOption {
1402 #[inline]
1403 fn to_little_endian(self) -> Self {
1404 let n = i8::to_le(self as i8);
1405 let p = &n as *const i8 as *const RumbleOption;
1406 unsafe { *p }
1407 }
1408 #[inline]
1409 fn from_little_endian(self) -> Self {
1410 let n = i8::from_le(self as i8);
1411 let p = &n as *const i8 as *const RumbleOption;
1412 unsafe { *p }
1413 }
1414 }
1415
1416 impl flatbuffers::Push for RumbleOption {
1417 type Output = RumbleOption;
1418 #[inline]
1419 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1420 flatbuffers::emplace_scalar::<RumbleOption>(dst, *self);
1421 }
1422 }
1423
1424 #[allow(non_camel_case_types)]
1425 const ENUM_VALUES_RUMBLE_OPTION: [RumbleOption; 7] = [
1426 RumbleOption::None,
1427 RumbleOption::Default,
1428 RumbleOption::Slow,
1429 RumbleOption::Civilized,
1430 RumbleOption::Destruction_Derby,
1431 RumbleOption::Spring_Loaded,
1432 RumbleOption::Spikes_Only,
1433 ];
1434
1435 #[allow(non_camel_case_types)]
1436 const ENUM_NAMES_RUMBLE_OPTION: [&'static str; 7] = [
1437 "None",
1438 "Default",
1439 "Slow",
1440 "Civilized",
1441 "Destruction_Derby",
1442 "Spring_Loaded",
1443 "Spikes_Only",
1444 ];
1445
1446 pub fn enum_name_rumble_option(e: RumbleOption) -> &'static str {
1447 let index: usize = e as usize;
1448 ENUM_NAMES_RUMBLE_OPTION[index]
1449 }
1450
1451 #[allow(non_camel_case_types)]
1452 #[repr(i8)]
1453 #[derive(Clone, Copy, PartialEq, Debug)]
1454 pub enum BoostStrengthOption {
1455 One = 0,
1456 OneAndAHalf = 1,
1457 Two = 2,
1458 Ten = 3,
1459 }
1460
1461 const ENUM_MIN_BOOST_STRENGTH_OPTION: i8 = 0;
1462 const ENUM_MAX_BOOST_STRENGTH_OPTION: i8 = 3;
1463
1464 impl<'a> flatbuffers::Follow<'a> for BoostStrengthOption {
1465 type Inner = Self;
1466 #[inline]
1467 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1468 flatbuffers::read_scalar_at::<Self>(buf, loc)
1469 }
1470 }
1471
1472 impl flatbuffers::EndianScalar for BoostStrengthOption {
1473 #[inline]
1474 fn to_little_endian(self) -> Self {
1475 let n = i8::to_le(self as i8);
1476 let p = &n as *const i8 as *const BoostStrengthOption;
1477 unsafe { *p }
1478 }
1479 #[inline]
1480 fn from_little_endian(self) -> Self {
1481 let n = i8::from_le(self as i8);
1482 let p = &n as *const i8 as *const BoostStrengthOption;
1483 unsafe { *p }
1484 }
1485 }
1486
1487 impl flatbuffers::Push for BoostStrengthOption {
1488 type Output = BoostStrengthOption;
1489 #[inline]
1490 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1491 flatbuffers::emplace_scalar::<BoostStrengthOption>(dst, *self);
1492 }
1493 }
1494
1495 #[allow(non_camel_case_types)]
1496 const ENUM_VALUES_BOOST_STRENGTH_OPTION: [BoostStrengthOption; 4] = [
1497 BoostStrengthOption::One,
1498 BoostStrengthOption::OneAndAHalf,
1499 BoostStrengthOption::Two,
1500 BoostStrengthOption::Ten,
1501 ];
1502
1503 #[allow(non_camel_case_types)]
1504 const ENUM_NAMES_BOOST_STRENGTH_OPTION: [&'static str; 4] =
1505 ["One", "OneAndAHalf", "Two", "Ten"];
1506
1507 pub fn enum_name_boost_strength_option(e: BoostStrengthOption) -> &'static str {
1508 let index: usize = e as usize;
1509 ENUM_NAMES_BOOST_STRENGTH_OPTION[index]
1510 }
1511
1512 #[allow(non_camel_case_types)]
1513 #[repr(i8)]
1514 #[derive(Clone, Copy, PartialEq, Debug)]
1515 pub enum GravityOption {
1516 Default = 0,
1517 Low = 1,
1518 High = 2,
1519 Super_High = 3,
1520 }
1521
1522 const ENUM_MIN_GRAVITY_OPTION: i8 = 0;
1523 const ENUM_MAX_GRAVITY_OPTION: i8 = 3;
1524
1525 impl<'a> flatbuffers::Follow<'a> for GravityOption {
1526 type Inner = Self;
1527 #[inline]
1528 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1529 flatbuffers::read_scalar_at::<Self>(buf, loc)
1530 }
1531 }
1532
1533 impl flatbuffers::EndianScalar for GravityOption {
1534 #[inline]
1535 fn to_little_endian(self) -> Self {
1536 let n = i8::to_le(self as i8);
1537 let p = &n as *const i8 as *const GravityOption;
1538 unsafe { *p }
1539 }
1540 #[inline]
1541 fn from_little_endian(self) -> Self {
1542 let n = i8::from_le(self as i8);
1543 let p = &n as *const i8 as *const GravityOption;
1544 unsafe { *p }
1545 }
1546 }
1547
1548 impl flatbuffers::Push for GravityOption {
1549 type Output = GravityOption;
1550 #[inline]
1551 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1552 flatbuffers::emplace_scalar::<GravityOption>(dst, *self);
1553 }
1554 }
1555
1556 #[allow(non_camel_case_types)]
1557 const ENUM_VALUES_GRAVITY_OPTION: [GravityOption; 4] = [
1558 GravityOption::Default,
1559 GravityOption::Low,
1560 GravityOption::High,
1561 GravityOption::Super_High,
1562 ];
1563
1564 #[allow(non_camel_case_types)]
1565 const ENUM_NAMES_GRAVITY_OPTION: [&'static str; 4] =
1566 ["Default", "Low", "High", "Super_High"];
1567
1568 pub fn enum_name_gravity_option(e: GravityOption) -> &'static str {
1569 let index: usize = e as usize;
1570 ENUM_NAMES_GRAVITY_OPTION[index]
1571 }
1572
1573 #[allow(non_camel_case_types)]
1574 #[repr(i8)]
1575 #[derive(Clone, Copy, PartialEq, Debug)]
1576 pub enum DemolishOption {
1577 Default = 0,
1578 Disabled = 1,
1579 Friendly_Fire = 2,
1580 On_Contact = 3,
1581 On_Contact_FF = 4,
1582 }
1583
1584 const ENUM_MIN_DEMOLISH_OPTION: i8 = 0;
1585 const ENUM_MAX_DEMOLISH_OPTION: i8 = 4;
1586
1587 impl<'a> flatbuffers::Follow<'a> for DemolishOption {
1588 type Inner = Self;
1589 #[inline]
1590 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1591 flatbuffers::read_scalar_at::<Self>(buf, loc)
1592 }
1593 }
1594
1595 impl flatbuffers::EndianScalar for DemolishOption {
1596 #[inline]
1597 fn to_little_endian(self) -> Self {
1598 let n = i8::to_le(self as i8);
1599 let p = &n as *const i8 as *const DemolishOption;
1600 unsafe { *p }
1601 }
1602 #[inline]
1603 fn from_little_endian(self) -> Self {
1604 let n = i8::from_le(self as i8);
1605 let p = &n as *const i8 as *const DemolishOption;
1606 unsafe { *p }
1607 }
1608 }
1609
1610 impl flatbuffers::Push for DemolishOption {
1611 type Output = DemolishOption;
1612 #[inline]
1613 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1614 flatbuffers::emplace_scalar::<DemolishOption>(dst, *self);
1615 }
1616 }
1617
1618 #[allow(non_camel_case_types)]
1619 const ENUM_VALUES_DEMOLISH_OPTION: [DemolishOption; 5] = [
1620 DemolishOption::Default,
1621 DemolishOption::Disabled,
1622 DemolishOption::Friendly_Fire,
1623 DemolishOption::On_Contact,
1624 DemolishOption::On_Contact_FF,
1625 ];
1626
1627 #[allow(non_camel_case_types)]
1628 const ENUM_NAMES_DEMOLISH_OPTION: [&'static str; 5] = [
1629 "Default",
1630 "Disabled",
1631 "Friendly_Fire",
1632 "On_Contact",
1633 "On_Contact_FF",
1634 ];
1635
1636 pub fn enum_name_demolish_option(e: DemolishOption) -> &'static str {
1637 let index: usize = e as usize;
1638 ENUM_NAMES_DEMOLISH_OPTION[index]
1639 }
1640
1641 #[allow(non_camel_case_types)]
1642 #[repr(i8)]
1643 #[derive(Clone, Copy, PartialEq, Debug)]
1644 pub enum RespawnTimeOption {
1645 Three_Seconds = 0,
1646 Two_Seconds = 1,
1647 One_Seconds = 2,
1648 Disable_Goal_Reset = 3,
1649 }
1650
1651 const ENUM_MIN_RESPAWN_TIME_OPTION: i8 = 0;
1652 const ENUM_MAX_RESPAWN_TIME_OPTION: i8 = 3;
1653
1654 impl<'a> flatbuffers::Follow<'a> for RespawnTimeOption {
1655 type Inner = Self;
1656 #[inline]
1657 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1658 flatbuffers::read_scalar_at::<Self>(buf, loc)
1659 }
1660 }
1661
1662 impl flatbuffers::EndianScalar for RespawnTimeOption {
1663 #[inline]
1664 fn to_little_endian(self) -> Self {
1665 let n = i8::to_le(self as i8);
1666 let p = &n as *const i8 as *const RespawnTimeOption;
1667 unsafe { *p }
1668 }
1669 #[inline]
1670 fn from_little_endian(self) -> Self {
1671 let n = i8::from_le(self as i8);
1672 let p = &n as *const i8 as *const RespawnTimeOption;
1673 unsafe { *p }
1674 }
1675 }
1676
1677 impl flatbuffers::Push for RespawnTimeOption {
1678 type Output = RespawnTimeOption;
1679 #[inline]
1680 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1681 flatbuffers::emplace_scalar::<RespawnTimeOption>(dst, *self);
1682 }
1683 }
1684
1685 #[allow(non_camel_case_types)]
1686 const ENUM_VALUES_RESPAWN_TIME_OPTION: [RespawnTimeOption; 4] = [
1687 RespawnTimeOption::Three_Seconds,
1688 RespawnTimeOption::Two_Seconds,
1689 RespawnTimeOption::One_Seconds,
1690 RespawnTimeOption::Disable_Goal_Reset,
1691 ];
1692
1693 #[allow(non_camel_case_types)]
1694 const ENUM_NAMES_RESPAWN_TIME_OPTION: [&'static str; 4] = [
1695 "Three_Seconds",
1696 "Two_Seconds",
1697 "One_Seconds",
1698 "Disable_Goal_Reset",
1699 ];
1700
1701 pub fn enum_name_respawn_time_option(e: RespawnTimeOption) -> &'static str {
1702 let index: usize = e as usize;
1703 ENUM_NAMES_RESPAWN_TIME_OPTION[index]
1704 }
1705
1706 #[repr(C, align(4))]
1708 #[derive(Clone, Copy, Debug, PartialEq)]
1709 pub struct Vector3 {
1710 x_: f32,
1711 y_: f32,
1712 z_: f32,
1713 } impl flatbuffers::SafeSliceAccess for Vector3 {}
1715 impl<'a> flatbuffers::Follow<'a> for Vector3 {
1716 type Inner = &'a Vector3;
1717 #[inline]
1718 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1719 <&'a Vector3>::follow(buf, loc)
1720 }
1721 }
1722 impl<'a> flatbuffers::Follow<'a> for &'a Vector3 {
1723 type Inner = &'a Vector3;
1724 #[inline]
1725 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1726 flatbuffers::follow_cast_ref::<Vector3>(buf, loc)
1727 }
1728 }
1729 impl<'b> flatbuffers::Push for Vector3 {
1730 type Output = Vector3;
1731 #[inline]
1732 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1733 let src = unsafe {
1734 ::std::slice::from_raw_parts(self as *const Vector3 as *const u8, Self::size())
1735 };
1736 dst.copy_from_slice(src);
1737 }
1738 }
1739 impl<'b> flatbuffers::Push for &'b Vector3 {
1740 type Output = Vector3;
1741
1742 #[inline]
1743 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1744 let src = unsafe {
1745 ::std::slice::from_raw_parts(*self as *const Vector3 as *const u8, Self::size())
1746 };
1747 dst.copy_from_slice(src);
1748 }
1749 }
1750
1751 impl Vector3 {
1752 pub fn new<'a>(_x: f32, _y: f32, _z: f32) -> Self {
1753 Vector3 {
1754 x_: _x.to_little_endian(),
1755 y_: _y.to_little_endian(),
1756 z_: _z.to_little_endian(),
1757 }
1758 }
1759 pub fn x<'a>(&'a self) -> f32 {
1760 self.x_.from_little_endian()
1761 }
1762 pub fn y<'a>(&'a self) -> f32 {
1763 self.y_.from_little_endian()
1764 }
1765 pub fn z<'a>(&'a self) -> f32 {
1766 self.z_.from_little_endian()
1767 }
1768 }
1769
1770 #[repr(C, align(4))]
1774 #[derive(Clone, Copy, Debug, PartialEq)]
1775 pub struct Rotator {
1776 pitch_: f32,
1777 yaw_: f32,
1778 roll_: f32,
1779 } impl flatbuffers::SafeSliceAccess for Rotator {}
1781 impl<'a> flatbuffers::Follow<'a> for Rotator {
1782 type Inner = &'a Rotator;
1783 #[inline]
1784 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1785 <&'a Rotator>::follow(buf, loc)
1786 }
1787 }
1788 impl<'a> flatbuffers::Follow<'a> for &'a Rotator {
1789 type Inner = &'a Rotator;
1790 #[inline]
1791 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1792 flatbuffers::follow_cast_ref::<Rotator>(buf, loc)
1793 }
1794 }
1795 impl<'b> flatbuffers::Push for Rotator {
1796 type Output = Rotator;
1797 #[inline]
1798 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1799 let src = unsafe {
1800 ::std::slice::from_raw_parts(self as *const Rotator as *const u8, Self::size())
1801 };
1802 dst.copy_from_slice(src);
1803 }
1804 }
1805 impl<'b> flatbuffers::Push for &'b Rotator {
1806 type Output = Rotator;
1807
1808 #[inline]
1809 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1810 let src = unsafe {
1811 ::std::slice::from_raw_parts(*self as *const Rotator as *const u8, Self::size())
1812 };
1813 dst.copy_from_slice(src);
1814 }
1815 }
1816
1817 impl Rotator {
1818 pub fn new<'a>(_pitch: f32, _yaw: f32, _roll: f32) -> Self {
1819 Rotator {
1820 pitch_: _pitch.to_little_endian(),
1821 yaw_: _yaw.to_little_endian(),
1822 roll_: _roll.to_little_endian(),
1823 }
1824 }
1825 pub fn pitch<'a>(&'a self) -> f32 {
1826 self.pitch_.from_little_endian()
1827 }
1828 pub fn yaw<'a>(&'a self) -> f32 {
1829 self.yaw_.from_little_endian()
1830 }
1831 pub fn roll<'a>(&'a self) -> f32 {
1832 self.roll_.from_little_endian()
1833 }
1834 }
1835
1836 #[repr(C, align(4))]
1841 #[derive(Clone, Copy, Debug, PartialEq)]
1842 pub struct Quaternion {
1843 x_: f32,
1844 y_: f32,
1845 z_: f32,
1846 w_: f32,
1847 } impl flatbuffers::SafeSliceAccess for Quaternion {}
1849 impl<'a> flatbuffers::Follow<'a> for Quaternion {
1850 type Inner = &'a Quaternion;
1851 #[inline]
1852 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1853 <&'a Quaternion>::follow(buf, loc)
1854 }
1855 }
1856 impl<'a> flatbuffers::Follow<'a> for &'a Quaternion {
1857 type Inner = &'a Quaternion;
1858 #[inline]
1859 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1860 flatbuffers::follow_cast_ref::<Quaternion>(buf, loc)
1861 }
1862 }
1863 impl<'b> flatbuffers::Push for Quaternion {
1864 type Output = Quaternion;
1865 #[inline]
1866 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1867 let src = unsafe {
1868 ::std::slice::from_raw_parts(
1869 self as *const Quaternion as *const u8,
1870 Self::size(),
1871 )
1872 };
1873 dst.copy_from_slice(src);
1874 }
1875 }
1876 impl<'b> flatbuffers::Push for &'b Quaternion {
1877 type Output = Quaternion;
1878
1879 #[inline]
1880 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1881 let src = unsafe {
1882 ::std::slice::from_raw_parts(
1883 *self as *const Quaternion as *const u8,
1884 Self::size(),
1885 )
1886 };
1887 dst.copy_from_slice(src);
1888 }
1889 }
1890
1891 impl Quaternion {
1892 pub fn new<'a>(_x: f32, _y: f32, _z: f32, _w: f32) -> Self {
1893 Quaternion {
1894 x_: _x.to_little_endian(),
1895 y_: _y.to_little_endian(),
1896 z_: _z.to_little_endian(),
1897 w_: _w.to_little_endian(),
1898 }
1899 }
1900 pub fn x<'a>(&'a self) -> f32 {
1901 self.x_.from_little_endian()
1902 }
1903 pub fn y<'a>(&'a self) -> f32 {
1904 self.y_.from_little_endian()
1905 }
1906 pub fn z<'a>(&'a self) -> f32 {
1907 self.z_.from_little_endian()
1908 }
1909 pub fn w<'a>(&'a self) -> f32 {
1910 self.w_.from_little_endian()
1911 }
1912 }
1913
1914 #[repr(C, align(4))]
1916 #[derive(Clone, Copy, Debug, PartialEq)]
1917 pub struct Float {
1918 val_: f32,
1919 } impl flatbuffers::SafeSliceAccess for Float {}
1921 impl<'a> flatbuffers::Follow<'a> for Float {
1922 type Inner = &'a Float;
1923 #[inline]
1924 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1925 <&'a Float>::follow(buf, loc)
1926 }
1927 }
1928 impl<'a> flatbuffers::Follow<'a> for &'a Float {
1929 type Inner = &'a Float;
1930 #[inline]
1931 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1932 flatbuffers::follow_cast_ref::<Float>(buf, loc)
1933 }
1934 }
1935 impl<'b> flatbuffers::Push for Float {
1936 type Output = Float;
1937 #[inline]
1938 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1939 let src = unsafe {
1940 ::std::slice::from_raw_parts(self as *const Float as *const u8, Self::size())
1941 };
1942 dst.copy_from_slice(src);
1943 }
1944 }
1945 impl<'b> flatbuffers::Push for &'b Float {
1946 type Output = Float;
1947
1948 #[inline]
1949 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1950 let src = unsafe {
1951 ::std::slice::from_raw_parts(*self as *const Float as *const u8, Self::size())
1952 };
1953 dst.copy_from_slice(src);
1954 }
1955 }
1956
1957 impl Float {
1958 pub fn new<'a>(_val: f32) -> Self {
1959 Float {
1960 val_: _val.to_little_endian(),
1961 }
1962 }
1963 pub fn val<'a>(&'a self) -> f32 {
1964 self.val_.from_little_endian()
1965 }
1966 }
1967
1968 #[repr(C, align(1))]
1970 #[derive(Clone, Copy, Debug, PartialEq)]
1971 pub struct Bool {
1972 val_: bool,
1973 } impl flatbuffers::SafeSliceAccess for Bool {}
1975 impl<'a> flatbuffers::Follow<'a> for Bool {
1976 type Inner = &'a Bool;
1977 #[inline]
1978 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1979 <&'a Bool>::follow(buf, loc)
1980 }
1981 }
1982 impl<'a> flatbuffers::Follow<'a> for &'a Bool {
1983 type Inner = &'a Bool;
1984 #[inline]
1985 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1986 flatbuffers::follow_cast_ref::<Bool>(buf, loc)
1987 }
1988 }
1989 impl<'b> flatbuffers::Push for Bool {
1990 type Output = Bool;
1991 #[inline]
1992 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
1993 let src = unsafe {
1994 ::std::slice::from_raw_parts(self as *const Bool as *const u8, Self::size())
1995 };
1996 dst.copy_from_slice(src);
1997 }
1998 }
1999 impl<'b> flatbuffers::Push for &'b Bool {
2000 type Output = Bool;
2001
2002 #[inline]
2003 fn push(&self, dst: &mut [u8], _rest: &[u8]) {
2004 let src = unsafe {
2005 ::std::slice::from_raw_parts(*self as *const Bool as *const u8, Self::size())
2006 };
2007 dst.copy_from_slice(src);
2008 }
2009 }
2010
2011 impl Bool {
2012 pub fn new<'a>(_val: bool) -> Self {
2013 Bool {
2014 val_: _val.to_little_endian(),
2015 }
2016 }
2017 pub fn val<'a>(&'a self) -> bool {
2018 self.val_.from_little_endian()
2019 }
2020 }
2021
2022 pub enum ControllerStateOffset {}
2023 #[derive(Copy, Clone, Debug, PartialEq)]
2024
2025 pub struct ControllerState<'a> {
2026 pub _tab: flatbuffers::Table<'a>,
2027 }
2028
2029 impl<'a> flatbuffers::Follow<'a> for ControllerState<'a> {
2030 type Inner = ControllerState<'a>;
2031 #[inline]
2032 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
2033 Self {
2034 _tab: flatbuffers::Table { buf, loc },
2035 }
2036 }
2037 }
2038
2039 impl<'a> ControllerState<'a> {
2040 #[inline]
2041 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
2042 ControllerState { _tab: table }
2043 }
2044 #[allow(unused_mut)]
2045 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
2046 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
2047 args: &'args ControllerStateArgs,
2048 ) -> flatbuffers::WIPOffset<ControllerState<'bldr>> {
2049 let mut builder = ControllerStateBuilder::new(_fbb);
2050 builder.add_roll(args.roll);
2051 builder.add_yaw(args.yaw);
2052 builder.add_pitch(args.pitch);
2053 builder.add_steer(args.steer);
2054 builder.add_throttle(args.throttle);
2055 builder.add_handbrake(args.handbrake);
2056 builder.add_boost(args.boost);
2057 builder.add_jump(args.jump);
2058 builder.finish()
2059 }
2060
2061 pub const VT_THROTTLE: flatbuffers::VOffsetT = 4;
2062 pub const VT_STEER: flatbuffers::VOffsetT = 6;
2063 pub const VT_PITCH: flatbuffers::VOffsetT = 8;
2064 pub const VT_YAW: flatbuffers::VOffsetT = 10;
2065 pub const VT_ROLL: flatbuffers::VOffsetT = 12;
2066 pub const VT_JUMP: flatbuffers::VOffsetT = 14;
2067 pub const VT_BOOST: flatbuffers::VOffsetT = 16;
2068 pub const VT_HANDBRAKE: flatbuffers::VOffsetT = 18;
2069
2070 #[inline]
2072 pub fn throttle(&self) -> f32 {
2073 self._tab
2074 .get::<f32>(ControllerState::VT_THROTTLE, Some(0.0))
2075 .unwrap()
2076 }
2077 #[inline]
2079 pub fn steer(&self) -> f32 {
2080 self._tab
2081 .get::<f32>(ControllerState::VT_STEER, Some(0.0))
2082 .unwrap()
2083 }
2084 #[inline]
2086 pub fn pitch(&self) -> f32 {
2087 self._tab
2088 .get::<f32>(ControllerState::VT_PITCH, Some(0.0))
2089 .unwrap()
2090 }
2091 #[inline]
2093 pub fn yaw(&self) -> f32 {
2094 self._tab
2095 .get::<f32>(ControllerState::VT_YAW, Some(0.0))
2096 .unwrap()
2097 }
2098 #[inline]
2100 pub fn roll(&self) -> f32 {
2101 self._tab
2102 .get::<f32>(ControllerState::VT_ROLL, Some(0.0))
2103 .unwrap()
2104 }
2105 #[inline]
2107 pub fn jump(&self) -> bool {
2108 self._tab
2109 .get::<bool>(ControllerState::VT_JUMP, Some(false))
2110 .unwrap()
2111 }
2112 #[inline]
2114 pub fn boost(&self) -> bool {
2115 self._tab
2116 .get::<bool>(ControllerState::VT_BOOST, Some(false))
2117 .unwrap()
2118 }
2119 #[inline]
2121 pub fn handbrake(&self) -> bool {
2122 self._tab
2123 .get::<bool>(ControllerState::VT_HANDBRAKE, Some(false))
2124 .unwrap()
2125 }
2126 }
2127
2128 pub struct ControllerStateArgs {
2129 pub throttle: f32,
2130 pub steer: f32,
2131 pub pitch: f32,
2132 pub yaw: f32,
2133 pub roll: f32,
2134 pub jump: bool,
2135 pub boost: bool,
2136 pub handbrake: bool,
2137 }
2138 impl<'a> Default for ControllerStateArgs {
2139 #[inline]
2140 fn default() -> Self {
2141 ControllerStateArgs {
2142 throttle: 0.0,
2143 steer: 0.0,
2144 pitch: 0.0,
2145 yaw: 0.0,
2146 roll: 0.0,
2147 jump: false,
2148 boost: false,
2149 handbrake: false,
2150 }
2151 }
2152 }
2153 pub struct ControllerStateBuilder<'a: 'b, 'b> {
2154 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
2155 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
2156 }
2157 impl<'a: 'b, 'b> ControllerStateBuilder<'a, 'b> {
2158 #[inline]
2159 pub fn add_throttle(&mut self, throttle: f32) {
2160 self.fbb_
2161 .push_slot::<f32>(ControllerState::VT_THROTTLE, throttle, 0.0);
2162 }
2163 #[inline]
2164 pub fn add_steer(&mut self, steer: f32) {
2165 self.fbb_
2166 .push_slot::<f32>(ControllerState::VT_STEER, steer, 0.0);
2167 }
2168 #[inline]
2169 pub fn add_pitch(&mut self, pitch: f32) {
2170 self.fbb_
2171 .push_slot::<f32>(ControllerState::VT_PITCH, pitch, 0.0);
2172 }
2173 #[inline]
2174 pub fn add_yaw(&mut self, yaw: f32) {
2175 self.fbb_
2176 .push_slot::<f32>(ControllerState::VT_YAW, yaw, 0.0);
2177 }
2178 #[inline]
2179 pub fn add_roll(&mut self, roll: f32) {
2180 self.fbb_
2181 .push_slot::<f32>(ControllerState::VT_ROLL, roll, 0.0);
2182 }
2183 #[inline]
2184 pub fn add_jump(&mut self, jump: bool) {
2185 self.fbb_
2186 .push_slot::<bool>(ControllerState::VT_JUMP, jump, false);
2187 }
2188 #[inline]
2189 pub fn add_boost(&mut self, boost: bool) {
2190 self.fbb_
2191 .push_slot::<bool>(ControllerState::VT_BOOST, boost, false);
2192 }
2193 #[inline]
2194 pub fn add_handbrake(&mut self, handbrake: bool) {
2195 self.fbb_
2196 .push_slot::<bool>(ControllerState::VT_HANDBRAKE, handbrake, false);
2197 }
2198 #[inline]
2199 pub fn new(
2200 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
2201 ) -> ControllerStateBuilder<'a, 'b> {
2202 let start = _fbb.start_table();
2203 ControllerStateBuilder {
2204 fbb_: _fbb,
2205 start_: start,
2206 }
2207 }
2208 #[inline]
2209 pub fn finish(self) -> flatbuffers::WIPOffset<ControllerState<'a>> {
2210 let o = self.fbb_.end_table(self.start_);
2211 flatbuffers::WIPOffset::new(o.value())
2212 }
2213 }
2214
2215 pub enum PlayerInputOffset {}
2216 #[derive(Copy, Clone, Debug, PartialEq)]
2217
2218 pub struct PlayerInput<'a> {
2219 pub _tab: flatbuffers::Table<'a>,
2220 }
2221
2222 impl<'a> flatbuffers::Follow<'a> for PlayerInput<'a> {
2223 type Inner = PlayerInput<'a>;
2224 #[inline]
2225 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
2226 Self {
2227 _tab: flatbuffers::Table { buf, loc },
2228 }
2229 }
2230 }
2231
2232 impl<'a> PlayerInput<'a> {
2233 #[inline]
2234 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
2235 PlayerInput { _tab: table }
2236 }
2237 #[allow(unused_mut)]
2238 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
2239 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
2240 args: &'args PlayerInputArgs<'args>,
2241 ) -> flatbuffers::WIPOffset<PlayerInput<'bldr>> {
2242 let mut builder = PlayerInputBuilder::new(_fbb);
2243 if let Some(x) = args.controllerState {
2244 builder.add_controllerState(x);
2245 }
2246 builder.add_playerIndex(args.playerIndex);
2247 builder.finish()
2248 }
2249
2250 pub const VT_PLAYERINDEX: flatbuffers::VOffsetT = 4;
2251 pub const VT_CONTROLLERSTATE: flatbuffers::VOffsetT = 6;
2252
2253 #[inline]
2254 pub fn playerIndex(&self) -> i32 {
2255 self._tab
2256 .get::<i32>(PlayerInput::VT_PLAYERINDEX, Some(0))
2257 .unwrap()
2258 }
2259 #[inline]
2260 pub fn controllerState(&self) -> Option<ControllerState<'a>> {
2261 self._tab
2262 .get::<flatbuffers::ForwardsUOffset<ControllerState<'a>>>(
2263 PlayerInput::VT_CONTROLLERSTATE,
2264 None,
2265 )
2266 }
2267 }
2268
2269 pub struct PlayerInputArgs<'a> {
2270 pub playerIndex: i32,
2271 pub controllerState: Option<flatbuffers::WIPOffset<ControllerState<'a>>>,
2272 }
2273 impl<'a> Default for PlayerInputArgs<'a> {
2274 #[inline]
2275 fn default() -> Self {
2276 PlayerInputArgs {
2277 playerIndex: 0,
2278 controllerState: None,
2279 }
2280 }
2281 }
2282 pub struct PlayerInputBuilder<'a: 'b, 'b> {
2283 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
2284 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
2285 }
2286 impl<'a: 'b, 'b> PlayerInputBuilder<'a, 'b> {
2287 #[inline]
2288 pub fn add_playerIndex(&mut self, playerIndex: i32) {
2289 self.fbb_
2290 .push_slot::<i32>(PlayerInput::VT_PLAYERINDEX, playerIndex, 0);
2291 }
2292 #[inline]
2293 pub fn add_controllerState(
2294 &mut self,
2295 controllerState: flatbuffers::WIPOffset<ControllerState<'b>>,
2296 ) {
2297 self.fbb_
2298 .push_slot_always::<flatbuffers::WIPOffset<ControllerState<'_>>>(
2299 PlayerInput::VT_CONTROLLERSTATE,
2300 controllerState,
2301 );
2302 }
2303 #[inline]
2304 pub fn new(
2305 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
2306 ) -> PlayerInputBuilder<'a, 'b> {
2307 let start = _fbb.start_table();
2308 PlayerInputBuilder {
2309 fbb_: _fbb,
2310 start_: start,
2311 }
2312 }
2313 #[inline]
2314 pub fn finish(self) -> flatbuffers::WIPOffset<PlayerInput<'a>> {
2315 let o = self.fbb_.end_table(self.start_);
2316 flatbuffers::WIPOffset::new(o.value())
2317 }
2318 }
2319
2320 pub enum TouchOffset {}
2321 #[derive(Copy, Clone, Debug, PartialEq)]
2322
2323 pub struct Touch<'a> {
2324 pub _tab: flatbuffers::Table<'a>,
2325 }
2326
2327 impl<'a> flatbuffers::Follow<'a> for Touch<'a> {
2328 type Inner = Touch<'a>;
2329 #[inline]
2330 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
2331 Self {
2332 _tab: flatbuffers::Table { buf, loc },
2333 }
2334 }
2335 }
2336
2337 impl<'a> Touch<'a> {
2338 #[inline]
2339 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
2340 Touch { _tab: table }
2341 }
2342 #[allow(unused_mut)]
2343 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
2344 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
2345 args: &'args TouchArgs<'args>,
2346 ) -> flatbuffers::WIPOffset<Touch<'bldr>> {
2347 let mut builder = TouchBuilder::new(_fbb);
2348 builder.add_team(args.team);
2349 if let Some(x) = args.normal {
2350 builder.add_normal(x);
2351 }
2352 if let Some(x) = args.location {
2353 builder.add_location(x);
2354 }
2355 builder.add_gameSeconds(args.gameSeconds);
2356 if let Some(x) = args.playerName {
2357 builder.add_playerName(x);
2358 }
2359 builder.finish()
2360 }
2361
2362 pub const VT_PLAYERNAME: flatbuffers::VOffsetT = 4;
2363 pub const VT_GAMESECONDS: flatbuffers::VOffsetT = 6;
2364 pub const VT_LOCATION: flatbuffers::VOffsetT = 8;
2365 pub const VT_NORMAL: flatbuffers::VOffsetT = 10;
2366 pub const VT_TEAM: flatbuffers::VOffsetT = 12;
2367
2368 #[inline]
2370 pub fn playerName(&self) -> Option<&'a str> {
2371 self._tab
2372 .get::<flatbuffers::ForwardsUOffset<&str>>(Touch::VT_PLAYERNAME, None)
2373 }
2374 #[inline]
2376 pub fn gameSeconds(&self) -> f32 {
2377 self._tab
2378 .get::<f32>(Touch::VT_GAMESECONDS, Some(0.0))
2379 .unwrap()
2380 }
2381 #[inline]
2383 pub fn location(&self) -> Option<&'a Vector3> {
2384 self._tab.get::<Vector3>(Touch::VT_LOCATION, None)
2385 }
2386 #[inline]
2388 pub fn normal(&self) -> Option<&'a Vector3> {
2389 self._tab.get::<Vector3>(Touch::VT_NORMAL, None)
2390 }
2391 #[inline]
2393 pub fn team(&self) -> i32 {
2394 self._tab.get::<i32>(Touch::VT_TEAM, Some(0)).unwrap()
2395 }
2396 }
2397
2398 pub struct TouchArgs<'a> {
2399 pub playerName: Option<flatbuffers::WIPOffset<&'a str>>,
2400 pub gameSeconds: f32,
2401 pub location: Option<&'a Vector3>,
2402 pub normal: Option<&'a Vector3>,
2403 pub team: i32,
2404 }
2405 impl<'a> Default for TouchArgs<'a> {
2406 #[inline]
2407 fn default() -> Self {
2408 TouchArgs {
2409 playerName: None,
2410 gameSeconds: 0.0,
2411 location: None,
2412 normal: None,
2413 team: 0,
2414 }
2415 }
2416 }
2417 pub struct TouchBuilder<'a: 'b, 'b> {
2418 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
2419 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
2420 }
2421 impl<'a: 'b, 'b> TouchBuilder<'a, 'b> {
2422 #[inline]
2423 pub fn add_playerName(&mut self, playerName: flatbuffers::WIPOffset<&'b str>) {
2424 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
2425 Touch::VT_PLAYERNAME,
2426 playerName,
2427 );
2428 }
2429 #[inline]
2430 pub fn add_gameSeconds(&mut self, gameSeconds: f32) {
2431 self.fbb_
2432 .push_slot::<f32>(Touch::VT_GAMESECONDS, gameSeconds, 0.0);
2433 }
2434 #[inline]
2435 pub fn add_location(&mut self, location: &'b Vector3) {
2436 self.fbb_
2437 .push_slot_always::<&Vector3>(Touch::VT_LOCATION, location);
2438 }
2439 #[inline]
2440 pub fn add_normal(&mut self, normal: &'b Vector3) {
2441 self.fbb_
2442 .push_slot_always::<&Vector3>(Touch::VT_NORMAL, normal);
2443 }
2444 #[inline]
2445 pub fn add_team(&mut self, team: i32) {
2446 self.fbb_.push_slot::<i32>(Touch::VT_TEAM, team, 0);
2447 }
2448 #[inline]
2449 pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TouchBuilder<'a, 'b> {
2450 let start = _fbb.start_table();
2451 TouchBuilder {
2452 fbb_: _fbb,
2453 start_: start,
2454 }
2455 }
2456 #[inline]
2457 pub fn finish(self) -> flatbuffers::WIPOffset<Touch<'a>> {
2458 let o = self.fbb_.end_table(self.start_);
2459 flatbuffers::WIPOffset::new(o.value())
2460 }
2461 }
2462
2463 pub enum ScoreInfoOffset {}
2464 #[derive(Copy, Clone, Debug, PartialEq)]
2465
2466 pub struct ScoreInfo<'a> {
2467 pub _tab: flatbuffers::Table<'a>,
2468 }
2469
2470 impl<'a> flatbuffers::Follow<'a> for ScoreInfo<'a> {
2471 type Inner = ScoreInfo<'a>;
2472 #[inline]
2473 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
2474 Self {
2475 _tab: flatbuffers::Table { buf, loc },
2476 }
2477 }
2478 }
2479
2480 impl<'a> ScoreInfo<'a> {
2481 #[inline]
2482 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
2483 ScoreInfo { _tab: table }
2484 }
2485 #[allow(unused_mut)]
2486 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
2487 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
2488 args: &'args ScoreInfoArgs,
2489 ) -> flatbuffers::WIPOffset<ScoreInfo<'bldr>> {
2490 let mut builder = ScoreInfoBuilder::new(_fbb);
2491 builder.add_demolitions(args.demolitions);
2492 builder.add_shots(args.shots);
2493 builder.add_saves(args.saves);
2494 builder.add_assists(args.assists);
2495 builder.add_ownGoals(args.ownGoals);
2496 builder.add_goals(args.goals);
2497 builder.add_score(args.score);
2498 builder.finish()
2499 }
2500
2501 pub const VT_SCORE: flatbuffers::VOffsetT = 4;
2502 pub const VT_GOALS: flatbuffers::VOffsetT = 6;
2503 pub const VT_OWNGOALS: flatbuffers::VOffsetT = 8;
2504 pub const VT_ASSISTS: flatbuffers::VOffsetT = 10;
2505 pub const VT_SAVES: flatbuffers::VOffsetT = 12;
2506 pub const VT_SHOTS: flatbuffers::VOffsetT = 14;
2507 pub const VT_DEMOLITIONS: flatbuffers::VOffsetT = 16;
2508
2509 #[inline]
2510 pub fn score(&self) -> i32 {
2511 self._tab.get::<i32>(ScoreInfo::VT_SCORE, Some(0)).unwrap()
2512 }
2513 #[inline]
2514 pub fn goals(&self) -> i32 {
2515 self._tab.get::<i32>(ScoreInfo::VT_GOALS, Some(0)).unwrap()
2516 }
2517 #[inline]
2518 pub fn ownGoals(&self) -> i32 {
2519 self._tab
2520 .get::<i32>(ScoreInfo::VT_OWNGOALS, Some(0))
2521 .unwrap()
2522 }
2523 #[inline]
2524 pub fn assists(&self) -> i32 {
2525 self._tab
2526 .get::<i32>(ScoreInfo::VT_ASSISTS, Some(0))
2527 .unwrap()
2528 }
2529 #[inline]
2530 pub fn saves(&self) -> i32 {
2531 self._tab.get::<i32>(ScoreInfo::VT_SAVES, Some(0)).unwrap()
2532 }
2533 #[inline]
2534 pub fn shots(&self) -> i32 {
2535 self._tab.get::<i32>(ScoreInfo::VT_SHOTS, Some(0)).unwrap()
2536 }
2537 #[inline]
2538 pub fn demolitions(&self) -> i32 {
2539 self._tab
2540 .get::<i32>(ScoreInfo::VT_DEMOLITIONS, Some(0))
2541 .unwrap()
2542 }
2543 }
2544
2545 pub struct ScoreInfoArgs {
2546 pub score: i32,
2547 pub goals: i32,
2548 pub ownGoals: i32,
2549 pub assists: i32,
2550 pub saves: i32,
2551 pub shots: i32,
2552 pub demolitions: i32,
2553 }
2554 impl<'a> Default for ScoreInfoArgs {
2555 #[inline]
2556 fn default() -> Self {
2557 ScoreInfoArgs {
2558 score: 0,
2559 goals: 0,
2560 ownGoals: 0,
2561 assists: 0,
2562 saves: 0,
2563 shots: 0,
2564 demolitions: 0,
2565 }
2566 }
2567 }
2568 pub struct ScoreInfoBuilder<'a: 'b, 'b> {
2569 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
2570 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
2571 }
2572 impl<'a: 'b, 'b> ScoreInfoBuilder<'a, 'b> {
2573 #[inline]
2574 pub fn add_score(&mut self, score: i32) {
2575 self.fbb_.push_slot::<i32>(ScoreInfo::VT_SCORE, score, 0);
2576 }
2577 #[inline]
2578 pub fn add_goals(&mut self, goals: i32) {
2579 self.fbb_.push_slot::<i32>(ScoreInfo::VT_GOALS, goals, 0);
2580 }
2581 #[inline]
2582 pub fn add_ownGoals(&mut self, ownGoals: i32) {
2583 self.fbb_
2584 .push_slot::<i32>(ScoreInfo::VT_OWNGOALS, ownGoals, 0);
2585 }
2586 #[inline]
2587 pub fn add_assists(&mut self, assists: i32) {
2588 self.fbb_
2589 .push_slot::<i32>(ScoreInfo::VT_ASSISTS, assists, 0);
2590 }
2591 #[inline]
2592 pub fn add_saves(&mut self, saves: i32) {
2593 self.fbb_.push_slot::<i32>(ScoreInfo::VT_SAVES, saves, 0);
2594 }
2595 #[inline]
2596 pub fn add_shots(&mut self, shots: i32) {
2597 self.fbb_.push_slot::<i32>(ScoreInfo::VT_SHOTS, shots, 0);
2598 }
2599 #[inline]
2600 pub fn add_demolitions(&mut self, demolitions: i32) {
2601 self.fbb_
2602 .push_slot::<i32>(ScoreInfo::VT_DEMOLITIONS, demolitions, 0);
2603 }
2604 #[inline]
2605 pub fn new(
2606 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
2607 ) -> ScoreInfoBuilder<'a, 'b> {
2608 let start = _fbb.start_table();
2609 ScoreInfoBuilder {
2610 fbb_: _fbb,
2611 start_: start,
2612 }
2613 }
2614 #[inline]
2615 pub fn finish(self) -> flatbuffers::WIPOffset<ScoreInfo<'a>> {
2616 let o = self.fbb_.end_table(self.start_);
2617 flatbuffers::WIPOffset::new(o.value())
2618 }
2619 }
2620
2621 pub enum PhysicsOffset {}
2622 #[derive(Copy, Clone, Debug, PartialEq)]
2623
2624 pub struct Physics<'a> {
2625 pub _tab: flatbuffers::Table<'a>,
2626 }
2627
2628 impl<'a> flatbuffers::Follow<'a> for Physics<'a> {
2629 type Inner = Physics<'a>;
2630 #[inline]
2631 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
2632 Self {
2633 _tab: flatbuffers::Table { buf, loc },
2634 }
2635 }
2636 }
2637
2638 impl<'a> Physics<'a> {
2639 #[inline]
2640 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
2641 Physics { _tab: table }
2642 }
2643 #[allow(unused_mut)]
2644 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
2645 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
2646 args: &'args PhysicsArgs<'args>,
2647 ) -> flatbuffers::WIPOffset<Physics<'bldr>> {
2648 let mut builder = PhysicsBuilder::new(_fbb);
2649 if let Some(x) = args.angularVelocity {
2650 builder.add_angularVelocity(x);
2651 }
2652 if let Some(x) = args.velocity {
2653 builder.add_velocity(x);
2654 }
2655 if let Some(x) = args.rotation {
2656 builder.add_rotation(x);
2657 }
2658 if let Some(x) = args.location {
2659 builder.add_location(x);
2660 }
2661 builder.finish()
2662 }
2663
2664 pub const VT_LOCATION: flatbuffers::VOffsetT = 4;
2665 pub const VT_ROTATION: flatbuffers::VOffsetT = 6;
2666 pub const VT_VELOCITY: flatbuffers::VOffsetT = 8;
2667 pub const VT_ANGULARVELOCITY: flatbuffers::VOffsetT = 10;
2668
2669 #[inline]
2670 pub fn location(&self) -> Option<&'a Vector3> {
2671 self._tab.get::<Vector3>(Physics::VT_LOCATION, None)
2672 }
2673 #[inline]
2674 pub fn rotation(&self) -> Option<&'a Rotator> {
2675 self._tab.get::<Rotator>(Physics::VT_ROTATION, None)
2676 }
2677 #[inline]
2678 pub fn velocity(&self) -> Option<&'a Vector3> {
2679 self._tab.get::<Vector3>(Physics::VT_VELOCITY, None)
2680 }
2681 #[inline]
2682 pub fn angularVelocity(&self) -> Option<&'a Vector3> {
2683 self._tab.get::<Vector3>(Physics::VT_ANGULARVELOCITY, None)
2684 }
2685 }
2686
2687 pub struct PhysicsArgs<'a> {
2688 pub location: Option<&'a Vector3>,
2689 pub rotation: Option<&'a Rotator>,
2690 pub velocity: Option<&'a Vector3>,
2691 pub angularVelocity: Option<&'a Vector3>,
2692 }
2693 impl<'a> Default for PhysicsArgs<'a> {
2694 #[inline]
2695 fn default() -> Self {
2696 PhysicsArgs {
2697 location: None,
2698 rotation: None,
2699 velocity: None,
2700 angularVelocity: None,
2701 }
2702 }
2703 }
2704 pub struct PhysicsBuilder<'a: 'b, 'b> {
2705 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
2706 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
2707 }
2708 impl<'a: 'b, 'b> PhysicsBuilder<'a, 'b> {
2709 #[inline]
2710 pub fn add_location(&mut self, location: &'b Vector3) {
2711 self.fbb_
2712 .push_slot_always::<&Vector3>(Physics::VT_LOCATION, location);
2713 }
2714 #[inline]
2715 pub fn add_rotation(&mut self, rotation: &'b Rotator) {
2716 self.fbb_
2717 .push_slot_always::<&Rotator>(Physics::VT_ROTATION, rotation);
2718 }
2719 #[inline]
2720 pub fn add_velocity(&mut self, velocity: &'b Vector3) {
2721 self.fbb_
2722 .push_slot_always::<&Vector3>(Physics::VT_VELOCITY, velocity);
2723 }
2724 #[inline]
2725 pub fn add_angularVelocity(&mut self, angularVelocity: &'b Vector3) {
2726 self.fbb_
2727 .push_slot_always::<&Vector3>(Physics::VT_ANGULARVELOCITY, angularVelocity);
2728 }
2729 #[inline]
2730 pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> PhysicsBuilder<'a, 'b> {
2731 let start = _fbb.start_table();
2732 PhysicsBuilder {
2733 fbb_: _fbb,
2734 start_: start,
2735 }
2736 }
2737 #[inline]
2738 pub fn finish(self) -> flatbuffers::WIPOffset<Physics<'a>> {
2739 let o = self.fbb_.end_table(self.start_);
2740 flatbuffers::WIPOffset::new(o.value())
2741 }
2742 }
2743
2744 pub enum PlayerInfoOffset {}
2745 #[derive(Copy, Clone, Debug, PartialEq)]
2746
2747 pub struct PlayerInfo<'a> {
2748 pub _tab: flatbuffers::Table<'a>,
2749 }
2750
2751 impl<'a> flatbuffers::Follow<'a> for PlayerInfo<'a> {
2752 type Inner = PlayerInfo<'a>;
2753 #[inline]
2754 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
2755 Self {
2756 _tab: flatbuffers::Table { buf, loc },
2757 }
2758 }
2759 }
2760
2761 impl<'a> PlayerInfo<'a> {
2762 #[inline]
2763 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
2764 PlayerInfo { _tab: table }
2765 }
2766 #[allow(unused_mut)]
2767 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
2768 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
2769 args: &'args PlayerInfoArgs<'args>,
2770 ) -> flatbuffers::WIPOffset<PlayerInfo<'bldr>> {
2771 let mut builder = PlayerInfoBuilder::new(_fbb);
2772 builder.add_boost(args.boost);
2773 builder.add_team(args.team);
2774 if let Some(x) = args.name {
2775 builder.add_name(x);
2776 }
2777 if let Some(x) = args.scoreInfo {
2778 builder.add_scoreInfo(x);
2779 }
2780 if let Some(x) = args.physics {
2781 builder.add_physics(x);
2782 }
2783 builder.add_doubleJumped(args.doubleJumped);
2784 builder.add_jumped(args.jumped);
2785 builder.add_isBot(args.isBot);
2786 builder.add_isSupersonic(args.isSupersonic);
2787 builder.add_hasWheelContact(args.hasWheelContact);
2788 builder.add_isDemolished(args.isDemolished);
2789 builder.finish()
2790 }
2791
2792 pub const VT_PHYSICS: flatbuffers::VOffsetT = 4;
2793 pub const VT_SCOREINFO: flatbuffers::VOffsetT = 6;
2794 pub const VT_ISDEMOLISHED: flatbuffers::VOffsetT = 8;
2795 pub const VT_HASWHEELCONTACT: flatbuffers::VOffsetT = 10;
2796 pub const VT_ISSUPERSONIC: flatbuffers::VOffsetT = 12;
2797 pub const VT_ISBOT: flatbuffers::VOffsetT = 14;
2798 pub const VT_JUMPED: flatbuffers::VOffsetT = 16;
2799 pub const VT_DOUBLEJUMPED: flatbuffers::VOffsetT = 18;
2800 pub const VT_NAME: flatbuffers::VOffsetT = 20;
2801 pub const VT_TEAM: flatbuffers::VOffsetT = 22;
2802 pub const VT_BOOST: flatbuffers::VOffsetT = 24;
2803
2804 #[inline]
2805 pub fn physics(&self) -> Option<Physics<'a>> {
2806 self._tab
2807 .get::<flatbuffers::ForwardsUOffset<Physics<'a>>>(PlayerInfo::VT_PHYSICS, None)
2808 }
2809 #[inline]
2810 pub fn scoreInfo(&self) -> Option<ScoreInfo<'a>> {
2811 self._tab
2812 .get::<flatbuffers::ForwardsUOffset<ScoreInfo<'a>>>(
2813 PlayerInfo::VT_SCOREINFO,
2814 None,
2815 )
2816 }
2817 #[inline]
2818 pub fn isDemolished(&self) -> bool {
2819 self._tab
2820 .get::<bool>(PlayerInfo::VT_ISDEMOLISHED, Some(false))
2821 .unwrap()
2822 }
2823 #[inline]
2826 pub fn hasWheelContact(&self) -> bool {
2827 self._tab
2828 .get::<bool>(PlayerInfo::VT_HASWHEELCONTACT, Some(false))
2829 .unwrap()
2830 }
2831 #[inline]
2832 pub fn isSupersonic(&self) -> bool {
2833 self._tab
2834 .get::<bool>(PlayerInfo::VT_ISSUPERSONIC, Some(false))
2835 .unwrap()
2836 }
2837 #[inline]
2838 pub fn isBot(&self) -> bool {
2839 self._tab
2840 .get::<bool>(PlayerInfo::VT_ISBOT, Some(false))
2841 .unwrap()
2842 }
2843 #[inline]
2846 pub fn jumped(&self) -> bool {
2847 self._tab
2848 .get::<bool>(PlayerInfo::VT_JUMPED, Some(false))
2849 .unwrap()
2850 }
2851 #[inline]
2855 pub fn doubleJumped(&self) -> bool {
2856 self._tab
2857 .get::<bool>(PlayerInfo::VT_DOUBLEJUMPED, Some(false))
2858 .unwrap()
2859 }
2860 #[inline]
2861 pub fn name(&self) -> Option<&'a str> {
2862 self._tab
2863 .get::<flatbuffers::ForwardsUOffset<&str>>(PlayerInfo::VT_NAME, None)
2864 }
2865 #[inline]
2866 pub fn team(&self) -> i32 {
2867 self._tab.get::<i32>(PlayerInfo::VT_TEAM, Some(0)).unwrap()
2868 }
2869 #[inline]
2870 pub fn boost(&self) -> i32 {
2871 self._tab.get::<i32>(PlayerInfo::VT_BOOST, Some(0)).unwrap()
2872 }
2873 }
2874
2875 pub struct PlayerInfoArgs<'a> {
2876 pub physics: Option<flatbuffers::WIPOffset<Physics<'a>>>,
2877 pub scoreInfo: Option<flatbuffers::WIPOffset<ScoreInfo<'a>>>,
2878 pub isDemolished: bool,
2879 pub hasWheelContact: bool,
2880 pub isSupersonic: bool,
2881 pub isBot: bool,
2882 pub jumped: bool,
2883 pub doubleJumped: bool,
2884 pub name: Option<flatbuffers::WIPOffset<&'a str>>,
2885 pub team: i32,
2886 pub boost: i32,
2887 }
2888 impl<'a> Default for PlayerInfoArgs<'a> {
2889 #[inline]
2890 fn default() -> Self {
2891 PlayerInfoArgs {
2892 physics: None,
2893 scoreInfo: None,
2894 isDemolished: false,
2895 hasWheelContact: false,
2896 isSupersonic: false,
2897 isBot: false,
2898 jumped: false,
2899 doubleJumped: false,
2900 name: None,
2901 team: 0,
2902 boost: 0,
2903 }
2904 }
2905 }
2906 pub struct PlayerInfoBuilder<'a: 'b, 'b> {
2907 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
2908 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
2909 }
2910 impl<'a: 'b, 'b> PlayerInfoBuilder<'a, 'b> {
2911 #[inline]
2912 pub fn add_physics(&mut self, physics: flatbuffers::WIPOffset<Physics<'b>>) {
2913 self.fbb_
2914 .push_slot_always::<flatbuffers::WIPOffset<Physics<'_>>>(
2915 PlayerInfo::VT_PHYSICS,
2916 physics,
2917 );
2918 }
2919 #[inline]
2920 pub fn add_scoreInfo(&mut self, scoreInfo: flatbuffers::WIPOffset<ScoreInfo<'b>>) {
2921 self.fbb_
2922 .push_slot_always::<flatbuffers::WIPOffset<ScoreInfo<'_>>>(
2923 PlayerInfo::VT_SCOREINFO,
2924 scoreInfo,
2925 );
2926 }
2927 #[inline]
2928 pub fn add_isDemolished(&mut self, isDemolished: bool) {
2929 self.fbb_
2930 .push_slot::<bool>(PlayerInfo::VT_ISDEMOLISHED, isDemolished, false);
2931 }
2932 #[inline]
2933 pub fn add_hasWheelContact(&mut self, hasWheelContact: bool) {
2934 self.fbb_
2935 .push_slot::<bool>(PlayerInfo::VT_HASWHEELCONTACT, hasWheelContact, false);
2936 }
2937 #[inline]
2938 pub fn add_isSupersonic(&mut self, isSupersonic: bool) {
2939 self.fbb_
2940 .push_slot::<bool>(PlayerInfo::VT_ISSUPERSONIC, isSupersonic, false);
2941 }
2942 #[inline]
2943 pub fn add_isBot(&mut self, isBot: bool) {
2944 self.fbb_
2945 .push_slot::<bool>(PlayerInfo::VT_ISBOT, isBot, false);
2946 }
2947 #[inline]
2948 pub fn add_jumped(&mut self, jumped: bool) {
2949 self.fbb_
2950 .push_slot::<bool>(PlayerInfo::VT_JUMPED, jumped, false);
2951 }
2952 #[inline]
2953 pub fn add_doubleJumped(&mut self, doubleJumped: bool) {
2954 self.fbb_
2955 .push_slot::<bool>(PlayerInfo::VT_DOUBLEJUMPED, doubleJumped, false);
2956 }
2957 #[inline]
2958 pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
2959 self.fbb_
2960 .push_slot_always::<flatbuffers::WIPOffset<_>>(PlayerInfo::VT_NAME, name);
2961 }
2962 #[inline]
2963 pub fn add_team(&mut self, team: i32) {
2964 self.fbb_.push_slot::<i32>(PlayerInfo::VT_TEAM, team, 0);
2965 }
2966 #[inline]
2967 pub fn add_boost(&mut self, boost: i32) {
2968 self.fbb_.push_slot::<i32>(PlayerInfo::VT_BOOST, boost, 0);
2969 }
2970 #[inline]
2971 pub fn new(
2972 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
2973 ) -> PlayerInfoBuilder<'a, 'b> {
2974 let start = _fbb.start_table();
2975 PlayerInfoBuilder {
2976 fbb_: _fbb,
2977 start_: start,
2978 }
2979 }
2980 #[inline]
2981 pub fn finish(self) -> flatbuffers::WIPOffset<PlayerInfo<'a>> {
2982 let o = self.fbb_.end_table(self.start_);
2983 flatbuffers::WIPOffset::new(o.value())
2984 }
2985 }
2986
2987 pub enum DropShotBallInfoOffset {}
2988 #[derive(Copy, Clone, Debug, PartialEq)]
2989
2990 pub struct DropShotBallInfo<'a> {
2991 pub _tab: flatbuffers::Table<'a>,
2992 }
2993
2994 impl<'a> flatbuffers::Follow<'a> for DropShotBallInfo<'a> {
2995 type Inner = DropShotBallInfo<'a>;
2996 #[inline]
2997 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
2998 Self {
2999 _tab: flatbuffers::Table { buf, loc },
3000 }
3001 }
3002 }
3003
3004 impl<'a> DropShotBallInfo<'a> {
3005 #[inline]
3006 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
3007 DropShotBallInfo { _tab: table }
3008 }
3009 #[allow(unused_mut)]
3010 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
3011 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
3012 args: &'args DropShotBallInfoArgs,
3013 ) -> flatbuffers::WIPOffset<DropShotBallInfo<'bldr>> {
3014 let mut builder = DropShotBallInfoBuilder::new(_fbb);
3015 builder.add_forceAccumRecent(args.forceAccumRecent);
3016 builder.add_damageIndex(args.damageIndex);
3017 builder.add_absorbedForce(args.absorbedForce);
3018 builder.finish()
3019 }
3020
3021 pub const VT_ABSORBEDFORCE: flatbuffers::VOffsetT = 4;
3022 pub const VT_DAMAGEINDEX: flatbuffers::VOffsetT = 6;
3023 pub const VT_FORCEACCUMRECENT: flatbuffers::VOffsetT = 8;
3024
3025 #[inline]
3026 pub fn absorbedForce(&self) -> f32 {
3027 self._tab
3028 .get::<f32>(DropShotBallInfo::VT_ABSORBEDFORCE, Some(0.0))
3029 .unwrap()
3030 }
3031 #[inline]
3032 pub fn damageIndex(&self) -> i32 {
3033 self._tab
3034 .get::<i32>(DropShotBallInfo::VT_DAMAGEINDEX, Some(0))
3035 .unwrap()
3036 }
3037 #[inline]
3038 pub fn forceAccumRecent(&self) -> f32 {
3039 self._tab
3040 .get::<f32>(DropShotBallInfo::VT_FORCEACCUMRECENT, Some(0.0))
3041 .unwrap()
3042 }
3043 }
3044
3045 pub struct DropShotBallInfoArgs {
3046 pub absorbedForce: f32,
3047 pub damageIndex: i32,
3048 pub forceAccumRecent: f32,
3049 }
3050 impl<'a> Default for DropShotBallInfoArgs {
3051 #[inline]
3052 fn default() -> Self {
3053 DropShotBallInfoArgs {
3054 absorbedForce: 0.0,
3055 damageIndex: 0,
3056 forceAccumRecent: 0.0,
3057 }
3058 }
3059 }
3060 pub struct DropShotBallInfoBuilder<'a: 'b, 'b> {
3061 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3062 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
3063 }
3064 impl<'a: 'b, 'b> DropShotBallInfoBuilder<'a, 'b> {
3065 #[inline]
3066 pub fn add_absorbedForce(&mut self, absorbedForce: f32) {
3067 self.fbb_
3068 .push_slot::<f32>(DropShotBallInfo::VT_ABSORBEDFORCE, absorbedForce, 0.0);
3069 }
3070 #[inline]
3071 pub fn add_damageIndex(&mut self, damageIndex: i32) {
3072 self.fbb_
3073 .push_slot::<i32>(DropShotBallInfo::VT_DAMAGEINDEX, damageIndex, 0);
3074 }
3075 #[inline]
3076 pub fn add_forceAccumRecent(&mut self, forceAccumRecent: f32) {
3077 self.fbb_.push_slot::<f32>(
3078 DropShotBallInfo::VT_FORCEACCUMRECENT,
3079 forceAccumRecent,
3080 0.0,
3081 );
3082 }
3083 #[inline]
3084 pub fn new(
3085 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3086 ) -> DropShotBallInfoBuilder<'a, 'b> {
3087 let start = _fbb.start_table();
3088 DropShotBallInfoBuilder {
3089 fbb_: _fbb,
3090 start_: start,
3091 }
3092 }
3093 #[inline]
3094 pub fn finish(self) -> flatbuffers::WIPOffset<DropShotBallInfo<'a>> {
3095 let o = self.fbb_.end_table(self.start_);
3096 flatbuffers::WIPOffset::new(o.value())
3097 }
3098 }
3099
3100 pub enum BallInfoOffset {}
3101 #[derive(Copy, Clone, Debug, PartialEq)]
3102
3103 pub struct BallInfo<'a> {
3104 pub _tab: flatbuffers::Table<'a>,
3105 }
3106
3107 impl<'a> flatbuffers::Follow<'a> for BallInfo<'a> {
3108 type Inner = BallInfo<'a>;
3109 #[inline]
3110 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
3111 Self {
3112 _tab: flatbuffers::Table { buf, loc },
3113 }
3114 }
3115 }
3116
3117 impl<'a> BallInfo<'a> {
3118 #[inline]
3119 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
3120 BallInfo { _tab: table }
3121 }
3122 #[allow(unused_mut)]
3123 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
3124 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
3125 args: &'args BallInfoArgs<'args>,
3126 ) -> flatbuffers::WIPOffset<BallInfo<'bldr>> {
3127 let mut builder = BallInfoBuilder::new(_fbb);
3128 if let Some(x) = args.dropShotInfo {
3129 builder.add_dropShotInfo(x);
3130 }
3131 if let Some(x) = args.latestTouch {
3132 builder.add_latestTouch(x);
3133 }
3134 if let Some(x) = args.physics {
3135 builder.add_physics(x);
3136 }
3137 builder.finish()
3138 }
3139
3140 pub const VT_PHYSICS: flatbuffers::VOffsetT = 4;
3141 pub const VT_LATESTTOUCH: flatbuffers::VOffsetT = 6;
3142 pub const VT_DROPSHOTINFO: flatbuffers::VOffsetT = 8;
3143
3144 #[inline]
3145 pub fn physics(&self) -> Option<Physics<'a>> {
3146 self._tab
3147 .get::<flatbuffers::ForwardsUOffset<Physics<'a>>>(BallInfo::VT_PHYSICS, None)
3148 }
3149 #[inline]
3150 pub fn latestTouch(&self) -> Option<Touch<'a>> {
3151 self._tab
3152 .get::<flatbuffers::ForwardsUOffset<Touch<'a>>>(BallInfo::VT_LATESTTOUCH, None)
3153 }
3154 #[inline]
3155 pub fn dropShotInfo(&self) -> Option<DropShotBallInfo<'a>> {
3156 self._tab
3157 .get::<flatbuffers::ForwardsUOffset<DropShotBallInfo<'a>>>(
3158 BallInfo::VT_DROPSHOTINFO,
3159 None,
3160 )
3161 }
3162 }
3163
3164 pub struct BallInfoArgs<'a> {
3165 pub physics: Option<flatbuffers::WIPOffset<Physics<'a>>>,
3166 pub latestTouch: Option<flatbuffers::WIPOffset<Touch<'a>>>,
3167 pub dropShotInfo: Option<flatbuffers::WIPOffset<DropShotBallInfo<'a>>>,
3168 }
3169 impl<'a> Default for BallInfoArgs<'a> {
3170 #[inline]
3171 fn default() -> Self {
3172 BallInfoArgs {
3173 physics: None,
3174 latestTouch: None,
3175 dropShotInfo: None,
3176 }
3177 }
3178 }
3179 pub struct BallInfoBuilder<'a: 'b, 'b> {
3180 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3181 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
3182 }
3183 impl<'a: 'b, 'b> BallInfoBuilder<'a, 'b> {
3184 #[inline]
3185 pub fn add_physics(&mut self, physics: flatbuffers::WIPOffset<Physics<'b>>) {
3186 self.fbb_
3187 .push_slot_always::<flatbuffers::WIPOffset<Physics<'_>>>(
3188 BallInfo::VT_PHYSICS,
3189 physics,
3190 );
3191 }
3192 #[inline]
3193 pub fn add_latestTouch(&mut self, latestTouch: flatbuffers::WIPOffset<Touch<'b>>) {
3194 self.fbb_
3195 .push_slot_always::<flatbuffers::WIPOffset<Touch<'_>>>(
3196 BallInfo::VT_LATESTTOUCH,
3197 latestTouch,
3198 );
3199 }
3200 #[inline]
3201 pub fn add_dropShotInfo(
3202 &mut self,
3203 dropShotInfo: flatbuffers::WIPOffset<DropShotBallInfo<'b>>,
3204 ) {
3205 self.fbb_
3206 .push_slot_always::<flatbuffers::WIPOffset<DropShotBallInfo<'_>>>(
3207 BallInfo::VT_DROPSHOTINFO,
3208 dropShotInfo,
3209 );
3210 }
3211 #[inline]
3212 pub fn new(
3213 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3214 ) -> BallInfoBuilder<'a, 'b> {
3215 let start = _fbb.start_table();
3216 BallInfoBuilder {
3217 fbb_: _fbb,
3218 start_: start,
3219 }
3220 }
3221 #[inline]
3222 pub fn finish(self) -> flatbuffers::WIPOffset<BallInfo<'a>> {
3223 let o = self.fbb_.end_table(self.start_);
3224 flatbuffers::WIPOffset::new(o.value())
3225 }
3226 }
3227
3228 pub enum BoostPadStateOffset {}
3229 #[derive(Copy, Clone, Debug, PartialEq)]
3230
3231 pub struct BoostPadState<'a> {
3232 pub _tab: flatbuffers::Table<'a>,
3233 }
3234
3235 impl<'a> flatbuffers::Follow<'a> for BoostPadState<'a> {
3236 type Inner = BoostPadState<'a>;
3237 #[inline]
3238 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
3239 Self {
3240 _tab: flatbuffers::Table { buf, loc },
3241 }
3242 }
3243 }
3244
3245 impl<'a> BoostPadState<'a> {
3246 #[inline]
3247 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
3248 BoostPadState { _tab: table }
3249 }
3250 #[allow(unused_mut)]
3251 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
3252 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
3253 args: &'args BoostPadStateArgs,
3254 ) -> flatbuffers::WIPOffset<BoostPadState<'bldr>> {
3255 let mut builder = BoostPadStateBuilder::new(_fbb);
3256 builder.add_timer(args.timer);
3257 builder.add_isActive(args.isActive);
3258 builder.finish()
3259 }
3260
3261 pub const VT_ISACTIVE: flatbuffers::VOffsetT = 4;
3262 pub const VT_TIMER: flatbuffers::VOffsetT = 6;
3263
3264 #[inline]
3266 pub fn isActive(&self) -> bool {
3267 self._tab
3268 .get::<bool>(BoostPadState::VT_ISACTIVE, Some(false))
3269 .unwrap()
3270 }
3271 #[inline]
3274 pub fn timer(&self) -> f32 {
3275 self._tab
3276 .get::<f32>(BoostPadState::VT_TIMER, Some(0.0))
3277 .unwrap()
3278 }
3279 }
3280
3281 pub struct BoostPadStateArgs {
3282 pub isActive: bool,
3283 pub timer: f32,
3284 }
3285 impl<'a> Default for BoostPadStateArgs {
3286 #[inline]
3287 fn default() -> Self {
3288 BoostPadStateArgs {
3289 isActive: false,
3290 timer: 0.0,
3291 }
3292 }
3293 }
3294 pub struct BoostPadStateBuilder<'a: 'b, 'b> {
3295 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3296 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
3297 }
3298 impl<'a: 'b, 'b> BoostPadStateBuilder<'a, 'b> {
3299 #[inline]
3300 pub fn add_isActive(&mut self, isActive: bool) {
3301 self.fbb_
3302 .push_slot::<bool>(BoostPadState::VT_ISACTIVE, isActive, false);
3303 }
3304 #[inline]
3305 pub fn add_timer(&mut self, timer: f32) {
3306 self.fbb_
3307 .push_slot::<f32>(BoostPadState::VT_TIMER, timer, 0.0);
3308 }
3309 #[inline]
3310 pub fn new(
3311 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3312 ) -> BoostPadStateBuilder<'a, 'b> {
3313 let start = _fbb.start_table();
3314 BoostPadStateBuilder {
3315 fbb_: _fbb,
3316 start_: start,
3317 }
3318 }
3319 #[inline]
3320 pub fn finish(self) -> flatbuffers::WIPOffset<BoostPadState<'a>> {
3321 let o = self.fbb_.end_table(self.start_);
3322 flatbuffers::WIPOffset::new(o.value())
3323 }
3324 }
3325
3326 pub enum DropshotTileOffset {}
3327 #[derive(Copy, Clone, Debug, PartialEq)]
3328
3329 pub struct DropshotTile<'a> {
3330 pub _tab: flatbuffers::Table<'a>,
3331 }
3332
3333 impl<'a> flatbuffers::Follow<'a> for DropshotTile<'a> {
3334 type Inner = DropshotTile<'a>;
3335 #[inline]
3336 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
3337 Self {
3338 _tab: flatbuffers::Table { buf, loc },
3339 }
3340 }
3341 }
3342
3343 impl<'a> DropshotTile<'a> {
3344 #[inline]
3345 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
3346 DropshotTile { _tab: table }
3347 }
3348 #[allow(unused_mut)]
3349 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
3350 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
3351 args: &'args DropshotTileArgs,
3352 ) -> flatbuffers::WIPOffset<DropshotTile<'bldr>> {
3353 let mut builder = DropshotTileBuilder::new(_fbb);
3354 builder.add_tileState(args.tileState);
3355 builder.finish()
3356 }
3357
3358 pub const VT_TILESTATE: flatbuffers::VOffsetT = 4;
3359
3360 #[inline]
3362 pub fn tileState(&self) -> TileState {
3363 self._tab
3364 .get::<TileState>(DropshotTile::VT_TILESTATE, Some(TileState::Unknown))
3365 .unwrap()
3366 }
3367 }
3368
3369 pub struct DropshotTileArgs {
3370 pub tileState: TileState,
3371 }
3372 impl<'a> Default for DropshotTileArgs {
3373 #[inline]
3374 fn default() -> Self {
3375 DropshotTileArgs {
3376 tileState: TileState::Unknown,
3377 }
3378 }
3379 }
3380 pub struct DropshotTileBuilder<'a: 'b, 'b> {
3381 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3382 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
3383 }
3384 impl<'a: 'b, 'b> DropshotTileBuilder<'a, 'b> {
3385 #[inline]
3386 pub fn add_tileState(&mut self, tileState: TileState) {
3387 self.fbb_.push_slot::<TileState>(
3388 DropshotTile::VT_TILESTATE,
3389 tileState,
3390 TileState::Unknown,
3391 );
3392 }
3393 #[inline]
3394 pub fn new(
3395 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3396 ) -> DropshotTileBuilder<'a, 'b> {
3397 let start = _fbb.start_table();
3398 DropshotTileBuilder {
3399 fbb_: _fbb,
3400 start_: start,
3401 }
3402 }
3403 #[inline]
3404 pub fn finish(self) -> flatbuffers::WIPOffset<DropshotTile<'a>> {
3405 let o = self.fbb_.end_table(self.start_);
3406 flatbuffers::WIPOffset::new(o.value())
3407 }
3408 }
3409
3410 pub enum GameInfoOffset {}
3411 #[derive(Copy, Clone, Debug, PartialEq)]
3412
3413 pub struct GameInfo<'a> {
3414 pub _tab: flatbuffers::Table<'a>,
3415 }
3416
3417 impl<'a> flatbuffers::Follow<'a> for GameInfo<'a> {
3418 type Inner = GameInfo<'a>;
3419 #[inline]
3420 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
3421 Self {
3422 _tab: flatbuffers::Table { buf, loc },
3423 }
3424 }
3425 }
3426
3427 impl<'a> GameInfo<'a> {
3428 #[inline]
3429 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
3430 GameInfo { _tab: table }
3431 }
3432 #[allow(unused_mut)]
3433 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
3434 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
3435 args: &'args GameInfoArgs,
3436 ) -> flatbuffers::WIPOffset<GameInfo<'bldr>> {
3437 let mut builder = GameInfoBuilder::new(_fbb);
3438 builder.add_gameSpeed(args.gameSpeed);
3439 builder.add_worldGravityZ(args.worldGravityZ);
3440 builder.add_gameTimeRemaining(args.gameTimeRemaining);
3441 builder.add_secondsElapsed(args.secondsElapsed);
3442 builder.add_isMatchEnded(args.isMatchEnded);
3443 builder.add_isKickoffPause(args.isKickoffPause);
3444 builder.add_isRoundActive(args.isRoundActive);
3445 builder.add_isUnlimitedTime(args.isUnlimitedTime);
3446 builder.add_isOvertime(args.isOvertime);
3447 builder.finish()
3448 }
3449
3450 pub const VT_SECONDSELAPSED: flatbuffers::VOffsetT = 4;
3451 pub const VT_GAMETIMEREMAINING: flatbuffers::VOffsetT = 6;
3452 pub const VT_ISOVERTIME: flatbuffers::VOffsetT = 8;
3453 pub const VT_ISUNLIMITEDTIME: flatbuffers::VOffsetT = 10;
3454 pub const VT_ISROUNDACTIVE: flatbuffers::VOffsetT = 12;
3455 pub const VT_ISKICKOFFPAUSE: flatbuffers::VOffsetT = 14;
3456 pub const VT_ISMATCHENDED: flatbuffers::VOffsetT = 16;
3457 pub const VT_WORLDGRAVITYZ: flatbuffers::VOffsetT = 18;
3458 pub const VT_GAMESPEED: flatbuffers::VOffsetT = 20;
3459
3460 #[inline]
3461 pub fn secondsElapsed(&self) -> f32 {
3462 self._tab
3463 .get::<f32>(GameInfo::VT_SECONDSELAPSED, Some(0.0))
3464 .unwrap()
3465 }
3466 #[inline]
3467 pub fn gameTimeRemaining(&self) -> f32 {
3468 self._tab
3469 .get::<f32>(GameInfo::VT_GAMETIMEREMAINING, Some(0.0))
3470 .unwrap()
3471 }
3472 #[inline]
3473 pub fn isOvertime(&self) -> bool {
3474 self._tab
3475 .get::<bool>(GameInfo::VT_ISOVERTIME, Some(false))
3476 .unwrap()
3477 }
3478 #[inline]
3479 pub fn isUnlimitedTime(&self) -> bool {
3480 self._tab
3481 .get::<bool>(GameInfo::VT_ISUNLIMITEDTIME, Some(false))
3482 .unwrap()
3483 }
3484 #[inline]
3487 pub fn isRoundActive(&self) -> bool {
3488 self._tab
3489 .get::<bool>(GameInfo::VT_ISROUNDACTIVE, Some(false))
3490 .unwrap()
3491 }
3492 #[inline]
3497 pub fn isKickoffPause(&self) -> bool {
3498 self._tab
3499 .get::<bool>(GameInfo::VT_ISKICKOFFPAUSE, Some(false))
3500 .unwrap()
3501 }
3502 #[inline]
3507 pub fn isMatchEnded(&self) -> bool {
3508 self._tab
3509 .get::<bool>(GameInfo::VT_ISMATCHENDED, Some(false))
3510 .unwrap()
3511 }
3512 #[inline]
3513 pub fn worldGravityZ(&self) -> f32 {
3514 self._tab
3515 .get::<f32>(GameInfo::VT_WORLDGRAVITYZ, Some(0.0))
3516 .unwrap()
3517 }
3518 #[inline]
3520 pub fn gameSpeed(&self) -> f32 {
3521 self._tab
3522 .get::<f32>(GameInfo::VT_GAMESPEED, Some(0.0))
3523 .unwrap()
3524 }
3525 }
3526
3527 pub struct GameInfoArgs {
3528 pub secondsElapsed: f32,
3529 pub gameTimeRemaining: f32,
3530 pub isOvertime: bool,
3531 pub isUnlimitedTime: bool,
3532 pub isRoundActive: bool,
3533 pub isKickoffPause: bool,
3534 pub isMatchEnded: bool,
3535 pub worldGravityZ: f32,
3536 pub gameSpeed: f32,
3537 }
3538 impl<'a> Default for GameInfoArgs {
3539 #[inline]
3540 fn default() -> Self {
3541 GameInfoArgs {
3542 secondsElapsed: 0.0,
3543 gameTimeRemaining: 0.0,
3544 isOvertime: false,
3545 isUnlimitedTime: false,
3546 isRoundActive: false,
3547 isKickoffPause: false,
3548 isMatchEnded: false,
3549 worldGravityZ: 0.0,
3550 gameSpeed: 0.0,
3551 }
3552 }
3553 }
3554 pub struct GameInfoBuilder<'a: 'b, 'b> {
3555 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3556 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
3557 }
3558 impl<'a: 'b, 'b> GameInfoBuilder<'a, 'b> {
3559 #[inline]
3560 pub fn add_secondsElapsed(&mut self, secondsElapsed: f32) {
3561 self.fbb_
3562 .push_slot::<f32>(GameInfo::VT_SECONDSELAPSED, secondsElapsed, 0.0);
3563 }
3564 #[inline]
3565 pub fn add_gameTimeRemaining(&mut self, gameTimeRemaining: f32) {
3566 self.fbb_
3567 .push_slot::<f32>(GameInfo::VT_GAMETIMEREMAINING, gameTimeRemaining, 0.0);
3568 }
3569 #[inline]
3570 pub fn add_isOvertime(&mut self, isOvertime: bool) {
3571 self.fbb_
3572 .push_slot::<bool>(GameInfo::VT_ISOVERTIME, isOvertime, false);
3573 }
3574 #[inline]
3575 pub fn add_isUnlimitedTime(&mut self, isUnlimitedTime: bool) {
3576 self.fbb_
3577 .push_slot::<bool>(GameInfo::VT_ISUNLIMITEDTIME, isUnlimitedTime, false);
3578 }
3579 #[inline]
3580 pub fn add_isRoundActive(&mut self, isRoundActive: bool) {
3581 self.fbb_
3582 .push_slot::<bool>(GameInfo::VT_ISROUNDACTIVE, isRoundActive, false);
3583 }
3584 #[inline]
3585 pub fn add_isKickoffPause(&mut self, isKickoffPause: bool) {
3586 self.fbb_
3587 .push_slot::<bool>(GameInfo::VT_ISKICKOFFPAUSE, isKickoffPause, false);
3588 }
3589 #[inline]
3590 pub fn add_isMatchEnded(&mut self, isMatchEnded: bool) {
3591 self.fbb_
3592 .push_slot::<bool>(GameInfo::VT_ISMATCHENDED, isMatchEnded, false);
3593 }
3594 #[inline]
3595 pub fn add_worldGravityZ(&mut self, worldGravityZ: f32) {
3596 self.fbb_
3597 .push_slot::<f32>(GameInfo::VT_WORLDGRAVITYZ, worldGravityZ, 0.0);
3598 }
3599 #[inline]
3600 pub fn add_gameSpeed(&mut self, gameSpeed: f32) {
3601 self.fbb_
3602 .push_slot::<f32>(GameInfo::VT_GAMESPEED, gameSpeed, 0.0);
3603 }
3604 #[inline]
3605 pub fn new(
3606 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3607 ) -> GameInfoBuilder<'a, 'b> {
3608 let start = _fbb.start_table();
3609 GameInfoBuilder {
3610 fbb_: _fbb,
3611 start_: start,
3612 }
3613 }
3614 #[inline]
3615 pub fn finish(self) -> flatbuffers::WIPOffset<GameInfo<'a>> {
3616 let o = self.fbb_.end_table(self.start_);
3617 flatbuffers::WIPOffset::new(o.value())
3618 }
3619 }
3620
3621 pub enum TeamInfoOffset {}
3622 #[derive(Copy, Clone, Debug, PartialEq)]
3623
3624 pub struct TeamInfo<'a> {
3625 pub _tab: flatbuffers::Table<'a>,
3626 }
3627
3628 impl<'a> flatbuffers::Follow<'a> for TeamInfo<'a> {
3629 type Inner = TeamInfo<'a>;
3630 #[inline]
3631 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
3632 Self {
3633 _tab: flatbuffers::Table { buf, loc },
3634 }
3635 }
3636 }
3637
3638 impl<'a> TeamInfo<'a> {
3639 #[inline]
3640 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
3641 TeamInfo { _tab: table }
3642 }
3643 #[allow(unused_mut)]
3644 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
3645 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
3646 args: &'args TeamInfoArgs,
3647 ) -> flatbuffers::WIPOffset<TeamInfo<'bldr>> {
3648 let mut builder = TeamInfoBuilder::new(_fbb);
3649 builder.add_score(args.score);
3650 builder.add_teamIndex(args.teamIndex);
3651 builder.finish()
3652 }
3653
3654 pub const VT_TEAMINDEX: flatbuffers::VOffsetT = 4;
3655 pub const VT_SCORE: flatbuffers::VOffsetT = 6;
3656
3657 #[inline]
3658 pub fn teamIndex(&self) -> i32 {
3659 self._tab
3660 .get::<i32>(TeamInfo::VT_TEAMINDEX, Some(0))
3661 .unwrap()
3662 }
3663 #[inline]
3665 pub fn score(&self) -> i32 {
3666 self._tab.get::<i32>(TeamInfo::VT_SCORE, Some(0)).unwrap()
3667 }
3668 }
3669
3670 pub struct TeamInfoArgs {
3671 pub teamIndex: i32,
3672 pub score: i32,
3673 }
3674 impl<'a> Default for TeamInfoArgs {
3675 #[inline]
3676 fn default() -> Self {
3677 TeamInfoArgs {
3678 teamIndex: 0,
3679 score: 0,
3680 }
3681 }
3682 }
3683 pub struct TeamInfoBuilder<'a: 'b, 'b> {
3684 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3685 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
3686 }
3687 impl<'a: 'b, 'b> TeamInfoBuilder<'a, 'b> {
3688 #[inline]
3689 pub fn add_teamIndex(&mut self, teamIndex: i32) {
3690 self.fbb_
3691 .push_slot::<i32>(TeamInfo::VT_TEAMINDEX, teamIndex, 0);
3692 }
3693 #[inline]
3694 pub fn add_score(&mut self, score: i32) {
3695 self.fbb_.push_slot::<i32>(TeamInfo::VT_SCORE, score, 0);
3696 }
3697 #[inline]
3698 pub fn new(
3699 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3700 ) -> TeamInfoBuilder<'a, 'b> {
3701 let start = _fbb.start_table();
3702 TeamInfoBuilder {
3703 fbb_: _fbb,
3704 start_: start,
3705 }
3706 }
3707 #[inline]
3708 pub fn finish(self) -> flatbuffers::WIPOffset<TeamInfo<'a>> {
3709 let o = self.fbb_.end_table(self.start_);
3710 flatbuffers::WIPOffset::new(o.value())
3711 }
3712 }
3713
3714 pub enum GameTickPacketOffset {}
3715 #[derive(Copy, Clone, Debug, PartialEq)]
3716
3717 pub struct GameTickPacket<'a> {
3718 pub _tab: flatbuffers::Table<'a>,
3719 }
3720
3721 impl<'a> flatbuffers::Follow<'a> for GameTickPacket<'a> {
3722 type Inner = GameTickPacket<'a>;
3723 #[inline]
3724 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
3725 Self {
3726 _tab: flatbuffers::Table { buf, loc },
3727 }
3728 }
3729 }
3730
3731 impl<'a> GameTickPacket<'a> {
3732 #[inline]
3733 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
3734 GameTickPacket { _tab: table }
3735 }
3736 #[allow(unused_mut)]
3737 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
3738 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
3739 args: &'args GameTickPacketArgs<'args>,
3740 ) -> flatbuffers::WIPOffset<GameTickPacket<'bldr>> {
3741 let mut builder = GameTickPacketBuilder::new(_fbb);
3742 if let Some(x) = args.teams {
3743 builder.add_teams(x);
3744 }
3745 if let Some(x) = args.tileInformation {
3746 builder.add_tileInformation(x);
3747 }
3748 if let Some(x) = args.gameInfo {
3749 builder.add_gameInfo(x);
3750 }
3751 if let Some(x) = args.ball {
3752 builder.add_ball(x);
3753 }
3754 if let Some(x) = args.boostPadStates {
3755 builder.add_boostPadStates(x);
3756 }
3757 if let Some(x) = args.players {
3758 builder.add_players(x);
3759 }
3760 builder.finish()
3761 }
3762
3763 pub const VT_PLAYERS: flatbuffers::VOffsetT = 4;
3764 pub const VT_BOOSTPADSTATES: flatbuffers::VOffsetT = 6;
3765 pub const VT_BALL: flatbuffers::VOffsetT = 8;
3766 pub const VT_GAMEINFO: flatbuffers::VOffsetT = 10;
3767 pub const VT_TILEINFORMATION: flatbuffers::VOffsetT = 12;
3768 pub const VT_TEAMS: flatbuffers::VOffsetT = 14;
3769
3770 #[inline]
3771 pub fn players(
3772 &self,
3773 ) -> Option<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PlayerInfo<'a>>>>
3774 {
3775 self._tab.get::<flatbuffers::ForwardsUOffset<
3776 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PlayerInfo<'a>>>,
3777 >>(GameTickPacket::VT_PLAYERS, None)
3778 }
3779 #[inline]
3780 pub fn boostPadStates(
3781 &self,
3782 ) -> Option<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<BoostPadState<'a>>>>
3783 {
3784 self._tab.get::<flatbuffers::ForwardsUOffset<
3785 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<BoostPadState<'a>>>,
3786 >>(GameTickPacket::VT_BOOSTPADSTATES, None)
3787 }
3788 #[inline]
3789 pub fn ball(&self) -> Option<BallInfo<'a>> {
3790 self._tab.get::<flatbuffers::ForwardsUOffset<BallInfo<'a>>>(
3791 GameTickPacket::VT_BALL,
3792 None,
3793 )
3794 }
3795 #[inline]
3796 pub fn gameInfo(&self) -> Option<GameInfo<'a>> {
3797 self._tab.get::<flatbuffers::ForwardsUOffset<GameInfo<'a>>>(
3798 GameTickPacket::VT_GAMEINFO,
3799 None,
3800 )
3801 }
3802 #[inline]
3803 pub fn tileInformation(
3804 &self,
3805 ) -> Option<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<DropshotTile<'a>>>>
3806 {
3807 self._tab.get::<flatbuffers::ForwardsUOffset<
3808 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<DropshotTile<'a>>>,
3809 >>(GameTickPacket::VT_TILEINFORMATION, None)
3810 }
3811 #[inline]
3812 pub fn teams(
3813 &self,
3814 ) -> Option<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TeamInfo<'a>>>>
3815 {
3816 self._tab.get::<flatbuffers::ForwardsUOffset<
3817 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TeamInfo<'a>>>,
3818 >>(GameTickPacket::VT_TEAMS, None)
3819 }
3820 }
3821
3822 pub struct GameTickPacketArgs<'a> {
3823 pub players: Option<
3824 flatbuffers::WIPOffset<
3825 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PlayerInfo<'a>>>,
3826 >,
3827 >,
3828 pub boostPadStates: Option<
3829 flatbuffers::WIPOffset<
3830 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<BoostPadState<'a>>>,
3831 >,
3832 >,
3833 pub ball: Option<flatbuffers::WIPOffset<BallInfo<'a>>>,
3834 pub gameInfo: Option<flatbuffers::WIPOffset<GameInfo<'a>>>,
3835 pub tileInformation: Option<
3836 flatbuffers::WIPOffset<
3837 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<DropshotTile<'a>>>,
3838 >,
3839 >,
3840 pub teams: Option<
3841 flatbuffers::WIPOffset<
3842 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TeamInfo<'a>>>,
3843 >,
3844 >,
3845 }
3846 impl<'a> Default for GameTickPacketArgs<'a> {
3847 #[inline]
3848 fn default() -> Self {
3849 GameTickPacketArgs {
3850 players: None,
3851 boostPadStates: None,
3852 ball: None,
3853 gameInfo: None,
3854 tileInformation: None,
3855 teams: None,
3856 }
3857 }
3858 }
3859 pub struct GameTickPacketBuilder<'a: 'b, 'b> {
3860 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3861 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
3862 }
3863 impl<'a: 'b, 'b> GameTickPacketBuilder<'a, 'b> {
3864 #[inline]
3865 pub fn add_players(
3866 &mut self,
3867 players: flatbuffers::WIPOffset<
3868 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<PlayerInfo<'b>>>,
3869 >,
3870 ) {
3871 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
3872 GameTickPacket::VT_PLAYERS,
3873 players,
3874 );
3875 }
3876 #[inline]
3877 pub fn add_boostPadStates(
3878 &mut self,
3879 boostPadStates: flatbuffers::WIPOffset<
3880 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<BoostPadState<'b>>>,
3881 >,
3882 ) {
3883 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
3884 GameTickPacket::VT_BOOSTPADSTATES,
3885 boostPadStates,
3886 );
3887 }
3888 #[inline]
3889 pub fn add_ball(&mut self, ball: flatbuffers::WIPOffset<BallInfo<'b>>) {
3890 self.fbb_
3891 .push_slot_always::<flatbuffers::WIPOffset<BallInfo<'_>>>(
3892 GameTickPacket::VT_BALL,
3893 ball,
3894 );
3895 }
3896 #[inline]
3897 pub fn add_gameInfo(&mut self, gameInfo: flatbuffers::WIPOffset<GameInfo<'b>>) {
3898 self.fbb_
3899 .push_slot_always::<flatbuffers::WIPOffset<GameInfo<'_>>>(
3900 GameTickPacket::VT_GAMEINFO,
3901 gameInfo,
3902 );
3903 }
3904 #[inline]
3905 pub fn add_tileInformation(
3906 &mut self,
3907 tileInformation: flatbuffers::WIPOffset<
3908 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<DropshotTile<'b>>>,
3909 >,
3910 ) {
3911 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
3912 GameTickPacket::VT_TILEINFORMATION,
3913 tileInformation,
3914 );
3915 }
3916 #[inline]
3917 pub fn add_teams(
3918 &mut self,
3919 teams: flatbuffers::WIPOffset<
3920 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<TeamInfo<'b>>>,
3921 >,
3922 ) {
3923 self.fbb_
3924 .push_slot_always::<flatbuffers::WIPOffset<_>>(GameTickPacket::VT_TEAMS, teams);
3925 }
3926 #[inline]
3927 pub fn new(
3928 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
3929 ) -> GameTickPacketBuilder<'a, 'b> {
3930 let start = _fbb.start_table();
3931 GameTickPacketBuilder {
3932 fbb_: _fbb,
3933 start_: start,
3934 }
3935 }
3936 #[inline]
3937 pub fn finish(self) -> flatbuffers::WIPOffset<GameTickPacket<'a>> {
3938 let o = self.fbb_.end_table(self.start_);
3939 flatbuffers::WIPOffset::new(o.value())
3940 }
3941 }
3942
3943 pub enum RigidBodyStateOffset {}
3948 #[derive(Copy, Clone, Debug, PartialEq)]
3949
3950 pub struct RigidBodyState<'a> {
3951 pub _tab: flatbuffers::Table<'a>,
3952 }
3953
3954 impl<'a> flatbuffers::Follow<'a> for RigidBodyState<'a> {
3955 type Inner = RigidBodyState<'a>;
3956 #[inline]
3957 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
3958 Self {
3959 _tab: flatbuffers::Table { buf, loc },
3960 }
3961 }
3962 }
3963
3964 impl<'a> RigidBodyState<'a> {
3965 #[inline]
3966 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
3967 RigidBodyState { _tab: table }
3968 }
3969 #[allow(unused_mut)]
3970 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
3971 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
3972 args: &'args RigidBodyStateArgs<'args>,
3973 ) -> flatbuffers::WIPOffset<RigidBodyState<'bldr>> {
3974 let mut builder = RigidBodyStateBuilder::new(_fbb);
3975 if let Some(x) = args.angularVelocity {
3976 builder.add_angularVelocity(x);
3977 }
3978 if let Some(x) = args.velocity {
3979 builder.add_velocity(x);
3980 }
3981 if let Some(x) = args.rotation {
3982 builder.add_rotation(x);
3983 }
3984 if let Some(x) = args.location {
3985 builder.add_location(x);
3986 }
3987 builder.add_frame(args.frame);
3988 builder.finish()
3989 }
3990
3991 pub const VT_FRAME: flatbuffers::VOffsetT = 4;
3992 pub const VT_LOCATION: flatbuffers::VOffsetT = 6;
3993 pub const VT_ROTATION: flatbuffers::VOffsetT = 8;
3994 pub const VT_VELOCITY: flatbuffers::VOffsetT = 10;
3995 pub const VT_ANGULARVELOCITY: flatbuffers::VOffsetT = 12;
3996
3997 #[inline]
3998 pub fn frame(&self) -> i32 {
3999 self._tab
4000 .get::<i32>(RigidBodyState::VT_FRAME, Some(0))
4001 .unwrap()
4002 }
4003 #[inline]
4004 pub fn location(&self) -> Option<&'a Vector3> {
4005 self._tab.get::<Vector3>(RigidBodyState::VT_LOCATION, None)
4006 }
4007 #[inline]
4008 pub fn rotation(&self) -> Option<&'a Quaternion> {
4009 self._tab
4010 .get::<Quaternion>(RigidBodyState::VT_ROTATION, None)
4011 }
4012 #[inline]
4013 pub fn velocity(&self) -> Option<&'a Vector3> {
4014 self._tab.get::<Vector3>(RigidBodyState::VT_VELOCITY, None)
4015 }
4016 #[inline]
4017 pub fn angularVelocity(&self) -> Option<&'a Vector3> {
4018 self._tab
4019 .get::<Vector3>(RigidBodyState::VT_ANGULARVELOCITY, None)
4020 }
4021 }
4022
4023 pub struct RigidBodyStateArgs<'a> {
4024 pub frame: i32,
4025 pub location: Option<&'a Vector3>,
4026 pub rotation: Option<&'a Quaternion>,
4027 pub velocity: Option<&'a Vector3>,
4028 pub angularVelocity: Option<&'a Vector3>,
4029 }
4030 impl<'a> Default for RigidBodyStateArgs<'a> {
4031 #[inline]
4032 fn default() -> Self {
4033 RigidBodyStateArgs {
4034 frame: 0,
4035 location: None,
4036 rotation: None,
4037 velocity: None,
4038 angularVelocity: None,
4039 }
4040 }
4041 }
4042 pub struct RigidBodyStateBuilder<'a: 'b, 'b> {
4043 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4044 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
4045 }
4046 impl<'a: 'b, 'b> RigidBodyStateBuilder<'a, 'b> {
4047 #[inline]
4048 pub fn add_frame(&mut self, frame: i32) {
4049 self.fbb_
4050 .push_slot::<i32>(RigidBodyState::VT_FRAME, frame, 0);
4051 }
4052 #[inline]
4053 pub fn add_location(&mut self, location: &'b Vector3) {
4054 self.fbb_
4055 .push_slot_always::<&Vector3>(RigidBodyState::VT_LOCATION, location);
4056 }
4057 #[inline]
4058 pub fn add_rotation(&mut self, rotation: &'b Quaternion) {
4059 self.fbb_
4060 .push_slot_always::<&Quaternion>(RigidBodyState::VT_ROTATION, rotation);
4061 }
4062 #[inline]
4063 pub fn add_velocity(&mut self, velocity: &'b Vector3) {
4064 self.fbb_
4065 .push_slot_always::<&Vector3>(RigidBodyState::VT_VELOCITY, velocity);
4066 }
4067 #[inline]
4068 pub fn add_angularVelocity(&mut self, angularVelocity: &'b Vector3) {
4069 self.fbb_.push_slot_always::<&Vector3>(
4070 RigidBodyState::VT_ANGULARVELOCITY,
4071 angularVelocity,
4072 );
4073 }
4074 #[inline]
4075 pub fn new(
4076 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4077 ) -> RigidBodyStateBuilder<'a, 'b> {
4078 let start = _fbb.start_table();
4079 RigidBodyStateBuilder {
4080 fbb_: _fbb,
4081 start_: start,
4082 }
4083 }
4084 #[inline]
4085 pub fn finish(self) -> flatbuffers::WIPOffset<RigidBodyState<'a>> {
4086 let o = self.fbb_.end_table(self.start_);
4087 flatbuffers::WIPOffset::new(o.value())
4088 }
4089 }
4090
4091 pub enum PlayerRigidBodyStateOffset {}
4095 #[derive(Copy, Clone, Debug, PartialEq)]
4096
4097 pub struct PlayerRigidBodyState<'a> {
4098 pub _tab: flatbuffers::Table<'a>,
4099 }
4100
4101 impl<'a> flatbuffers::Follow<'a> for PlayerRigidBodyState<'a> {
4102 type Inner = PlayerRigidBodyState<'a>;
4103 #[inline]
4104 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
4105 Self {
4106 _tab: flatbuffers::Table { buf, loc },
4107 }
4108 }
4109 }
4110
4111 impl<'a> PlayerRigidBodyState<'a> {
4112 #[inline]
4113 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
4114 PlayerRigidBodyState { _tab: table }
4115 }
4116 #[allow(unused_mut)]
4117 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
4118 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
4119 args: &'args PlayerRigidBodyStateArgs<'args>,
4120 ) -> flatbuffers::WIPOffset<PlayerRigidBodyState<'bldr>> {
4121 let mut builder = PlayerRigidBodyStateBuilder::new(_fbb);
4122 if let Some(x) = args.input {
4123 builder.add_input(x);
4124 }
4125 if let Some(x) = args.state {
4126 builder.add_state(x);
4127 }
4128 builder.finish()
4129 }
4130
4131 pub const VT_STATE: flatbuffers::VOffsetT = 4;
4132 pub const VT_INPUT: flatbuffers::VOffsetT = 6;
4133
4134 #[inline]
4135 pub fn state(&self) -> Option<RigidBodyState<'a>> {
4136 self._tab
4137 .get::<flatbuffers::ForwardsUOffset<RigidBodyState<'a>>>(
4138 PlayerRigidBodyState::VT_STATE,
4139 None,
4140 )
4141 }
4142 #[inline]
4143 pub fn input(&self) -> Option<ControllerState<'a>> {
4144 self._tab
4145 .get::<flatbuffers::ForwardsUOffset<ControllerState<'a>>>(
4146 PlayerRigidBodyState::VT_INPUT,
4147 None,
4148 )
4149 }
4150 }
4151
4152 pub struct PlayerRigidBodyStateArgs<'a> {
4153 pub state: Option<flatbuffers::WIPOffset<RigidBodyState<'a>>>,
4154 pub input: Option<flatbuffers::WIPOffset<ControllerState<'a>>>,
4155 }
4156 impl<'a> Default for PlayerRigidBodyStateArgs<'a> {
4157 #[inline]
4158 fn default() -> Self {
4159 PlayerRigidBodyStateArgs {
4160 state: None,
4161 input: None,
4162 }
4163 }
4164 }
4165 pub struct PlayerRigidBodyStateBuilder<'a: 'b, 'b> {
4166 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4167 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
4168 }
4169 impl<'a: 'b, 'b> PlayerRigidBodyStateBuilder<'a, 'b> {
4170 #[inline]
4171 pub fn add_state(&mut self, state: flatbuffers::WIPOffset<RigidBodyState<'b>>) {
4172 self.fbb_
4173 .push_slot_always::<flatbuffers::WIPOffset<RigidBodyState<'_>>>(
4174 PlayerRigidBodyState::VT_STATE,
4175 state,
4176 );
4177 }
4178 #[inline]
4179 pub fn add_input(&mut self, input: flatbuffers::WIPOffset<ControllerState<'b>>) {
4180 self.fbb_
4181 .push_slot_always::<flatbuffers::WIPOffset<ControllerState<'_>>>(
4182 PlayerRigidBodyState::VT_INPUT,
4183 input,
4184 );
4185 }
4186 #[inline]
4187 pub fn new(
4188 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4189 ) -> PlayerRigidBodyStateBuilder<'a, 'b> {
4190 let start = _fbb.start_table();
4191 PlayerRigidBodyStateBuilder {
4192 fbb_: _fbb,
4193 start_: start,
4194 }
4195 }
4196 #[inline]
4197 pub fn finish(self) -> flatbuffers::WIPOffset<PlayerRigidBodyState<'a>> {
4198 let o = self.fbb_.end_table(self.start_);
4199 flatbuffers::WIPOffset::new(o.value())
4200 }
4201 }
4202
4203 pub enum BallRigidBodyStateOffset {}
4205 #[derive(Copy, Clone, Debug, PartialEq)]
4206
4207 pub struct BallRigidBodyState<'a> {
4208 pub _tab: flatbuffers::Table<'a>,
4209 }
4210
4211 impl<'a> flatbuffers::Follow<'a> for BallRigidBodyState<'a> {
4212 type Inner = BallRigidBodyState<'a>;
4213 #[inline]
4214 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
4215 Self {
4216 _tab: flatbuffers::Table { buf, loc },
4217 }
4218 }
4219 }
4220
4221 impl<'a> BallRigidBodyState<'a> {
4222 #[inline]
4223 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
4224 BallRigidBodyState { _tab: table }
4225 }
4226 #[allow(unused_mut)]
4227 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
4228 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
4229 args: &'args BallRigidBodyStateArgs<'args>,
4230 ) -> flatbuffers::WIPOffset<BallRigidBodyState<'bldr>> {
4231 let mut builder = BallRigidBodyStateBuilder::new(_fbb);
4232 if let Some(x) = args.state {
4233 builder.add_state(x);
4234 }
4235 builder.finish()
4236 }
4237
4238 pub const VT_STATE: flatbuffers::VOffsetT = 4;
4239
4240 #[inline]
4241 pub fn state(&self) -> Option<RigidBodyState<'a>> {
4242 self._tab
4243 .get::<flatbuffers::ForwardsUOffset<RigidBodyState<'a>>>(
4244 BallRigidBodyState::VT_STATE,
4245 None,
4246 )
4247 }
4248 }
4249
4250 pub struct BallRigidBodyStateArgs<'a> {
4251 pub state: Option<flatbuffers::WIPOffset<RigidBodyState<'a>>>,
4252 }
4253 impl<'a> Default for BallRigidBodyStateArgs<'a> {
4254 #[inline]
4255 fn default() -> Self {
4256 BallRigidBodyStateArgs { state: None }
4257 }
4258 }
4259 pub struct BallRigidBodyStateBuilder<'a: 'b, 'b> {
4260 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4261 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
4262 }
4263 impl<'a: 'b, 'b> BallRigidBodyStateBuilder<'a, 'b> {
4264 #[inline]
4265 pub fn add_state(&mut self, state: flatbuffers::WIPOffset<RigidBodyState<'b>>) {
4266 self.fbb_
4267 .push_slot_always::<flatbuffers::WIPOffset<RigidBodyState<'_>>>(
4268 BallRigidBodyState::VT_STATE,
4269 state,
4270 );
4271 }
4272 #[inline]
4273 pub fn new(
4274 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4275 ) -> BallRigidBodyStateBuilder<'a, 'b> {
4276 let start = _fbb.start_table();
4277 BallRigidBodyStateBuilder {
4278 fbb_: _fbb,
4279 start_: start,
4280 }
4281 }
4282 #[inline]
4283 pub fn finish(self) -> flatbuffers::WIPOffset<BallRigidBodyState<'a>> {
4284 let o = self.fbb_.end_table(self.start_);
4285 flatbuffers::WIPOffset::new(o.value())
4286 }
4287 }
4288
4289 pub enum RigidBodyTickOffset {}
4291 #[derive(Copy, Clone, Debug, PartialEq)]
4292
4293 pub struct RigidBodyTick<'a> {
4294 pub _tab: flatbuffers::Table<'a>,
4295 }
4296
4297 impl<'a> flatbuffers::Follow<'a> for RigidBodyTick<'a> {
4298 type Inner = RigidBodyTick<'a>;
4299 #[inline]
4300 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
4301 Self {
4302 _tab: flatbuffers::Table { buf, loc },
4303 }
4304 }
4305 }
4306
4307 impl<'a> RigidBodyTick<'a> {
4308 #[inline]
4309 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
4310 RigidBodyTick { _tab: table }
4311 }
4312 #[allow(unused_mut)]
4313 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
4314 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
4315 args: &'args RigidBodyTickArgs<'args>,
4316 ) -> flatbuffers::WIPOffset<RigidBodyTick<'bldr>> {
4317 let mut builder = RigidBodyTickBuilder::new(_fbb);
4318 if let Some(x) = args.players {
4319 builder.add_players(x);
4320 }
4321 if let Some(x) = args.ball {
4322 builder.add_ball(x);
4323 }
4324 builder.finish()
4325 }
4326
4327 pub const VT_BALL: flatbuffers::VOffsetT = 4;
4328 pub const VT_PLAYERS: flatbuffers::VOffsetT = 6;
4329
4330 #[inline]
4331 pub fn ball(&self) -> Option<BallRigidBodyState<'a>> {
4332 self._tab
4333 .get::<flatbuffers::ForwardsUOffset<BallRigidBodyState<'a>>>(
4334 RigidBodyTick::VT_BALL,
4335 None,
4336 )
4337 }
4338 #[inline]
4339 pub fn players(
4340 &self,
4341 ) -> Option<
4342 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PlayerRigidBodyState<'a>>>,
4343 > {
4344 self._tab.get::<flatbuffers::ForwardsUOffset<
4345 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PlayerRigidBodyState<'a>>>,
4346 >>(RigidBodyTick::VT_PLAYERS, None)
4347 }
4348 }
4349
4350 pub struct RigidBodyTickArgs<'a> {
4351 pub ball: Option<flatbuffers::WIPOffset<BallRigidBodyState<'a>>>,
4352 pub players: Option<
4353 flatbuffers::WIPOffset<
4354 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PlayerRigidBodyState<'a>>>,
4355 >,
4356 >,
4357 }
4358 impl<'a> Default for RigidBodyTickArgs<'a> {
4359 #[inline]
4360 fn default() -> Self {
4361 RigidBodyTickArgs {
4362 ball: None,
4363 players: None,
4364 }
4365 }
4366 }
4367 pub struct RigidBodyTickBuilder<'a: 'b, 'b> {
4368 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4369 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
4370 }
4371 impl<'a: 'b, 'b> RigidBodyTickBuilder<'a, 'b> {
4372 #[inline]
4373 pub fn add_ball(&mut self, ball: flatbuffers::WIPOffset<BallRigidBodyState<'b>>) {
4374 self.fbb_
4375 .push_slot_always::<flatbuffers::WIPOffset<BallRigidBodyState<'_>>>(
4376 RigidBodyTick::VT_BALL,
4377 ball,
4378 );
4379 }
4380 #[inline]
4381 pub fn add_players(
4382 &mut self,
4383 players: flatbuffers::WIPOffset<
4384 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<PlayerRigidBodyState<'b>>>,
4385 >,
4386 ) {
4387 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
4388 RigidBodyTick::VT_PLAYERS,
4389 players,
4390 );
4391 }
4392 #[inline]
4393 pub fn new(
4394 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4395 ) -> RigidBodyTickBuilder<'a, 'b> {
4396 let start = _fbb.start_table();
4397 RigidBodyTickBuilder {
4398 fbb_: _fbb,
4399 start_: start,
4400 }
4401 }
4402 #[inline]
4403 pub fn finish(self) -> flatbuffers::WIPOffset<RigidBodyTick<'a>> {
4404 let o = self.fbb_.end_table(self.start_);
4405 flatbuffers::WIPOffset::new(o.value())
4406 }
4407 }
4408
4409 pub enum GoalInfoOffset {}
4410 #[derive(Copy, Clone, Debug, PartialEq)]
4411
4412 pub struct GoalInfo<'a> {
4413 pub _tab: flatbuffers::Table<'a>,
4414 }
4415
4416 impl<'a> flatbuffers::Follow<'a> for GoalInfo<'a> {
4417 type Inner = GoalInfo<'a>;
4418 #[inline]
4419 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
4420 Self {
4421 _tab: flatbuffers::Table { buf, loc },
4422 }
4423 }
4424 }
4425
4426 impl<'a> GoalInfo<'a> {
4427 #[inline]
4428 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
4429 GoalInfo { _tab: table }
4430 }
4431 #[allow(unused_mut)]
4432 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
4433 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
4434 args: &'args GoalInfoArgs<'args>,
4435 ) -> flatbuffers::WIPOffset<GoalInfo<'bldr>> {
4436 let mut builder = GoalInfoBuilder::new(_fbb);
4437 if let Some(x) = args.direction {
4438 builder.add_direction(x);
4439 }
4440 if let Some(x) = args.location {
4441 builder.add_location(x);
4442 }
4443 builder.add_teamNum(args.teamNum);
4444 builder.finish()
4445 }
4446
4447 pub const VT_TEAMNUM: flatbuffers::VOffsetT = 4;
4448 pub const VT_LOCATION: flatbuffers::VOffsetT = 6;
4449 pub const VT_DIRECTION: flatbuffers::VOffsetT = 8;
4450
4451 #[inline]
4452 pub fn teamNum(&self) -> i32 {
4453 self._tab.get::<i32>(GoalInfo::VT_TEAMNUM, Some(0)).unwrap()
4454 }
4455 #[inline]
4456 pub fn location(&self) -> Option<&'a Vector3> {
4457 self._tab.get::<Vector3>(GoalInfo::VT_LOCATION, None)
4458 }
4459 #[inline]
4460 pub fn direction(&self) -> Option<&'a Vector3> {
4461 self._tab.get::<Vector3>(GoalInfo::VT_DIRECTION, None)
4462 }
4463 }
4464
4465 pub struct GoalInfoArgs<'a> {
4466 pub teamNum: i32,
4467 pub location: Option<&'a Vector3>,
4468 pub direction: Option<&'a Vector3>,
4469 }
4470 impl<'a> Default for GoalInfoArgs<'a> {
4471 #[inline]
4472 fn default() -> Self {
4473 GoalInfoArgs {
4474 teamNum: 0,
4475 location: None,
4476 direction: None,
4477 }
4478 }
4479 }
4480 pub struct GoalInfoBuilder<'a: 'b, 'b> {
4481 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4482 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
4483 }
4484 impl<'a: 'b, 'b> GoalInfoBuilder<'a, 'b> {
4485 #[inline]
4486 pub fn add_teamNum(&mut self, teamNum: i32) {
4487 self.fbb_.push_slot::<i32>(GoalInfo::VT_TEAMNUM, teamNum, 0);
4488 }
4489 #[inline]
4490 pub fn add_location(&mut self, location: &'b Vector3) {
4491 self.fbb_
4492 .push_slot_always::<&Vector3>(GoalInfo::VT_LOCATION, location);
4493 }
4494 #[inline]
4495 pub fn add_direction(&mut self, direction: &'b Vector3) {
4496 self.fbb_
4497 .push_slot_always::<&Vector3>(GoalInfo::VT_DIRECTION, direction);
4498 }
4499 #[inline]
4500 pub fn new(
4501 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4502 ) -> GoalInfoBuilder<'a, 'b> {
4503 let start = _fbb.start_table();
4504 GoalInfoBuilder {
4505 fbb_: _fbb,
4506 start_: start,
4507 }
4508 }
4509 #[inline]
4510 pub fn finish(self) -> flatbuffers::WIPOffset<GoalInfo<'a>> {
4511 let o = self.fbb_.end_table(self.start_);
4512 flatbuffers::WIPOffset::new(o.value())
4513 }
4514 }
4515
4516 pub enum BoostPadOffset {}
4517 #[derive(Copy, Clone, Debug, PartialEq)]
4518
4519 pub struct BoostPad<'a> {
4520 pub _tab: flatbuffers::Table<'a>,
4521 }
4522
4523 impl<'a> flatbuffers::Follow<'a> for BoostPad<'a> {
4524 type Inner = BoostPad<'a>;
4525 #[inline]
4526 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
4527 Self {
4528 _tab: flatbuffers::Table { buf, loc },
4529 }
4530 }
4531 }
4532
4533 impl<'a> BoostPad<'a> {
4534 #[inline]
4535 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
4536 BoostPad { _tab: table }
4537 }
4538 #[allow(unused_mut)]
4539 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
4540 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
4541 args: &'args BoostPadArgs<'args>,
4542 ) -> flatbuffers::WIPOffset<BoostPad<'bldr>> {
4543 let mut builder = BoostPadBuilder::new(_fbb);
4544 if let Some(x) = args.location {
4545 builder.add_location(x);
4546 }
4547 builder.add_isFullBoost(args.isFullBoost);
4548 builder.finish()
4549 }
4550
4551 pub const VT_LOCATION: flatbuffers::VOffsetT = 4;
4552 pub const VT_ISFULLBOOST: flatbuffers::VOffsetT = 6;
4553
4554 #[inline]
4555 pub fn location(&self) -> Option<&'a Vector3> {
4556 self._tab.get::<Vector3>(BoostPad::VT_LOCATION, None)
4557 }
4558 #[inline]
4559 pub fn isFullBoost(&self) -> bool {
4560 self._tab
4561 .get::<bool>(BoostPad::VT_ISFULLBOOST, Some(false))
4562 .unwrap()
4563 }
4564 }
4565
4566 pub struct BoostPadArgs<'a> {
4567 pub location: Option<&'a Vector3>,
4568 pub isFullBoost: bool,
4569 }
4570 impl<'a> Default for BoostPadArgs<'a> {
4571 #[inline]
4572 fn default() -> Self {
4573 BoostPadArgs {
4574 location: None,
4575 isFullBoost: false,
4576 }
4577 }
4578 }
4579 pub struct BoostPadBuilder<'a: 'b, 'b> {
4580 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4581 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
4582 }
4583 impl<'a: 'b, 'b> BoostPadBuilder<'a, 'b> {
4584 #[inline]
4585 pub fn add_location(&mut self, location: &'b Vector3) {
4586 self.fbb_
4587 .push_slot_always::<&Vector3>(BoostPad::VT_LOCATION, location);
4588 }
4589 #[inline]
4590 pub fn add_isFullBoost(&mut self, isFullBoost: bool) {
4591 self.fbb_
4592 .push_slot::<bool>(BoostPad::VT_ISFULLBOOST, isFullBoost, false);
4593 }
4594 #[inline]
4595 pub fn new(
4596 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4597 ) -> BoostPadBuilder<'a, 'b> {
4598 let start = _fbb.start_table();
4599 BoostPadBuilder {
4600 fbb_: _fbb,
4601 start_: start,
4602 }
4603 }
4604 #[inline]
4605 pub fn finish(self) -> flatbuffers::WIPOffset<BoostPad<'a>> {
4606 let o = self.fbb_.end_table(self.start_);
4607 flatbuffers::WIPOffset::new(o.value())
4608 }
4609 }
4610
4611 pub enum FieldInfoOffset {}
4612 #[derive(Copy, Clone, Debug, PartialEq)]
4613
4614 pub struct FieldInfo<'a> {
4615 pub _tab: flatbuffers::Table<'a>,
4616 }
4617
4618 impl<'a> flatbuffers::Follow<'a> for FieldInfo<'a> {
4619 type Inner = FieldInfo<'a>;
4620 #[inline]
4621 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
4622 Self {
4623 _tab: flatbuffers::Table { buf, loc },
4624 }
4625 }
4626 }
4627
4628 impl<'a> FieldInfo<'a> {
4629 #[inline]
4630 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
4631 FieldInfo { _tab: table }
4632 }
4633 #[allow(unused_mut)]
4634 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
4635 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
4636 args: &'args FieldInfoArgs<'args>,
4637 ) -> flatbuffers::WIPOffset<FieldInfo<'bldr>> {
4638 let mut builder = FieldInfoBuilder::new(_fbb);
4639 if let Some(x) = args.goals {
4640 builder.add_goals(x);
4641 }
4642 if let Some(x) = args.boostPads {
4643 builder.add_boostPads(x);
4644 }
4645 builder.finish()
4646 }
4647
4648 pub const VT_BOOSTPADS: flatbuffers::VOffsetT = 4;
4649 pub const VT_GOALS: flatbuffers::VOffsetT = 6;
4650
4651 #[inline]
4652 pub fn boostPads(
4653 &self,
4654 ) -> Option<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<BoostPad<'a>>>>
4655 {
4656 self._tab.get::<flatbuffers::ForwardsUOffset<
4657 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<BoostPad<'a>>>,
4658 >>(FieldInfo::VT_BOOSTPADS, None)
4659 }
4660 #[inline]
4661 pub fn goals(
4662 &self,
4663 ) -> Option<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<GoalInfo<'a>>>>
4664 {
4665 self._tab.get::<flatbuffers::ForwardsUOffset<
4666 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<GoalInfo<'a>>>,
4667 >>(FieldInfo::VT_GOALS, None)
4668 }
4669 }
4670
4671 pub struct FieldInfoArgs<'a> {
4672 pub boostPads: Option<
4673 flatbuffers::WIPOffset<
4674 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<BoostPad<'a>>>,
4675 >,
4676 >,
4677 pub goals: Option<
4678 flatbuffers::WIPOffset<
4679 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<GoalInfo<'a>>>,
4680 >,
4681 >,
4682 }
4683 impl<'a> Default for FieldInfoArgs<'a> {
4684 #[inline]
4685 fn default() -> Self {
4686 FieldInfoArgs {
4687 boostPads: None,
4688 goals: None,
4689 }
4690 }
4691 }
4692 pub struct FieldInfoBuilder<'a: 'b, 'b> {
4693 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4694 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
4695 }
4696 impl<'a: 'b, 'b> FieldInfoBuilder<'a, 'b> {
4697 #[inline]
4698 pub fn add_boostPads(
4699 &mut self,
4700 boostPads: flatbuffers::WIPOffset<
4701 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<BoostPad<'b>>>,
4702 >,
4703 ) {
4704 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
4705 FieldInfo::VT_BOOSTPADS,
4706 boostPads,
4707 );
4708 }
4709 #[inline]
4710 pub fn add_goals(
4711 &mut self,
4712 goals: flatbuffers::WIPOffset<
4713 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<GoalInfo<'b>>>,
4714 >,
4715 ) {
4716 self.fbb_
4717 .push_slot_always::<flatbuffers::WIPOffset<_>>(FieldInfo::VT_GOALS, goals);
4718 }
4719 #[inline]
4720 pub fn new(
4721 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4722 ) -> FieldInfoBuilder<'a, 'b> {
4723 let start = _fbb.start_table();
4724 FieldInfoBuilder {
4725 fbb_: _fbb,
4726 start_: start,
4727 }
4728 }
4729 #[inline]
4730 pub fn finish(self) -> flatbuffers::WIPOffset<FieldInfo<'a>> {
4731 let o = self.fbb_.end_table(self.start_);
4732 flatbuffers::WIPOffset::new(o.value())
4733 }
4734 }
4735
4736 pub enum Vector3PartialOffset {}
4737 #[derive(Copy, Clone, Debug, PartialEq)]
4738
4739 pub struct Vector3Partial<'a> {
4740 pub _tab: flatbuffers::Table<'a>,
4741 }
4742
4743 impl<'a> flatbuffers::Follow<'a> for Vector3Partial<'a> {
4744 type Inner = Vector3Partial<'a>;
4745 #[inline]
4746 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
4747 Self {
4748 _tab: flatbuffers::Table { buf, loc },
4749 }
4750 }
4751 }
4752
4753 impl<'a> Vector3Partial<'a> {
4754 #[inline]
4755 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
4756 Vector3Partial { _tab: table }
4757 }
4758 #[allow(unused_mut)]
4759 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
4760 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
4761 args: &'args Vector3PartialArgs<'args>,
4762 ) -> flatbuffers::WIPOffset<Vector3Partial<'bldr>> {
4763 let mut builder = Vector3PartialBuilder::new(_fbb);
4764 if let Some(x) = args.z {
4765 builder.add_z(x);
4766 }
4767 if let Some(x) = args.y {
4768 builder.add_y(x);
4769 }
4770 if let Some(x) = args.x {
4771 builder.add_x(x);
4772 }
4773 builder.finish()
4774 }
4775
4776 pub const VT_X: flatbuffers::VOffsetT = 4;
4777 pub const VT_Y: flatbuffers::VOffsetT = 6;
4778 pub const VT_Z: flatbuffers::VOffsetT = 8;
4779
4780 #[inline]
4781 pub fn x(&self) -> Option<&'a Float> {
4782 self._tab.get::<Float>(Vector3Partial::VT_X, None)
4783 }
4784 #[inline]
4785 pub fn y(&self) -> Option<&'a Float> {
4786 self._tab.get::<Float>(Vector3Partial::VT_Y, None)
4787 }
4788 #[inline]
4789 pub fn z(&self) -> Option<&'a Float> {
4790 self._tab.get::<Float>(Vector3Partial::VT_Z, None)
4791 }
4792 }
4793
4794 pub struct Vector3PartialArgs<'a> {
4795 pub x: Option<&'a Float>,
4796 pub y: Option<&'a Float>,
4797 pub z: Option<&'a Float>,
4798 }
4799 impl<'a> Default for Vector3PartialArgs<'a> {
4800 #[inline]
4801 fn default() -> Self {
4802 Vector3PartialArgs {
4803 x: None,
4804 y: None,
4805 z: None,
4806 }
4807 }
4808 }
4809 pub struct Vector3PartialBuilder<'a: 'b, 'b> {
4810 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4811 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
4812 }
4813 impl<'a: 'b, 'b> Vector3PartialBuilder<'a, 'b> {
4814 #[inline]
4815 pub fn add_x(&mut self, x: &'b Float) {
4816 self.fbb_
4817 .push_slot_always::<&Float>(Vector3Partial::VT_X, x);
4818 }
4819 #[inline]
4820 pub fn add_y(&mut self, y: &'b Float) {
4821 self.fbb_
4822 .push_slot_always::<&Float>(Vector3Partial::VT_Y, y);
4823 }
4824 #[inline]
4825 pub fn add_z(&mut self, z: &'b Float) {
4826 self.fbb_
4827 .push_slot_always::<&Float>(Vector3Partial::VT_Z, z);
4828 }
4829 #[inline]
4830 pub fn new(
4831 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4832 ) -> Vector3PartialBuilder<'a, 'b> {
4833 let start = _fbb.start_table();
4834 Vector3PartialBuilder {
4835 fbb_: _fbb,
4836 start_: start,
4837 }
4838 }
4839 #[inline]
4840 pub fn finish(self) -> flatbuffers::WIPOffset<Vector3Partial<'a>> {
4841 let o = self.fbb_.end_table(self.start_);
4842 flatbuffers::WIPOffset::new(o.value())
4843 }
4844 }
4845
4846 pub enum RotatorPartialOffset {}
4847 #[derive(Copy, Clone, Debug, PartialEq)]
4848
4849 pub struct RotatorPartial<'a> {
4850 pub _tab: flatbuffers::Table<'a>,
4851 }
4852
4853 impl<'a> flatbuffers::Follow<'a> for RotatorPartial<'a> {
4854 type Inner = RotatorPartial<'a>;
4855 #[inline]
4856 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
4857 Self {
4858 _tab: flatbuffers::Table { buf, loc },
4859 }
4860 }
4861 }
4862
4863 impl<'a> RotatorPartial<'a> {
4864 #[inline]
4865 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
4866 RotatorPartial { _tab: table }
4867 }
4868 #[allow(unused_mut)]
4869 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
4870 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
4871 args: &'args RotatorPartialArgs<'args>,
4872 ) -> flatbuffers::WIPOffset<RotatorPartial<'bldr>> {
4873 let mut builder = RotatorPartialBuilder::new(_fbb);
4874 if let Some(x) = args.roll {
4875 builder.add_roll(x);
4876 }
4877 if let Some(x) = args.yaw {
4878 builder.add_yaw(x);
4879 }
4880 if let Some(x) = args.pitch {
4881 builder.add_pitch(x);
4882 }
4883 builder.finish()
4884 }
4885
4886 pub const VT_PITCH: flatbuffers::VOffsetT = 4;
4887 pub const VT_YAW: flatbuffers::VOffsetT = 6;
4888 pub const VT_ROLL: flatbuffers::VOffsetT = 8;
4889
4890 #[inline]
4891 pub fn pitch(&self) -> Option<&'a Float> {
4892 self._tab.get::<Float>(RotatorPartial::VT_PITCH, None)
4893 }
4894 #[inline]
4895 pub fn yaw(&self) -> Option<&'a Float> {
4896 self._tab.get::<Float>(RotatorPartial::VT_YAW, None)
4897 }
4898 #[inline]
4899 pub fn roll(&self) -> Option<&'a Float> {
4900 self._tab.get::<Float>(RotatorPartial::VT_ROLL, None)
4901 }
4902 }
4903
4904 pub struct RotatorPartialArgs<'a> {
4905 pub pitch: Option<&'a Float>,
4906 pub yaw: Option<&'a Float>,
4907 pub roll: Option<&'a Float>,
4908 }
4909 impl<'a> Default for RotatorPartialArgs<'a> {
4910 #[inline]
4911 fn default() -> Self {
4912 RotatorPartialArgs {
4913 pitch: None,
4914 yaw: None,
4915 roll: None,
4916 }
4917 }
4918 }
4919 pub struct RotatorPartialBuilder<'a: 'b, 'b> {
4920 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4921 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
4922 }
4923 impl<'a: 'b, 'b> RotatorPartialBuilder<'a, 'b> {
4924 #[inline]
4925 pub fn add_pitch(&mut self, pitch: &'b Float) {
4926 self.fbb_
4927 .push_slot_always::<&Float>(RotatorPartial::VT_PITCH, pitch);
4928 }
4929 #[inline]
4930 pub fn add_yaw(&mut self, yaw: &'b Float) {
4931 self.fbb_
4932 .push_slot_always::<&Float>(RotatorPartial::VT_YAW, yaw);
4933 }
4934 #[inline]
4935 pub fn add_roll(&mut self, roll: &'b Float) {
4936 self.fbb_
4937 .push_slot_always::<&Float>(RotatorPartial::VT_ROLL, roll);
4938 }
4939 #[inline]
4940 pub fn new(
4941 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
4942 ) -> RotatorPartialBuilder<'a, 'b> {
4943 let start = _fbb.start_table();
4944 RotatorPartialBuilder {
4945 fbb_: _fbb,
4946 start_: start,
4947 }
4948 }
4949 #[inline]
4950 pub fn finish(self) -> flatbuffers::WIPOffset<RotatorPartial<'a>> {
4951 let o = self.fbb_.end_table(self.start_);
4952 flatbuffers::WIPOffset::new(o.value())
4953 }
4954 }
4955
4956 pub enum DesiredPhysicsOffset {}
4957 #[derive(Copy, Clone, Debug, PartialEq)]
4958
4959 pub struct DesiredPhysics<'a> {
4960 pub _tab: flatbuffers::Table<'a>,
4961 }
4962
4963 impl<'a> flatbuffers::Follow<'a> for DesiredPhysics<'a> {
4964 type Inner = DesiredPhysics<'a>;
4965 #[inline]
4966 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
4967 Self {
4968 _tab: flatbuffers::Table { buf, loc },
4969 }
4970 }
4971 }
4972
4973 impl<'a> DesiredPhysics<'a> {
4974 #[inline]
4975 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
4976 DesiredPhysics { _tab: table }
4977 }
4978 #[allow(unused_mut)]
4979 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
4980 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
4981 args: &'args DesiredPhysicsArgs<'args>,
4982 ) -> flatbuffers::WIPOffset<DesiredPhysics<'bldr>> {
4983 let mut builder = DesiredPhysicsBuilder::new(_fbb);
4984 if let Some(x) = args.angularVelocity {
4985 builder.add_angularVelocity(x);
4986 }
4987 if let Some(x) = args.velocity {
4988 builder.add_velocity(x);
4989 }
4990 if let Some(x) = args.rotation {
4991 builder.add_rotation(x);
4992 }
4993 if let Some(x) = args.location {
4994 builder.add_location(x);
4995 }
4996 builder.finish()
4997 }
4998
4999 pub const VT_LOCATION: flatbuffers::VOffsetT = 4;
5000 pub const VT_ROTATION: flatbuffers::VOffsetT = 6;
5001 pub const VT_VELOCITY: flatbuffers::VOffsetT = 8;
5002 pub const VT_ANGULARVELOCITY: flatbuffers::VOffsetT = 10;
5003
5004 #[inline]
5005 pub fn location(&self) -> Option<Vector3Partial<'a>> {
5006 self._tab
5007 .get::<flatbuffers::ForwardsUOffset<Vector3Partial<'a>>>(
5008 DesiredPhysics::VT_LOCATION,
5009 None,
5010 )
5011 }
5012 #[inline]
5013 pub fn rotation(&self) -> Option<RotatorPartial<'a>> {
5014 self._tab
5015 .get::<flatbuffers::ForwardsUOffset<RotatorPartial<'a>>>(
5016 DesiredPhysics::VT_ROTATION,
5017 None,
5018 )
5019 }
5020 #[inline]
5021 pub fn velocity(&self) -> Option<Vector3Partial<'a>> {
5022 self._tab
5023 .get::<flatbuffers::ForwardsUOffset<Vector3Partial<'a>>>(
5024 DesiredPhysics::VT_VELOCITY,
5025 None,
5026 )
5027 }
5028 #[inline]
5029 pub fn angularVelocity(&self) -> Option<Vector3Partial<'a>> {
5030 self._tab
5031 .get::<flatbuffers::ForwardsUOffset<Vector3Partial<'a>>>(
5032 DesiredPhysics::VT_ANGULARVELOCITY,
5033 None,
5034 )
5035 }
5036 }
5037
5038 pub struct DesiredPhysicsArgs<'a> {
5039 pub location: Option<flatbuffers::WIPOffset<Vector3Partial<'a>>>,
5040 pub rotation: Option<flatbuffers::WIPOffset<RotatorPartial<'a>>>,
5041 pub velocity: Option<flatbuffers::WIPOffset<Vector3Partial<'a>>>,
5042 pub angularVelocity: Option<flatbuffers::WIPOffset<Vector3Partial<'a>>>,
5043 }
5044 impl<'a> Default for DesiredPhysicsArgs<'a> {
5045 #[inline]
5046 fn default() -> Self {
5047 DesiredPhysicsArgs {
5048 location: None,
5049 rotation: None,
5050 velocity: None,
5051 angularVelocity: None,
5052 }
5053 }
5054 }
5055 pub struct DesiredPhysicsBuilder<'a: 'b, 'b> {
5056 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5057 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
5058 }
5059 impl<'a: 'b, 'b> DesiredPhysicsBuilder<'a, 'b> {
5060 #[inline]
5061 pub fn add_location(&mut self, location: flatbuffers::WIPOffset<Vector3Partial<'b>>) {
5062 self.fbb_
5063 .push_slot_always::<flatbuffers::WIPOffset<Vector3Partial<'_>>>(
5064 DesiredPhysics::VT_LOCATION,
5065 location,
5066 );
5067 }
5068 #[inline]
5069 pub fn add_rotation(&mut self, rotation: flatbuffers::WIPOffset<RotatorPartial<'b>>) {
5070 self.fbb_
5071 .push_slot_always::<flatbuffers::WIPOffset<RotatorPartial<'_>>>(
5072 DesiredPhysics::VT_ROTATION,
5073 rotation,
5074 );
5075 }
5076 #[inline]
5077 pub fn add_velocity(&mut self, velocity: flatbuffers::WIPOffset<Vector3Partial<'b>>) {
5078 self.fbb_
5079 .push_slot_always::<flatbuffers::WIPOffset<Vector3Partial<'_>>>(
5080 DesiredPhysics::VT_VELOCITY,
5081 velocity,
5082 );
5083 }
5084 #[inline]
5085 pub fn add_angularVelocity(
5086 &mut self,
5087 angularVelocity: flatbuffers::WIPOffset<Vector3Partial<'b>>,
5088 ) {
5089 self.fbb_
5090 .push_slot_always::<flatbuffers::WIPOffset<Vector3Partial<'_>>>(
5091 DesiredPhysics::VT_ANGULARVELOCITY,
5092 angularVelocity,
5093 );
5094 }
5095 #[inline]
5096 pub fn new(
5097 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5098 ) -> DesiredPhysicsBuilder<'a, 'b> {
5099 let start = _fbb.start_table();
5100 DesiredPhysicsBuilder {
5101 fbb_: _fbb,
5102 start_: start,
5103 }
5104 }
5105 #[inline]
5106 pub fn finish(self) -> flatbuffers::WIPOffset<DesiredPhysics<'a>> {
5107 let o = self.fbb_.end_table(self.start_);
5108 flatbuffers::WIPOffset::new(o.value())
5109 }
5110 }
5111
5112 pub enum DesiredBallStateOffset {}
5113 #[derive(Copy, Clone, Debug, PartialEq)]
5114
5115 pub struct DesiredBallState<'a> {
5116 pub _tab: flatbuffers::Table<'a>,
5117 }
5118
5119 impl<'a> flatbuffers::Follow<'a> for DesiredBallState<'a> {
5120 type Inner = DesiredBallState<'a>;
5121 #[inline]
5122 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
5123 Self {
5124 _tab: flatbuffers::Table { buf, loc },
5125 }
5126 }
5127 }
5128
5129 impl<'a> DesiredBallState<'a> {
5130 #[inline]
5131 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
5132 DesiredBallState { _tab: table }
5133 }
5134 #[allow(unused_mut)]
5135 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
5136 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
5137 args: &'args DesiredBallStateArgs<'args>,
5138 ) -> flatbuffers::WIPOffset<DesiredBallState<'bldr>> {
5139 let mut builder = DesiredBallStateBuilder::new(_fbb);
5140 if let Some(x) = args.physics {
5141 builder.add_physics(x);
5142 }
5143 builder.finish()
5144 }
5145
5146 pub const VT_PHYSICS: flatbuffers::VOffsetT = 4;
5147
5148 #[inline]
5149 pub fn physics(&self) -> Option<DesiredPhysics<'a>> {
5150 self._tab
5151 .get::<flatbuffers::ForwardsUOffset<DesiredPhysics<'a>>>(
5152 DesiredBallState::VT_PHYSICS,
5153 None,
5154 )
5155 }
5156 }
5157
5158 pub struct DesiredBallStateArgs<'a> {
5159 pub physics: Option<flatbuffers::WIPOffset<DesiredPhysics<'a>>>,
5160 }
5161 impl<'a> Default for DesiredBallStateArgs<'a> {
5162 #[inline]
5163 fn default() -> Self {
5164 DesiredBallStateArgs { physics: None }
5165 }
5166 }
5167 pub struct DesiredBallStateBuilder<'a: 'b, 'b> {
5168 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5169 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
5170 }
5171 impl<'a: 'b, 'b> DesiredBallStateBuilder<'a, 'b> {
5172 #[inline]
5173 pub fn add_physics(&mut self, physics: flatbuffers::WIPOffset<DesiredPhysics<'b>>) {
5174 self.fbb_
5175 .push_slot_always::<flatbuffers::WIPOffset<DesiredPhysics<'_>>>(
5176 DesiredBallState::VT_PHYSICS,
5177 physics,
5178 );
5179 }
5180 #[inline]
5181 pub fn new(
5182 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5183 ) -> DesiredBallStateBuilder<'a, 'b> {
5184 let start = _fbb.start_table();
5185 DesiredBallStateBuilder {
5186 fbb_: _fbb,
5187 start_: start,
5188 }
5189 }
5190 #[inline]
5191 pub fn finish(self) -> flatbuffers::WIPOffset<DesiredBallState<'a>> {
5192 let o = self.fbb_.end_table(self.start_);
5193 flatbuffers::WIPOffset::new(o.value())
5194 }
5195 }
5196
5197 pub enum DesiredCarStateOffset {}
5198 #[derive(Copy, Clone, Debug, PartialEq)]
5199
5200 pub struct DesiredCarState<'a> {
5201 pub _tab: flatbuffers::Table<'a>,
5202 }
5203
5204 impl<'a> flatbuffers::Follow<'a> for DesiredCarState<'a> {
5205 type Inner = DesiredCarState<'a>;
5206 #[inline]
5207 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
5208 Self {
5209 _tab: flatbuffers::Table { buf, loc },
5210 }
5211 }
5212 }
5213
5214 impl<'a> DesiredCarState<'a> {
5215 #[inline]
5216 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
5217 DesiredCarState { _tab: table }
5218 }
5219 #[allow(unused_mut)]
5220 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
5221 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
5222 args: &'args DesiredCarStateArgs<'args>,
5223 ) -> flatbuffers::WIPOffset<DesiredCarState<'bldr>> {
5224 let mut builder = DesiredCarStateBuilder::new(_fbb);
5225 if let Some(x) = args.doubleJumped {
5226 builder.add_doubleJumped(x);
5227 }
5228 if let Some(x) = args.jumped {
5229 builder.add_jumped(x);
5230 }
5231 if let Some(x) = args.boostAmount {
5232 builder.add_boostAmount(x);
5233 }
5234 if let Some(x) = args.physics {
5235 builder.add_physics(x);
5236 }
5237 builder.finish()
5238 }
5239
5240 pub const VT_PHYSICS: flatbuffers::VOffsetT = 4;
5241 pub const VT_BOOSTAMOUNT: flatbuffers::VOffsetT = 6;
5242 pub const VT_JUMPED: flatbuffers::VOffsetT = 8;
5243 pub const VT_DOUBLEJUMPED: flatbuffers::VOffsetT = 10;
5244
5245 #[inline]
5246 pub fn physics(&self) -> Option<DesiredPhysics<'a>> {
5247 self._tab
5248 .get::<flatbuffers::ForwardsUOffset<DesiredPhysics<'a>>>(
5249 DesiredCarState::VT_PHYSICS,
5250 None,
5251 )
5252 }
5253 #[inline]
5254 pub fn boostAmount(&self) -> Option<&'a Float> {
5255 self._tab
5256 .get::<Float>(DesiredCarState::VT_BOOSTAMOUNT, None)
5257 }
5258 #[inline]
5259 pub fn jumped(&self) -> Option<&'a Bool> {
5260 self._tab.get::<Bool>(DesiredCarState::VT_JUMPED, None)
5261 }
5262 #[inline]
5263 pub fn doubleJumped(&self) -> Option<&'a Bool> {
5264 self._tab
5265 .get::<Bool>(DesiredCarState::VT_DOUBLEJUMPED, None)
5266 }
5267 }
5268
5269 pub struct DesiredCarStateArgs<'a> {
5270 pub physics: Option<flatbuffers::WIPOffset<DesiredPhysics<'a>>>,
5271 pub boostAmount: Option<&'a Float>,
5272 pub jumped: Option<&'a Bool>,
5273 pub doubleJumped: Option<&'a Bool>,
5274 }
5275 impl<'a> Default for DesiredCarStateArgs<'a> {
5276 #[inline]
5277 fn default() -> Self {
5278 DesiredCarStateArgs {
5279 physics: None,
5280 boostAmount: None,
5281 jumped: None,
5282 doubleJumped: None,
5283 }
5284 }
5285 }
5286 pub struct DesiredCarStateBuilder<'a: 'b, 'b> {
5287 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5288 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
5289 }
5290 impl<'a: 'b, 'b> DesiredCarStateBuilder<'a, 'b> {
5291 #[inline]
5292 pub fn add_physics(&mut self, physics: flatbuffers::WIPOffset<DesiredPhysics<'b>>) {
5293 self.fbb_
5294 .push_slot_always::<flatbuffers::WIPOffset<DesiredPhysics<'_>>>(
5295 DesiredCarState::VT_PHYSICS,
5296 physics,
5297 );
5298 }
5299 #[inline]
5300 pub fn add_boostAmount(&mut self, boostAmount: &'b Float) {
5301 self.fbb_
5302 .push_slot_always::<&Float>(DesiredCarState::VT_BOOSTAMOUNT, boostAmount);
5303 }
5304 #[inline]
5305 pub fn add_jumped(&mut self, jumped: &'b Bool) {
5306 self.fbb_
5307 .push_slot_always::<&Bool>(DesiredCarState::VT_JUMPED, jumped);
5308 }
5309 #[inline]
5310 pub fn add_doubleJumped(&mut self, doubleJumped: &'b Bool) {
5311 self.fbb_
5312 .push_slot_always::<&Bool>(DesiredCarState::VT_DOUBLEJUMPED, doubleJumped);
5313 }
5314 #[inline]
5315 pub fn new(
5316 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5317 ) -> DesiredCarStateBuilder<'a, 'b> {
5318 let start = _fbb.start_table();
5319 DesiredCarStateBuilder {
5320 fbb_: _fbb,
5321 start_: start,
5322 }
5323 }
5324 #[inline]
5325 pub fn finish(self) -> flatbuffers::WIPOffset<DesiredCarState<'a>> {
5326 let o = self.fbb_.end_table(self.start_);
5327 flatbuffers::WIPOffset::new(o.value())
5328 }
5329 }
5330
5331 pub enum DesiredBoostStateOffset {}
5332 #[derive(Copy, Clone, Debug, PartialEq)]
5333
5334 pub struct DesiredBoostState<'a> {
5335 pub _tab: flatbuffers::Table<'a>,
5336 }
5337
5338 impl<'a> flatbuffers::Follow<'a> for DesiredBoostState<'a> {
5339 type Inner = DesiredBoostState<'a>;
5340 #[inline]
5341 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
5342 Self {
5343 _tab: flatbuffers::Table { buf, loc },
5344 }
5345 }
5346 }
5347
5348 impl<'a> DesiredBoostState<'a> {
5349 #[inline]
5350 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
5351 DesiredBoostState { _tab: table }
5352 }
5353 #[allow(unused_mut)]
5354 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
5355 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
5356 args: &'args DesiredBoostStateArgs<'args>,
5357 ) -> flatbuffers::WIPOffset<DesiredBoostState<'bldr>> {
5358 let mut builder = DesiredBoostStateBuilder::new(_fbb);
5359 if let Some(x) = args.respawnTime {
5360 builder.add_respawnTime(x);
5361 }
5362 builder.finish()
5363 }
5364
5365 pub const VT_RESPAWNTIME: flatbuffers::VOffsetT = 4;
5366
5367 #[inline]
5368 pub fn respawnTime(&self) -> Option<&'a Float> {
5369 self._tab
5370 .get::<Float>(DesiredBoostState::VT_RESPAWNTIME, None)
5371 }
5372 }
5373
5374 pub struct DesiredBoostStateArgs<'a> {
5375 pub respawnTime: Option<&'a Float>,
5376 }
5377 impl<'a> Default for DesiredBoostStateArgs<'a> {
5378 #[inline]
5379 fn default() -> Self {
5380 DesiredBoostStateArgs { respawnTime: None }
5381 }
5382 }
5383 pub struct DesiredBoostStateBuilder<'a: 'b, 'b> {
5384 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5385 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
5386 }
5387 impl<'a: 'b, 'b> DesiredBoostStateBuilder<'a, 'b> {
5388 #[inline]
5389 pub fn add_respawnTime(&mut self, respawnTime: &'b Float) {
5390 self.fbb_
5391 .push_slot_always::<&Float>(DesiredBoostState::VT_RESPAWNTIME, respawnTime);
5392 }
5393 #[inline]
5394 pub fn new(
5395 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5396 ) -> DesiredBoostStateBuilder<'a, 'b> {
5397 let start = _fbb.start_table();
5398 DesiredBoostStateBuilder {
5399 fbb_: _fbb,
5400 start_: start,
5401 }
5402 }
5403 #[inline]
5404 pub fn finish(self) -> flatbuffers::WIPOffset<DesiredBoostState<'a>> {
5405 let o = self.fbb_.end_table(self.start_);
5406 flatbuffers::WIPOffset::new(o.value())
5407 }
5408 }
5409
5410 pub enum DesiredGameInfoStateOffset {}
5411 #[derive(Copy, Clone, Debug, PartialEq)]
5412
5413 pub struct DesiredGameInfoState<'a> {
5414 pub _tab: flatbuffers::Table<'a>,
5415 }
5416
5417 impl<'a> flatbuffers::Follow<'a> for DesiredGameInfoState<'a> {
5418 type Inner = DesiredGameInfoState<'a>;
5419 #[inline]
5420 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
5421 Self {
5422 _tab: flatbuffers::Table { buf, loc },
5423 }
5424 }
5425 }
5426
5427 impl<'a> DesiredGameInfoState<'a> {
5428 #[inline]
5429 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
5430 DesiredGameInfoState { _tab: table }
5431 }
5432 #[allow(unused_mut)]
5433 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
5434 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
5435 args: &'args DesiredGameInfoStateArgs<'args>,
5436 ) -> flatbuffers::WIPOffset<DesiredGameInfoState<'bldr>> {
5437 let mut builder = DesiredGameInfoStateBuilder::new(_fbb);
5438 if let Some(x) = args.gameSpeed {
5439 builder.add_gameSpeed(x);
5440 }
5441 if let Some(x) = args.worldGravityZ {
5442 builder.add_worldGravityZ(x);
5443 }
5444 builder.finish()
5445 }
5446
5447 pub const VT_WORLDGRAVITYZ: flatbuffers::VOffsetT = 4;
5448 pub const VT_GAMESPEED: flatbuffers::VOffsetT = 6;
5449
5450 #[inline]
5451 pub fn worldGravityZ(&self) -> Option<&'a Float> {
5452 self._tab
5453 .get::<Float>(DesiredGameInfoState::VT_WORLDGRAVITYZ, None)
5454 }
5455 #[inline]
5456 pub fn gameSpeed(&self) -> Option<&'a Float> {
5457 self._tab
5458 .get::<Float>(DesiredGameInfoState::VT_GAMESPEED, None)
5459 }
5460 }
5461
5462 pub struct DesiredGameInfoStateArgs<'a> {
5463 pub worldGravityZ: Option<&'a Float>,
5464 pub gameSpeed: Option<&'a Float>,
5465 }
5466 impl<'a> Default for DesiredGameInfoStateArgs<'a> {
5467 #[inline]
5468 fn default() -> Self {
5469 DesiredGameInfoStateArgs {
5470 worldGravityZ: None,
5471 gameSpeed: None,
5472 }
5473 }
5474 }
5475 pub struct DesiredGameInfoStateBuilder<'a: 'b, 'b> {
5476 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5477 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
5478 }
5479 impl<'a: 'b, 'b> DesiredGameInfoStateBuilder<'a, 'b> {
5480 #[inline]
5481 pub fn add_worldGravityZ(&mut self, worldGravityZ: &'b Float) {
5482 self.fbb_.push_slot_always::<&Float>(
5483 DesiredGameInfoState::VT_WORLDGRAVITYZ,
5484 worldGravityZ,
5485 );
5486 }
5487 #[inline]
5488 pub fn add_gameSpeed(&mut self, gameSpeed: &'b Float) {
5489 self.fbb_
5490 .push_slot_always::<&Float>(DesiredGameInfoState::VT_GAMESPEED, gameSpeed);
5491 }
5492 #[inline]
5493 pub fn new(
5494 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5495 ) -> DesiredGameInfoStateBuilder<'a, 'b> {
5496 let start = _fbb.start_table();
5497 DesiredGameInfoStateBuilder {
5498 fbb_: _fbb,
5499 start_: start,
5500 }
5501 }
5502 #[inline]
5503 pub fn finish(self) -> flatbuffers::WIPOffset<DesiredGameInfoState<'a>> {
5504 let o = self.fbb_.end_table(self.start_);
5505 flatbuffers::WIPOffset::new(o.value())
5506 }
5507 }
5508
5509 pub enum DesiredGameStateOffset {}
5510 #[derive(Copy, Clone, Debug, PartialEq)]
5511
5512 pub struct DesiredGameState<'a> {
5513 pub _tab: flatbuffers::Table<'a>,
5514 }
5515
5516 impl<'a> flatbuffers::Follow<'a> for DesiredGameState<'a> {
5517 type Inner = DesiredGameState<'a>;
5518 #[inline]
5519 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
5520 Self {
5521 _tab: flatbuffers::Table { buf, loc },
5522 }
5523 }
5524 }
5525
5526 impl<'a> DesiredGameState<'a> {
5527 #[inline]
5528 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
5529 DesiredGameState { _tab: table }
5530 }
5531 #[allow(unused_mut)]
5532 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
5533 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
5534 args: &'args DesiredGameStateArgs<'args>,
5535 ) -> flatbuffers::WIPOffset<DesiredGameState<'bldr>> {
5536 let mut builder = DesiredGameStateBuilder::new(_fbb);
5537 if let Some(x) = args.gameInfoState {
5538 builder.add_gameInfoState(x);
5539 }
5540 if let Some(x) = args.boostStates {
5541 builder.add_boostStates(x);
5542 }
5543 if let Some(x) = args.carStates {
5544 builder.add_carStates(x);
5545 }
5546 if let Some(x) = args.ballState {
5547 builder.add_ballState(x);
5548 }
5549 builder.finish()
5550 }
5551
5552 pub const VT_BALLSTATE: flatbuffers::VOffsetT = 4;
5553 pub const VT_CARSTATES: flatbuffers::VOffsetT = 6;
5554 pub const VT_BOOSTSTATES: flatbuffers::VOffsetT = 8;
5555 pub const VT_GAMEINFOSTATE: flatbuffers::VOffsetT = 10;
5556
5557 #[inline]
5558 pub fn ballState(&self) -> Option<DesiredBallState<'a>> {
5559 self._tab
5560 .get::<flatbuffers::ForwardsUOffset<DesiredBallState<'a>>>(
5561 DesiredGameState::VT_BALLSTATE,
5562 None,
5563 )
5564 }
5565 #[inline]
5566 pub fn carStates(
5567 &self,
5568 ) -> Option<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<DesiredCarState<'a>>>>
5569 {
5570 self._tab.get::<flatbuffers::ForwardsUOffset<
5571 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<DesiredCarState<'a>>>,
5572 >>(DesiredGameState::VT_CARSTATES, None)
5573 }
5574 #[inline]
5575 pub fn boostStates(
5576 &self,
5577 ) -> Option<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<DesiredBoostState<'a>>>>
5578 {
5579 self._tab.get::<flatbuffers::ForwardsUOffset<
5580 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<DesiredBoostState<'a>>>,
5581 >>(DesiredGameState::VT_BOOSTSTATES, None)
5582 }
5583 #[inline]
5584 pub fn gameInfoState(&self) -> Option<DesiredGameInfoState<'a>> {
5585 self._tab
5586 .get::<flatbuffers::ForwardsUOffset<DesiredGameInfoState<'a>>>(
5587 DesiredGameState::VT_GAMEINFOSTATE,
5588 None,
5589 )
5590 }
5591 }
5592
5593 pub struct DesiredGameStateArgs<'a> {
5594 pub ballState: Option<flatbuffers::WIPOffset<DesiredBallState<'a>>>,
5595 pub carStates: Option<
5596 flatbuffers::WIPOffset<
5597 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<DesiredCarState<'a>>>,
5598 >,
5599 >,
5600 pub boostStates: Option<
5601 flatbuffers::WIPOffset<
5602 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<DesiredBoostState<'a>>>,
5603 >,
5604 >,
5605 pub gameInfoState: Option<flatbuffers::WIPOffset<DesiredGameInfoState<'a>>>,
5606 }
5607 impl<'a> Default for DesiredGameStateArgs<'a> {
5608 #[inline]
5609 fn default() -> Self {
5610 DesiredGameStateArgs {
5611 ballState: None,
5612 carStates: None,
5613 boostStates: None,
5614 gameInfoState: None,
5615 }
5616 }
5617 }
5618 pub struct DesiredGameStateBuilder<'a: 'b, 'b> {
5619 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5620 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
5621 }
5622 impl<'a: 'b, 'b> DesiredGameStateBuilder<'a, 'b> {
5623 #[inline]
5624 pub fn add_ballState(
5625 &mut self,
5626 ballState: flatbuffers::WIPOffset<DesiredBallState<'b>>,
5627 ) {
5628 self.fbb_
5629 .push_slot_always::<flatbuffers::WIPOffset<DesiredBallState<'_>>>(
5630 DesiredGameState::VT_BALLSTATE,
5631 ballState,
5632 );
5633 }
5634 #[inline]
5635 pub fn add_carStates(
5636 &mut self,
5637 carStates: flatbuffers::WIPOffset<
5638 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<DesiredCarState<'b>>>,
5639 >,
5640 ) {
5641 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
5642 DesiredGameState::VT_CARSTATES,
5643 carStates,
5644 );
5645 }
5646 #[inline]
5647 pub fn add_boostStates(
5648 &mut self,
5649 boostStates: flatbuffers::WIPOffset<
5650 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<DesiredBoostState<'b>>>,
5651 >,
5652 ) {
5653 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
5654 DesiredGameState::VT_BOOSTSTATES,
5655 boostStates,
5656 );
5657 }
5658 #[inline]
5659 pub fn add_gameInfoState(
5660 &mut self,
5661 gameInfoState: flatbuffers::WIPOffset<DesiredGameInfoState<'b>>,
5662 ) {
5663 self.fbb_
5664 .push_slot_always::<flatbuffers::WIPOffset<DesiredGameInfoState<'_>>>(
5665 DesiredGameState::VT_GAMEINFOSTATE,
5666 gameInfoState,
5667 );
5668 }
5669 #[inline]
5670 pub fn new(
5671 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5672 ) -> DesiredGameStateBuilder<'a, 'b> {
5673 let start = _fbb.start_table();
5674 DesiredGameStateBuilder {
5675 fbb_: _fbb,
5676 start_: start,
5677 }
5678 }
5679 #[inline]
5680 pub fn finish(self) -> flatbuffers::WIPOffset<DesiredGameState<'a>> {
5681 let o = self.fbb_.end_table(self.start_);
5682 flatbuffers::WIPOffset::new(o.value())
5683 }
5684 }
5685
5686 pub enum ColorOffset {}
5687 #[derive(Copy, Clone, Debug, PartialEq)]
5688
5689 pub struct Color<'a> {
5690 pub _tab: flatbuffers::Table<'a>,
5691 }
5692
5693 impl<'a> flatbuffers::Follow<'a> for Color<'a> {
5694 type Inner = Color<'a>;
5695 #[inline]
5696 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
5697 Self {
5698 _tab: flatbuffers::Table { buf, loc },
5699 }
5700 }
5701 }
5702
5703 impl<'a> Color<'a> {
5704 #[inline]
5705 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
5706 Color { _tab: table }
5707 }
5708 #[allow(unused_mut)]
5709 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
5710 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
5711 args: &'args ColorArgs,
5712 ) -> flatbuffers::WIPOffset<Color<'bldr>> {
5713 let mut builder = ColorBuilder::new(_fbb);
5714 builder.add_b(args.b);
5715 builder.add_g(args.g);
5716 builder.add_r(args.r);
5717 builder.add_a(args.a);
5718 builder.finish()
5719 }
5720
5721 pub const VT_A: flatbuffers::VOffsetT = 4;
5722 pub const VT_R: flatbuffers::VOffsetT = 6;
5723 pub const VT_G: flatbuffers::VOffsetT = 8;
5724 pub const VT_B: flatbuffers::VOffsetT = 10;
5725
5726 #[inline]
5727 pub fn a(&self) -> u8 {
5728 self._tab.get::<u8>(Color::VT_A, Some(0)).unwrap()
5729 }
5730 #[inline]
5731 pub fn r(&self) -> u8 {
5732 self._tab.get::<u8>(Color::VT_R, Some(0)).unwrap()
5733 }
5734 #[inline]
5735 pub fn g(&self) -> u8 {
5736 self._tab.get::<u8>(Color::VT_G, Some(0)).unwrap()
5737 }
5738 #[inline]
5739 pub fn b(&self) -> u8 {
5740 self._tab.get::<u8>(Color::VT_B, Some(0)).unwrap()
5741 }
5742 }
5743
5744 pub struct ColorArgs {
5745 pub a: u8,
5746 pub r: u8,
5747 pub g: u8,
5748 pub b: u8,
5749 }
5750 impl<'a> Default for ColorArgs {
5751 #[inline]
5752 fn default() -> Self {
5753 ColorArgs {
5754 a: 0,
5755 r: 0,
5756 g: 0,
5757 b: 0,
5758 }
5759 }
5760 }
5761 pub struct ColorBuilder<'a: 'b, 'b> {
5762 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5763 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
5764 }
5765 impl<'a: 'b, 'b> ColorBuilder<'a, 'b> {
5766 #[inline]
5767 pub fn add_a(&mut self, a: u8) {
5768 self.fbb_.push_slot::<u8>(Color::VT_A, a, 0);
5769 }
5770 #[inline]
5771 pub fn add_r(&mut self, r: u8) {
5772 self.fbb_.push_slot::<u8>(Color::VT_R, r, 0);
5773 }
5774 #[inline]
5775 pub fn add_g(&mut self, g: u8) {
5776 self.fbb_.push_slot::<u8>(Color::VT_G, g, 0);
5777 }
5778 #[inline]
5779 pub fn add_b(&mut self, b: u8) {
5780 self.fbb_.push_slot::<u8>(Color::VT_B, b, 0);
5781 }
5782 #[inline]
5783 pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ColorBuilder<'a, 'b> {
5784 let start = _fbb.start_table();
5785 ColorBuilder {
5786 fbb_: _fbb,
5787 start_: start,
5788 }
5789 }
5790 #[inline]
5791 pub fn finish(self) -> flatbuffers::WIPOffset<Color<'a>> {
5792 let o = self.fbb_.end_table(self.start_);
5793 flatbuffers::WIPOffset::new(o.value())
5794 }
5795 }
5796
5797 pub enum RenderMessageOffset {}
5798 #[derive(Copy, Clone, Debug, PartialEq)]
5799
5800 pub struct RenderMessage<'a> {
5801 pub _tab: flatbuffers::Table<'a>,
5802 }
5803
5804 impl<'a> flatbuffers::Follow<'a> for RenderMessage<'a> {
5805 type Inner = RenderMessage<'a>;
5806 #[inline]
5807 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
5808 Self {
5809 _tab: flatbuffers::Table { buf, loc },
5810 }
5811 }
5812 }
5813
5814 impl<'a> RenderMessage<'a> {
5815 #[inline]
5816 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
5817 RenderMessage { _tab: table }
5818 }
5819 #[allow(unused_mut)]
5820 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
5821 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
5822 args: &'args RenderMessageArgs<'args>,
5823 ) -> flatbuffers::WIPOffset<RenderMessage<'bldr>> {
5824 let mut builder = RenderMessageBuilder::new(_fbb);
5825 if let Some(x) = args.text {
5826 builder.add_text(x);
5827 }
5828 builder.add_scaleY(args.scaleY);
5829 builder.add_scaleX(args.scaleX);
5830 if let Some(x) = args.end {
5831 builder.add_end(x);
5832 }
5833 if let Some(x) = args.start {
5834 builder.add_start(x);
5835 }
5836 if let Some(x) = args.color {
5837 builder.add_color(x);
5838 }
5839 builder.add_isFilled(args.isFilled);
5840 builder.add_renderType(args.renderType);
5841 builder.finish()
5842 }
5843
5844 pub const VT_RENDERTYPE: flatbuffers::VOffsetT = 4;
5845 pub const VT_COLOR: flatbuffers::VOffsetT = 6;
5846 pub const VT_START: flatbuffers::VOffsetT = 8;
5847 pub const VT_END: flatbuffers::VOffsetT = 10;
5848 pub const VT_SCALEX: flatbuffers::VOffsetT = 12;
5849 pub const VT_SCALEY: flatbuffers::VOffsetT = 14;
5850 pub const VT_TEXT: flatbuffers::VOffsetT = 16;
5851 pub const VT_ISFILLED: flatbuffers::VOffsetT = 18;
5852
5853 #[inline]
5854 pub fn renderType(&self) -> RenderType {
5855 self._tab
5856 .get::<RenderType>(RenderMessage::VT_RENDERTYPE, Some(RenderType::DrawLine2D))
5857 .unwrap()
5858 }
5859 #[inline]
5860 pub fn color(&self) -> Option<Color<'a>> {
5861 self._tab
5862 .get::<flatbuffers::ForwardsUOffset<Color<'a>>>(RenderMessage::VT_COLOR, None)
5863 }
5864 #[inline]
5866 pub fn start(&self) -> Option<&'a Vector3> {
5867 self._tab.get::<Vector3>(RenderMessage::VT_START, None)
5868 }
5869 #[inline]
5871 pub fn end(&self) -> Option<&'a Vector3> {
5872 self._tab.get::<Vector3>(RenderMessage::VT_END, None)
5873 }
5874 #[inline]
5877 pub fn scaleX(&self) -> i32 {
5878 self._tab
5879 .get::<i32>(RenderMessage::VT_SCALEX, Some(1))
5880 .unwrap()
5881 }
5882 #[inline]
5885 pub fn scaleY(&self) -> i32 {
5886 self._tab
5887 .get::<i32>(RenderMessage::VT_SCALEY, Some(1))
5888 .unwrap()
5889 }
5890 #[inline]
5891 pub fn text(&self) -> Option<&'a str> {
5892 self._tab
5893 .get::<flatbuffers::ForwardsUOffset<&str>>(RenderMessage::VT_TEXT, None)
5894 }
5895 #[inline]
5897 pub fn isFilled(&self) -> bool {
5898 self._tab
5899 .get::<bool>(RenderMessage::VT_ISFILLED, Some(false))
5900 .unwrap()
5901 }
5902 }
5903
5904 pub struct RenderMessageArgs<'a> {
5905 pub renderType: RenderType,
5906 pub color: Option<flatbuffers::WIPOffset<Color<'a>>>,
5907 pub start: Option<&'a Vector3>,
5908 pub end: Option<&'a Vector3>,
5909 pub scaleX: i32,
5910 pub scaleY: i32,
5911 pub text: Option<flatbuffers::WIPOffset<&'a str>>,
5912 pub isFilled: bool,
5913 }
5914 impl<'a> Default for RenderMessageArgs<'a> {
5915 #[inline]
5916 fn default() -> Self {
5917 RenderMessageArgs {
5918 renderType: RenderType::DrawLine2D,
5919 color: None,
5920 start: None,
5921 end: None,
5922 scaleX: 1,
5923 scaleY: 1,
5924 text: None,
5925 isFilled: false,
5926 }
5927 }
5928 }
5929 pub struct RenderMessageBuilder<'a: 'b, 'b> {
5930 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5931 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
5932 }
5933 impl<'a: 'b, 'b> RenderMessageBuilder<'a, 'b> {
5934 #[inline]
5935 pub fn add_renderType(&mut self, renderType: RenderType) {
5936 self.fbb_.push_slot::<RenderType>(
5937 RenderMessage::VT_RENDERTYPE,
5938 renderType,
5939 RenderType::DrawLine2D,
5940 );
5941 }
5942 #[inline]
5943 pub fn add_color(&mut self, color: flatbuffers::WIPOffset<Color<'b>>) {
5944 self.fbb_
5945 .push_slot_always::<flatbuffers::WIPOffset<Color<'_>>>(
5946 RenderMessage::VT_COLOR,
5947 color,
5948 );
5949 }
5950 #[inline]
5951 pub fn add_start(&mut self, start: &'b Vector3) {
5952 self.fbb_
5953 .push_slot_always::<&Vector3>(RenderMessage::VT_START, start);
5954 }
5955 #[inline]
5956 pub fn add_end(&mut self, end: &'b Vector3) {
5957 self.fbb_
5958 .push_slot_always::<&Vector3>(RenderMessage::VT_END, end);
5959 }
5960 #[inline]
5961 pub fn add_scaleX(&mut self, scaleX: i32) {
5962 self.fbb_
5963 .push_slot::<i32>(RenderMessage::VT_SCALEX, scaleX, 1);
5964 }
5965 #[inline]
5966 pub fn add_scaleY(&mut self, scaleY: i32) {
5967 self.fbb_
5968 .push_slot::<i32>(RenderMessage::VT_SCALEY, scaleY, 1);
5969 }
5970 #[inline]
5971 pub fn add_text(&mut self, text: flatbuffers::WIPOffset<&'b str>) {
5972 self.fbb_
5973 .push_slot_always::<flatbuffers::WIPOffset<_>>(RenderMessage::VT_TEXT, text);
5974 }
5975 #[inline]
5976 pub fn add_isFilled(&mut self, isFilled: bool) {
5977 self.fbb_
5978 .push_slot::<bool>(RenderMessage::VT_ISFILLED, isFilled, false);
5979 }
5980 #[inline]
5981 pub fn new(
5982 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
5983 ) -> RenderMessageBuilder<'a, 'b> {
5984 let start = _fbb.start_table();
5985 RenderMessageBuilder {
5986 fbb_: _fbb,
5987 start_: start,
5988 }
5989 }
5990 #[inline]
5991 pub fn finish(self) -> flatbuffers::WIPOffset<RenderMessage<'a>> {
5992 let o = self.fbb_.end_table(self.start_);
5993 flatbuffers::WIPOffset::new(o.value())
5994 }
5995 }
5996
5997 pub enum RenderGroupOffset {}
5998 #[derive(Copy, Clone, Debug, PartialEq)]
5999
6000 pub struct RenderGroup<'a> {
6001 pub _tab: flatbuffers::Table<'a>,
6002 }
6003
6004 impl<'a> flatbuffers::Follow<'a> for RenderGroup<'a> {
6005 type Inner = RenderGroup<'a>;
6006 #[inline]
6007 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
6008 Self {
6009 _tab: flatbuffers::Table { buf, loc },
6010 }
6011 }
6012 }
6013
6014 impl<'a> RenderGroup<'a> {
6015 #[inline]
6016 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
6017 RenderGroup { _tab: table }
6018 }
6019 #[allow(unused_mut)]
6020 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
6021 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
6022 args: &'args RenderGroupArgs<'args>,
6023 ) -> flatbuffers::WIPOffset<RenderGroup<'bldr>> {
6024 let mut builder = RenderGroupBuilder::new(_fbb);
6025 builder.add_id(args.id);
6026 if let Some(x) = args.renderMessages {
6027 builder.add_renderMessages(x);
6028 }
6029 builder.finish()
6030 }
6031
6032 pub const VT_RENDERMESSAGES: flatbuffers::VOffsetT = 4;
6033 pub const VT_ID: flatbuffers::VOffsetT = 6;
6034
6035 #[inline]
6036 pub fn renderMessages(
6037 &self,
6038 ) -> Option<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<RenderMessage<'a>>>>
6039 {
6040 self._tab.get::<flatbuffers::ForwardsUOffset<
6041 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<RenderMessage<'a>>>,
6042 >>(RenderGroup::VT_RENDERMESSAGES, None)
6043 }
6044 #[inline]
6046 pub fn id(&self) -> i32 {
6047 self._tab.get::<i32>(RenderGroup::VT_ID, Some(0)).unwrap()
6048 }
6049 }
6050
6051 pub struct RenderGroupArgs<'a> {
6052 pub renderMessages: Option<
6053 flatbuffers::WIPOffset<
6054 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<RenderMessage<'a>>>,
6055 >,
6056 >,
6057 pub id: i32,
6058 }
6059 impl<'a> Default for RenderGroupArgs<'a> {
6060 #[inline]
6061 fn default() -> Self {
6062 RenderGroupArgs {
6063 renderMessages: None,
6064 id: 0,
6065 }
6066 }
6067 }
6068 pub struct RenderGroupBuilder<'a: 'b, 'b> {
6069 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6070 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
6071 }
6072 impl<'a: 'b, 'b> RenderGroupBuilder<'a, 'b> {
6073 #[inline]
6074 pub fn add_renderMessages(
6075 &mut self,
6076 renderMessages: flatbuffers::WIPOffset<
6077 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<RenderMessage<'b>>>,
6078 >,
6079 ) {
6080 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
6081 RenderGroup::VT_RENDERMESSAGES,
6082 renderMessages,
6083 );
6084 }
6085 #[inline]
6086 pub fn add_id(&mut self, id: i32) {
6087 self.fbb_.push_slot::<i32>(RenderGroup::VT_ID, id, 0);
6088 }
6089 #[inline]
6090 pub fn new(
6091 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6092 ) -> RenderGroupBuilder<'a, 'b> {
6093 let start = _fbb.start_table();
6094 RenderGroupBuilder {
6095 fbb_: _fbb,
6096 start_: start,
6097 }
6098 }
6099 #[inline]
6100 pub fn finish(self) -> flatbuffers::WIPOffset<RenderGroup<'a>> {
6101 let o = self.fbb_.end_table(self.start_);
6102 flatbuffers::WIPOffset::new(o.value())
6103 }
6104 }
6105
6106 pub enum QuickChatOffset {}
6107 #[derive(Copy, Clone, Debug, PartialEq)]
6108
6109 pub struct QuickChat<'a> {
6110 pub _tab: flatbuffers::Table<'a>,
6111 }
6112
6113 impl<'a> flatbuffers::Follow<'a> for QuickChat<'a> {
6114 type Inner = QuickChat<'a>;
6115 #[inline]
6116 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
6117 Self {
6118 _tab: flatbuffers::Table { buf, loc },
6119 }
6120 }
6121 }
6122
6123 impl<'a> QuickChat<'a> {
6124 #[inline]
6125 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
6126 QuickChat { _tab: table }
6127 }
6128 #[allow(unused_mut)]
6129 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
6130 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
6131 args: &'args QuickChatArgs,
6132 ) -> flatbuffers::WIPOffset<QuickChat<'bldr>> {
6133 let mut builder = QuickChatBuilder::new(_fbb);
6134 builder.add_playerIndex(args.playerIndex);
6135 builder.add_teamOnly(args.teamOnly);
6136 builder.add_quickChatSelection(args.quickChatSelection);
6137 builder.finish()
6138 }
6139
6140 pub const VT_QUICKCHATSELECTION: flatbuffers::VOffsetT = 4;
6141 pub const VT_PLAYERINDEX: flatbuffers::VOffsetT = 6;
6142 pub const VT_TEAMONLY: flatbuffers::VOffsetT = 8;
6143
6144 #[inline]
6145 pub fn quickChatSelection(&self) -> QuickChatSelection {
6146 self._tab
6147 .get::<QuickChatSelection>(
6148 QuickChat::VT_QUICKCHATSELECTION,
6149 Some(QuickChatSelection::Information_IGotIt),
6150 )
6151 .unwrap()
6152 }
6153 #[inline]
6155 pub fn playerIndex(&self) -> i32 {
6156 self._tab
6157 .get::<i32>(QuickChat::VT_PLAYERINDEX, Some(0))
6158 .unwrap()
6159 }
6160 #[inline]
6162 pub fn teamOnly(&self) -> bool {
6163 self._tab
6164 .get::<bool>(QuickChat::VT_TEAMONLY, Some(false))
6165 .unwrap()
6166 }
6167 }
6168
6169 pub struct QuickChatArgs {
6170 pub quickChatSelection: QuickChatSelection,
6171 pub playerIndex: i32,
6172 pub teamOnly: bool,
6173 }
6174 impl<'a> Default for QuickChatArgs {
6175 #[inline]
6176 fn default() -> Self {
6177 QuickChatArgs {
6178 quickChatSelection: QuickChatSelection::Information_IGotIt,
6179 playerIndex: 0,
6180 teamOnly: false,
6181 }
6182 }
6183 }
6184 pub struct QuickChatBuilder<'a: 'b, 'b> {
6185 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6186 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
6187 }
6188 impl<'a: 'b, 'b> QuickChatBuilder<'a, 'b> {
6189 #[inline]
6190 pub fn add_quickChatSelection(&mut self, quickChatSelection: QuickChatSelection) {
6191 self.fbb_.push_slot::<QuickChatSelection>(
6192 QuickChat::VT_QUICKCHATSELECTION,
6193 quickChatSelection,
6194 QuickChatSelection::Information_IGotIt,
6195 );
6196 }
6197 #[inline]
6198 pub fn add_playerIndex(&mut self, playerIndex: i32) {
6199 self.fbb_
6200 .push_slot::<i32>(QuickChat::VT_PLAYERINDEX, playerIndex, 0);
6201 }
6202 #[inline]
6203 pub fn add_teamOnly(&mut self, teamOnly: bool) {
6204 self.fbb_
6205 .push_slot::<bool>(QuickChat::VT_TEAMONLY, teamOnly, false);
6206 }
6207 #[inline]
6208 pub fn new(
6209 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6210 ) -> QuickChatBuilder<'a, 'b> {
6211 let start = _fbb.start_table();
6212 QuickChatBuilder {
6213 fbb_: _fbb,
6214 start_: start,
6215 }
6216 }
6217 #[inline]
6218 pub fn finish(self) -> flatbuffers::WIPOffset<QuickChat<'a>> {
6219 let o = self.fbb_.end_table(self.start_);
6220 flatbuffers::WIPOffset::new(o.value())
6221 }
6222 }
6223
6224 pub enum TinyPlayerOffset {}
6227 #[derive(Copy, Clone, Debug, PartialEq)]
6228
6229 pub struct TinyPlayer<'a> {
6230 pub _tab: flatbuffers::Table<'a>,
6231 }
6232
6233 impl<'a> flatbuffers::Follow<'a> for TinyPlayer<'a> {
6234 type Inner = TinyPlayer<'a>;
6235 #[inline]
6236 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
6237 Self {
6238 _tab: flatbuffers::Table { buf, loc },
6239 }
6240 }
6241 }
6242
6243 impl<'a> TinyPlayer<'a> {
6244 #[inline]
6245 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
6246 TinyPlayer { _tab: table }
6247 }
6248 #[allow(unused_mut)]
6249 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
6250 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
6251 args: &'args TinyPlayerArgs<'args>,
6252 ) -> flatbuffers::WIPOffset<TinyPlayer<'bldr>> {
6253 let mut builder = TinyPlayerBuilder::new(_fbb);
6254 builder.add_boost(args.boost);
6255 builder.add_team(args.team);
6256 if let Some(x) = args.velocity {
6257 builder.add_velocity(x);
6258 }
6259 if let Some(x) = args.rotation {
6260 builder.add_rotation(x);
6261 }
6262 if let Some(x) = args.location {
6263 builder.add_location(x);
6264 }
6265 builder.add_isSupersonic(args.isSupersonic);
6266 builder.add_hasWheelContact(args.hasWheelContact);
6267 builder.finish()
6268 }
6269
6270 pub const VT_LOCATION: flatbuffers::VOffsetT = 4;
6271 pub const VT_ROTATION: flatbuffers::VOffsetT = 6;
6272 pub const VT_VELOCITY: flatbuffers::VOffsetT = 8;
6273 pub const VT_HASWHEELCONTACT: flatbuffers::VOffsetT = 10;
6274 pub const VT_ISSUPERSONIC: flatbuffers::VOffsetT = 12;
6275 pub const VT_TEAM: flatbuffers::VOffsetT = 14;
6276 pub const VT_BOOST: flatbuffers::VOffsetT = 16;
6277
6278 #[inline]
6279 pub fn location(&self) -> Option<&'a Vector3> {
6280 self._tab.get::<Vector3>(TinyPlayer::VT_LOCATION, None)
6281 }
6282 #[inline]
6283 pub fn rotation(&self) -> Option<&'a Rotator> {
6284 self._tab.get::<Rotator>(TinyPlayer::VT_ROTATION, None)
6285 }
6286 #[inline]
6287 pub fn velocity(&self) -> Option<&'a Vector3> {
6288 self._tab.get::<Vector3>(TinyPlayer::VT_VELOCITY, None)
6289 }
6290 #[inline]
6291 pub fn hasWheelContact(&self) -> bool {
6292 self._tab
6293 .get::<bool>(TinyPlayer::VT_HASWHEELCONTACT, Some(false))
6294 .unwrap()
6295 }
6296 #[inline]
6297 pub fn isSupersonic(&self) -> bool {
6298 self._tab
6299 .get::<bool>(TinyPlayer::VT_ISSUPERSONIC, Some(false))
6300 .unwrap()
6301 }
6302 #[inline]
6303 pub fn team(&self) -> i32 {
6304 self._tab.get::<i32>(TinyPlayer::VT_TEAM, Some(0)).unwrap()
6305 }
6306 #[inline]
6307 pub fn boost(&self) -> i32 {
6308 self._tab.get::<i32>(TinyPlayer::VT_BOOST, Some(0)).unwrap()
6309 }
6310 }
6311
6312 pub struct TinyPlayerArgs<'a> {
6313 pub location: Option<&'a Vector3>,
6314 pub rotation: Option<&'a Rotator>,
6315 pub velocity: Option<&'a Vector3>,
6316 pub hasWheelContact: bool,
6317 pub isSupersonic: bool,
6318 pub team: i32,
6319 pub boost: i32,
6320 }
6321 impl<'a> Default for TinyPlayerArgs<'a> {
6322 #[inline]
6323 fn default() -> Self {
6324 TinyPlayerArgs {
6325 location: None,
6326 rotation: None,
6327 velocity: None,
6328 hasWheelContact: false,
6329 isSupersonic: false,
6330 team: 0,
6331 boost: 0,
6332 }
6333 }
6334 }
6335 pub struct TinyPlayerBuilder<'a: 'b, 'b> {
6336 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6337 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
6338 }
6339 impl<'a: 'b, 'b> TinyPlayerBuilder<'a, 'b> {
6340 #[inline]
6341 pub fn add_location(&mut self, location: &'b Vector3) {
6342 self.fbb_
6343 .push_slot_always::<&Vector3>(TinyPlayer::VT_LOCATION, location);
6344 }
6345 #[inline]
6346 pub fn add_rotation(&mut self, rotation: &'b Rotator) {
6347 self.fbb_
6348 .push_slot_always::<&Rotator>(TinyPlayer::VT_ROTATION, rotation);
6349 }
6350 #[inline]
6351 pub fn add_velocity(&mut self, velocity: &'b Vector3) {
6352 self.fbb_
6353 .push_slot_always::<&Vector3>(TinyPlayer::VT_VELOCITY, velocity);
6354 }
6355 #[inline]
6356 pub fn add_hasWheelContact(&mut self, hasWheelContact: bool) {
6357 self.fbb_
6358 .push_slot::<bool>(TinyPlayer::VT_HASWHEELCONTACT, hasWheelContact, false);
6359 }
6360 #[inline]
6361 pub fn add_isSupersonic(&mut self, isSupersonic: bool) {
6362 self.fbb_
6363 .push_slot::<bool>(TinyPlayer::VT_ISSUPERSONIC, isSupersonic, false);
6364 }
6365 #[inline]
6366 pub fn add_team(&mut self, team: i32) {
6367 self.fbb_.push_slot::<i32>(TinyPlayer::VT_TEAM, team, 0);
6368 }
6369 #[inline]
6370 pub fn add_boost(&mut self, boost: i32) {
6371 self.fbb_.push_slot::<i32>(TinyPlayer::VT_BOOST, boost, 0);
6372 }
6373 #[inline]
6374 pub fn new(
6375 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6376 ) -> TinyPlayerBuilder<'a, 'b> {
6377 let start = _fbb.start_table();
6378 TinyPlayerBuilder {
6379 fbb_: _fbb,
6380 start_: start,
6381 }
6382 }
6383 #[inline]
6384 pub fn finish(self) -> flatbuffers::WIPOffset<TinyPlayer<'a>> {
6385 let o = self.fbb_.end_table(self.start_);
6386 flatbuffers::WIPOffset::new(o.value())
6387 }
6388 }
6389
6390 pub enum TinyBallOffset {}
6393 #[derive(Copy, Clone, Debug, PartialEq)]
6394
6395 pub struct TinyBall<'a> {
6396 pub _tab: flatbuffers::Table<'a>,
6397 }
6398
6399 impl<'a> flatbuffers::Follow<'a> for TinyBall<'a> {
6400 type Inner = TinyBall<'a>;
6401 #[inline]
6402 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
6403 Self {
6404 _tab: flatbuffers::Table { buf, loc },
6405 }
6406 }
6407 }
6408
6409 impl<'a> TinyBall<'a> {
6410 #[inline]
6411 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
6412 TinyBall { _tab: table }
6413 }
6414 #[allow(unused_mut)]
6415 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
6416 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
6417 args: &'args TinyBallArgs<'args>,
6418 ) -> flatbuffers::WIPOffset<TinyBall<'bldr>> {
6419 let mut builder = TinyBallBuilder::new(_fbb);
6420 if let Some(x) = args.velocity {
6421 builder.add_velocity(x);
6422 }
6423 if let Some(x) = args.location {
6424 builder.add_location(x);
6425 }
6426 builder.finish()
6427 }
6428
6429 pub const VT_LOCATION: flatbuffers::VOffsetT = 4;
6430 pub const VT_VELOCITY: flatbuffers::VOffsetT = 6;
6431
6432 #[inline]
6433 pub fn location(&self) -> Option<&'a Vector3> {
6434 self._tab.get::<Vector3>(TinyBall::VT_LOCATION, None)
6435 }
6436 #[inline]
6437 pub fn velocity(&self) -> Option<&'a Vector3> {
6438 self._tab.get::<Vector3>(TinyBall::VT_VELOCITY, None)
6439 }
6440 }
6441
6442 pub struct TinyBallArgs<'a> {
6443 pub location: Option<&'a Vector3>,
6444 pub velocity: Option<&'a Vector3>,
6445 }
6446 impl<'a> Default for TinyBallArgs<'a> {
6447 #[inline]
6448 fn default() -> Self {
6449 TinyBallArgs {
6450 location: None,
6451 velocity: None,
6452 }
6453 }
6454 }
6455 pub struct TinyBallBuilder<'a: 'b, 'b> {
6456 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6457 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
6458 }
6459 impl<'a: 'b, 'b> TinyBallBuilder<'a, 'b> {
6460 #[inline]
6461 pub fn add_location(&mut self, location: &'b Vector3) {
6462 self.fbb_
6463 .push_slot_always::<&Vector3>(TinyBall::VT_LOCATION, location);
6464 }
6465 #[inline]
6466 pub fn add_velocity(&mut self, velocity: &'b Vector3) {
6467 self.fbb_
6468 .push_slot_always::<&Vector3>(TinyBall::VT_VELOCITY, velocity);
6469 }
6470 #[inline]
6471 pub fn new(
6472 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6473 ) -> TinyBallBuilder<'a, 'b> {
6474 let start = _fbb.start_table();
6475 TinyBallBuilder {
6476 fbb_: _fbb,
6477 start_: start,
6478 }
6479 }
6480 #[inline]
6481 pub fn finish(self) -> flatbuffers::WIPOffset<TinyBall<'a>> {
6482 let o = self.fbb_.end_table(self.start_);
6483 flatbuffers::WIPOffset::new(o.value())
6484 }
6485 }
6486
6487 pub enum TinyPacketOffset {}
6490 #[derive(Copy, Clone, Debug, PartialEq)]
6491
6492 pub struct TinyPacket<'a> {
6493 pub _tab: flatbuffers::Table<'a>,
6494 }
6495
6496 impl<'a> flatbuffers::Follow<'a> for TinyPacket<'a> {
6497 type Inner = TinyPacket<'a>;
6498 #[inline]
6499 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
6500 Self {
6501 _tab: flatbuffers::Table { buf, loc },
6502 }
6503 }
6504 }
6505
6506 impl<'a> TinyPacket<'a> {
6507 #[inline]
6508 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
6509 TinyPacket { _tab: table }
6510 }
6511 #[allow(unused_mut)]
6512 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
6513 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
6514 args: &'args TinyPacketArgs<'args>,
6515 ) -> flatbuffers::WIPOffset<TinyPacket<'bldr>> {
6516 let mut builder = TinyPacketBuilder::new(_fbb);
6517 if let Some(x) = args.ball {
6518 builder.add_ball(x);
6519 }
6520 if let Some(x) = args.players {
6521 builder.add_players(x);
6522 }
6523 builder.finish()
6524 }
6525
6526 pub const VT_PLAYERS: flatbuffers::VOffsetT = 4;
6527 pub const VT_BALL: flatbuffers::VOffsetT = 6;
6528
6529 #[inline]
6530 pub fn players(
6531 &self,
6532 ) -> Option<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TinyPlayer<'a>>>>
6533 {
6534 self._tab.get::<flatbuffers::ForwardsUOffset<
6535 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TinyPlayer<'a>>>,
6536 >>(TinyPacket::VT_PLAYERS, None)
6537 }
6538 #[inline]
6539 pub fn ball(&self) -> Option<TinyBall<'a>> {
6540 self._tab
6541 .get::<flatbuffers::ForwardsUOffset<TinyBall<'a>>>(TinyPacket::VT_BALL, None)
6542 }
6543 }
6544
6545 pub struct TinyPacketArgs<'a> {
6546 pub players: Option<
6547 flatbuffers::WIPOffset<
6548 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TinyPlayer<'a>>>,
6549 >,
6550 >,
6551 pub ball: Option<flatbuffers::WIPOffset<TinyBall<'a>>>,
6552 }
6553 impl<'a> Default for TinyPacketArgs<'a> {
6554 #[inline]
6555 fn default() -> Self {
6556 TinyPacketArgs {
6557 players: None,
6558 ball: None,
6559 }
6560 }
6561 }
6562 pub struct TinyPacketBuilder<'a: 'b, 'b> {
6563 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6564 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
6565 }
6566 impl<'a: 'b, 'b> TinyPacketBuilder<'a, 'b> {
6567 #[inline]
6568 pub fn add_players(
6569 &mut self,
6570 players: flatbuffers::WIPOffset<
6571 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<TinyPlayer<'b>>>,
6572 >,
6573 ) {
6574 self.fbb_
6575 .push_slot_always::<flatbuffers::WIPOffset<_>>(TinyPacket::VT_PLAYERS, players);
6576 }
6577 #[inline]
6578 pub fn add_ball(&mut self, ball: flatbuffers::WIPOffset<TinyBall<'b>>) {
6579 self.fbb_
6580 .push_slot_always::<flatbuffers::WIPOffset<TinyBall<'_>>>(
6581 TinyPacket::VT_BALL,
6582 ball,
6583 );
6584 }
6585 #[inline]
6586 pub fn new(
6587 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6588 ) -> TinyPacketBuilder<'a, 'b> {
6589 let start = _fbb.start_table();
6590 TinyPacketBuilder {
6591 fbb_: _fbb,
6592 start_: start,
6593 }
6594 }
6595 #[inline]
6596 pub fn finish(self) -> flatbuffers::WIPOffset<TinyPacket<'a>> {
6597 let o = self.fbb_.end_table(self.start_);
6598 flatbuffers::WIPOffset::new(o.value())
6599 }
6600 }
6601
6602 pub enum PredictionSliceOffset {}
6603 #[derive(Copy, Clone, Debug, PartialEq)]
6604
6605 pub struct PredictionSlice<'a> {
6606 pub _tab: flatbuffers::Table<'a>,
6607 }
6608
6609 impl<'a> flatbuffers::Follow<'a> for PredictionSlice<'a> {
6610 type Inner = PredictionSlice<'a>;
6611 #[inline]
6612 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
6613 Self {
6614 _tab: flatbuffers::Table { buf, loc },
6615 }
6616 }
6617 }
6618
6619 impl<'a> PredictionSlice<'a> {
6620 #[inline]
6621 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
6622 PredictionSlice { _tab: table }
6623 }
6624 #[allow(unused_mut)]
6625 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
6626 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
6627 args: &'args PredictionSliceArgs<'args>,
6628 ) -> flatbuffers::WIPOffset<PredictionSlice<'bldr>> {
6629 let mut builder = PredictionSliceBuilder::new(_fbb);
6630 if let Some(x) = args.physics {
6631 builder.add_physics(x);
6632 }
6633 builder.add_gameSeconds(args.gameSeconds);
6634 builder.finish()
6635 }
6636
6637 pub const VT_GAMESECONDS: flatbuffers::VOffsetT = 4;
6638 pub const VT_PHYSICS: flatbuffers::VOffsetT = 6;
6639
6640 #[inline]
6643 pub fn gameSeconds(&self) -> f32 {
6644 self._tab
6645 .get::<f32>(PredictionSlice::VT_GAMESECONDS, Some(0.0))
6646 .unwrap()
6647 }
6648 #[inline]
6650 pub fn physics(&self) -> Option<Physics<'a>> {
6651 self._tab.get::<flatbuffers::ForwardsUOffset<Physics<'a>>>(
6652 PredictionSlice::VT_PHYSICS,
6653 None,
6654 )
6655 }
6656 }
6657
6658 pub struct PredictionSliceArgs<'a> {
6659 pub gameSeconds: f32,
6660 pub physics: Option<flatbuffers::WIPOffset<Physics<'a>>>,
6661 }
6662 impl<'a> Default for PredictionSliceArgs<'a> {
6663 #[inline]
6664 fn default() -> Self {
6665 PredictionSliceArgs {
6666 gameSeconds: 0.0,
6667 physics: None,
6668 }
6669 }
6670 }
6671 pub struct PredictionSliceBuilder<'a: 'b, 'b> {
6672 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6673 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
6674 }
6675 impl<'a: 'b, 'b> PredictionSliceBuilder<'a, 'b> {
6676 #[inline]
6677 pub fn add_gameSeconds(&mut self, gameSeconds: f32) {
6678 self.fbb_
6679 .push_slot::<f32>(PredictionSlice::VT_GAMESECONDS, gameSeconds, 0.0);
6680 }
6681 #[inline]
6682 pub fn add_physics(&mut self, physics: flatbuffers::WIPOffset<Physics<'b>>) {
6683 self.fbb_
6684 .push_slot_always::<flatbuffers::WIPOffset<Physics<'_>>>(
6685 PredictionSlice::VT_PHYSICS,
6686 physics,
6687 );
6688 }
6689 #[inline]
6690 pub fn new(
6691 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6692 ) -> PredictionSliceBuilder<'a, 'b> {
6693 let start = _fbb.start_table();
6694 PredictionSliceBuilder {
6695 fbb_: _fbb,
6696 start_: start,
6697 }
6698 }
6699 #[inline]
6700 pub fn finish(self) -> flatbuffers::WIPOffset<PredictionSlice<'a>> {
6701 let o = self.fbb_.end_table(self.start_);
6702 flatbuffers::WIPOffset::new(o.value())
6703 }
6704 }
6705
6706 pub enum BallPredictionOffset {}
6707 #[derive(Copy, Clone, Debug, PartialEq)]
6708
6709 pub struct BallPrediction<'a> {
6710 pub _tab: flatbuffers::Table<'a>,
6711 }
6712
6713 impl<'a> flatbuffers::Follow<'a> for BallPrediction<'a> {
6714 type Inner = BallPrediction<'a>;
6715 #[inline]
6716 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
6717 Self {
6718 _tab: flatbuffers::Table { buf, loc },
6719 }
6720 }
6721 }
6722
6723 impl<'a> BallPrediction<'a> {
6724 #[inline]
6725 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
6726 BallPrediction { _tab: table }
6727 }
6728 #[allow(unused_mut)]
6729 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
6730 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
6731 args: &'args BallPredictionArgs<'args>,
6732 ) -> flatbuffers::WIPOffset<BallPrediction<'bldr>> {
6733 let mut builder = BallPredictionBuilder::new(_fbb);
6734 if let Some(x) = args.slices {
6735 builder.add_slices(x);
6736 }
6737 builder.finish()
6738 }
6739
6740 pub const VT_SLICES: flatbuffers::VOffsetT = 4;
6741
6742 #[inline]
6747 pub fn slices(
6748 &self,
6749 ) -> Option<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PredictionSlice<'a>>>>
6750 {
6751 self._tab.get::<flatbuffers::ForwardsUOffset<
6752 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PredictionSlice<'a>>>,
6753 >>(BallPrediction::VT_SLICES, None)
6754 }
6755 }
6756
6757 pub struct BallPredictionArgs<'a> {
6758 pub slices: Option<
6759 flatbuffers::WIPOffset<
6760 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PredictionSlice<'a>>>,
6761 >,
6762 >,
6763 }
6764 impl<'a> Default for BallPredictionArgs<'a> {
6765 #[inline]
6766 fn default() -> Self {
6767 BallPredictionArgs { slices: None }
6768 }
6769 }
6770 pub struct BallPredictionBuilder<'a: 'b, 'b> {
6771 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6772 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
6773 }
6774 impl<'a: 'b, 'b> BallPredictionBuilder<'a, 'b> {
6775 #[inline]
6776 pub fn add_slices(
6777 &mut self,
6778 slices: flatbuffers::WIPOffset<
6779 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<PredictionSlice<'b>>>,
6780 >,
6781 ) {
6782 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
6783 BallPrediction::VT_SLICES,
6784 slices,
6785 );
6786 }
6787 #[inline]
6788 pub fn new(
6789 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6790 ) -> BallPredictionBuilder<'a, 'b> {
6791 let start = _fbb.start_table();
6792 BallPredictionBuilder {
6793 fbb_: _fbb,
6794 start_: start,
6795 }
6796 }
6797 #[inline]
6798 pub fn finish(self) -> flatbuffers::WIPOffset<BallPrediction<'a>> {
6799 let o = self.fbb_.end_table(self.start_);
6800 flatbuffers::WIPOffset::new(o.value())
6801 }
6802 }
6803
6804 pub enum RLBotPlayerOffset {}
6806 #[derive(Copy, Clone, Debug, PartialEq)]
6807
6808 pub struct RLBotPlayer<'a> {
6809 pub _tab: flatbuffers::Table<'a>,
6810 }
6811
6812 impl<'a> flatbuffers::Follow<'a> for RLBotPlayer<'a> {
6813 type Inner = RLBotPlayer<'a>;
6814 #[inline]
6815 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
6816 Self {
6817 _tab: flatbuffers::Table { buf, loc },
6818 }
6819 }
6820 }
6821
6822 impl<'a> RLBotPlayer<'a> {
6823 #[inline]
6824 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
6825 RLBotPlayer { _tab: table }
6826 }
6827 #[allow(unused_mut)]
6828 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
6829 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
6830 _args: &'args RLBotPlayerArgs,
6831 ) -> flatbuffers::WIPOffset<RLBotPlayer<'bldr>> {
6832 let mut builder = RLBotPlayerBuilder::new(_fbb);
6833 builder.finish()
6834 }
6835 }
6836
6837 pub struct RLBotPlayerArgs {}
6838 impl<'a> Default for RLBotPlayerArgs {
6839 #[inline]
6840 fn default() -> Self {
6841 RLBotPlayerArgs {}
6842 }
6843 }
6844 pub struct RLBotPlayerBuilder<'a: 'b, 'b> {
6845 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6846 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
6847 }
6848 impl<'a: 'b, 'b> RLBotPlayerBuilder<'a, 'b> {
6849 #[inline]
6850 pub fn new(
6851 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6852 ) -> RLBotPlayerBuilder<'a, 'b> {
6853 let start = _fbb.start_table();
6854 RLBotPlayerBuilder {
6855 fbb_: _fbb,
6856 start_: start,
6857 }
6858 }
6859 #[inline]
6860 pub fn finish(self) -> flatbuffers::WIPOffset<RLBotPlayer<'a>> {
6861 let o = self.fbb_.end_table(self.start_);
6862 flatbuffers::WIPOffset::new(o.value())
6863 }
6864 }
6865
6866 pub enum HumanPlayerOffset {}
6868 #[derive(Copy, Clone, Debug, PartialEq)]
6869
6870 pub struct HumanPlayer<'a> {
6871 pub _tab: flatbuffers::Table<'a>,
6872 }
6873
6874 impl<'a> flatbuffers::Follow<'a> for HumanPlayer<'a> {
6875 type Inner = HumanPlayer<'a>;
6876 #[inline]
6877 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
6878 Self {
6879 _tab: flatbuffers::Table { buf, loc },
6880 }
6881 }
6882 }
6883
6884 impl<'a> HumanPlayer<'a> {
6885 #[inline]
6886 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
6887 HumanPlayer { _tab: table }
6888 }
6889 #[allow(unused_mut)]
6890 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
6891 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
6892 _args: &'args HumanPlayerArgs,
6893 ) -> flatbuffers::WIPOffset<HumanPlayer<'bldr>> {
6894 let mut builder = HumanPlayerBuilder::new(_fbb);
6895 builder.finish()
6896 }
6897 }
6898
6899 pub struct HumanPlayerArgs {}
6900 impl<'a> Default for HumanPlayerArgs {
6901 #[inline]
6902 fn default() -> Self {
6903 HumanPlayerArgs {}
6904 }
6905 }
6906 pub struct HumanPlayerBuilder<'a: 'b, 'b> {
6907 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6908 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
6909 }
6910 impl<'a: 'b, 'b> HumanPlayerBuilder<'a, 'b> {
6911 #[inline]
6912 pub fn new(
6913 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6914 ) -> HumanPlayerBuilder<'a, 'b> {
6915 let start = _fbb.start_table();
6916 HumanPlayerBuilder {
6917 fbb_: _fbb,
6918 start_: start,
6919 }
6920 }
6921 #[inline]
6922 pub fn finish(self) -> flatbuffers::WIPOffset<HumanPlayer<'a>> {
6923 let o = self.fbb_.end_table(self.start_);
6924 flatbuffers::WIPOffset::new(o.value())
6925 }
6926 }
6927
6928 pub enum PsyonixBotPlayerOffset {}
6930 #[derive(Copy, Clone, Debug, PartialEq)]
6931
6932 pub struct PsyonixBotPlayer<'a> {
6933 pub _tab: flatbuffers::Table<'a>,
6934 }
6935
6936 impl<'a> flatbuffers::Follow<'a> for PsyonixBotPlayer<'a> {
6937 type Inner = PsyonixBotPlayer<'a>;
6938 #[inline]
6939 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
6940 Self {
6941 _tab: flatbuffers::Table { buf, loc },
6942 }
6943 }
6944 }
6945
6946 impl<'a> PsyonixBotPlayer<'a> {
6947 #[inline]
6948 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
6949 PsyonixBotPlayer { _tab: table }
6950 }
6951 #[allow(unused_mut)]
6952 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
6953 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
6954 args: &'args PsyonixBotPlayerArgs,
6955 ) -> flatbuffers::WIPOffset<PsyonixBotPlayer<'bldr>> {
6956 let mut builder = PsyonixBotPlayerBuilder::new(_fbb);
6957 builder.add_botSkill(args.botSkill);
6958 builder.finish()
6959 }
6960
6961 pub const VT_BOTSKILL: flatbuffers::VOffsetT = 4;
6962
6963 #[inline]
6964 pub fn botSkill(&self) -> f32 {
6965 self._tab
6966 .get::<f32>(PsyonixBotPlayer::VT_BOTSKILL, Some(0.0))
6967 .unwrap()
6968 }
6969 }
6970
6971 pub struct PsyonixBotPlayerArgs {
6972 pub botSkill: f32,
6973 }
6974 impl<'a> Default for PsyonixBotPlayerArgs {
6975 #[inline]
6976 fn default() -> Self {
6977 PsyonixBotPlayerArgs { botSkill: 0.0 }
6978 }
6979 }
6980 pub struct PsyonixBotPlayerBuilder<'a: 'b, 'b> {
6981 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6982 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
6983 }
6984 impl<'a: 'b, 'b> PsyonixBotPlayerBuilder<'a, 'b> {
6985 #[inline]
6986 pub fn add_botSkill(&mut self, botSkill: f32) {
6987 self.fbb_
6988 .push_slot::<f32>(PsyonixBotPlayer::VT_BOTSKILL, botSkill, 0.0);
6989 }
6990 #[inline]
6991 pub fn new(
6992 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
6993 ) -> PsyonixBotPlayerBuilder<'a, 'b> {
6994 let start = _fbb.start_table();
6995 PsyonixBotPlayerBuilder {
6996 fbb_: _fbb,
6997 start_: start,
6998 }
6999 }
7000 #[inline]
7001 pub fn finish(self) -> flatbuffers::WIPOffset<PsyonixBotPlayer<'a>> {
7002 let o = self.fbb_.end_table(self.start_);
7003 flatbuffers::WIPOffset::new(o.value())
7004 }
7005 }
7006
7007 pub enum PartyMemberBotPlayerOffset {}
7011 #[derive(Copy, Clone, Debug, PartialEq)]
7012
7013 pub struct PartyMemberBotPlayer<'a> {
7014 pub _tab: flatbuffers::Table<'a>,
7015 }
7016
7017 impl<'a> flatbuffers::Follow<'a> for PartyMemberBotPlayer<'a> {
7018 type Inner = PartyMemberBotPlayer<'a>;
7019 #[inline]
7020 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
7021 Self {
7022 _tab: flatbuffers::Table { buf, loc },
7023 }
7024 }
7025 }
7026
7027 impl<'a> PartyMemberBotPlayer<'a> {
7028 #[inline]
7029 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
7030 PartyMemberBotPlayer { _tab: table }
7031 }
7032 #[allow(unused_mut)]
7033 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
7034 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
7035 _args: &'args PartyMemberBotPlayerArgs,
7036 ) -> flatbuffers::WIPOffset<PartyMemberBotPlayer<'bldr>> {
7037 let mut builder = PartyMemberBotPlayerBuilder::new(_fbb);
7038 builder.finish()
7039 }
7040 }
7041
7042 pub struct PartyMemberBotPlayerArgs {}
7043 impl<'a> Default for PartyMemberBotPlayerArgs {
7044 #[inline]
7045 fn default() -> Self {
7046 PartyMemberBotPlayerArgs {}
7047 }
7048 }
7049 pub struct PartyMemberBotPlayerBuilder<'a: 'b, 'b> {
7050 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
7051 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
7052 }
7053 impl<'a: 'b, 'b> PartyMemberBotPlayerBuilder<'a, 'b> {
7054 #[inline]
7055 pub fn new(
7056 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
7057 ) -> PartyMemberBotPlayerBuilder<'a, 'b> {
7058 let start = _fbb.start_table();
7059 PartyMemberBotPlayerBuilder {
7060 fbb_: _fbb,
7061 start_: start,
7062 }
7063 }
7064 #[inline]
7065 pub fn finish(self) -> flatbuffers::WIPOffset<PartyMemberBotPlayer<'a>> {
7066 let o = self.fbb_.end_table(self.start_);
7067 flatbuffers::WIPOffset::new(o.value())
7068 }
7069 }
7070
7071 pub enum PlayerLoadoutOffset {}
7074 #[derive(Copy, Clone, Debug, PartialEq)]
7075
7076 pub struct PlayerLoadout<'a> {
7077 pub _tab: flatbuffers::Table<'a>,
7078 }
7079
7080 impl<'a> flatbuffers::Follow<'a> for PlayerLoadout<'a> {
7081 type Inner = PlayerLoadout<'a>;
7082 #[inline]
7083 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
7084 Self {
7085 _tab: flatbuffers::Table { buf, loc },
7086 }
7087 }
7088 }
7089
7090 impl<'a> PlayerLoadout<'a> {
7091 #[inline]
7092 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
7093 PlayerLoadout { _tab: table }
7094 }
7095 #[allow(unused_mut)]
7096 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
7097 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
7098 args: &'args PlayerLoadoutArgs<'args>,
7099 ) -> flatbuffers::WIPOffset<PlayerLoadout<'bldr>> {
7100 let mut builder = PlayerLoadoutBuilder::new(_fbb);
7101 if let Some(x) = args.loadoutPaint {
7102 builder.add_loadoutPaint(x);
7103 }
7104 builder.add_goalExplosionId(args.goalExplosionId);
7105 builder.add_trailsId(args.trailsId);
7106 builder.add_engineAudioId(args.engineAudioId);
7107 builder.add_customFinishId(args.customFinishId);
7108 builder.add_paintFinishId(args.paintFinishId);
7109 builder.add_hatId(args.hatId);
7110 builder.add_antennaId(args.antennaId);
7111 builder.add_boostId(args.boostId);
7112 builder.add_wheelsId(args.wheelsId);
7113 builder.add_decalId(args.decalId);
7114 builder.add_carId(args.carId);
7115 builder.add_customColorId(args.customColorId);
7116 builder.add_teamColorId(args.teamColorId);
7117 builder.finish()
7118 }
7119
7120 pub const VT_TEAMCOLORID: flatbuffers::VOffsetT = 4;
7121 pub const VT_CUSTOMCOLORID: flatbuffers::VOffsetT = 6;
7122 pub const VT_CARID: flatbuffers::VOffsetT = 8;
7123 pub const VT_DECALID: flatbuffers::VOffsetT = 10;
7124 pub const VT_WHEELSID: flatbuffers::VOffsetT = 12;
7125 pub const VT_BOOSTID: flatbuffers::VOffsetT = 14;
7126 pub const VT_ANTENNAID: flatbuffers::VOffsetT = 16;
7127 pub const VT_HATID: flatbuffers::VOffsetT = 18;
7128 pub const VT_PAINTFINISHID: flatbuffers::VOffsetT = 20;
7129 pub const VT_CUSTOMFINISHID: flatbuffers::VOffsetT = 22;
7130 pub const VT_ENGINEAUDIOID: flatbuffers::VOffsetT = 24;
7131 pub const VT_TRAILSID: flatbuffers::VOffsetT = 26;
7132 pub const VT_GOALEXPLOSIONID: flatbuffers::VOffsetT = 28;
7133 pub const VT_LOADOUTPAINT: flatbuffers::VOffsetT = 30;
7134
7135 #[inline]
7136 pub fn teamColorId(&self) -> i32 {
7137 self._tab
7138 .get::<i32>(PlayerLoadout::VT_TEAMCOLORID, Some(0))
7139 .unwrap()
7140 }
7141 #[inline]
7142 pub fn customColorId(&self) -> i32 {
7143 self._tab
7144 .get::<i32>(PlayerLoadout::VT_CUSTOMCOLORID, Some(0))
7145 .unwrap()
7146 }
7147 #[inline]
7148 pub fn carId(&self) -> i32 {
7149 self._tab
7150 .get::<i32>(PlayerLoadout::VT_CARID, Some(0))
7151 .unwrap()
7152 }
7153 #[inline]
7154 pub fn decalId(&self) -> i32 {
7155 self._tab
7156 .get::<i32>(PlayerLoadout::VT_DECALID, Some(0))
7157 .unwrap()
7158 }
7159 #[inline]
7160 pub fn wheelsId(&self) -> i32 {
7161 self._tab
7162 .get::<i32>(PlayerLoadout::VT_WHEELSID, Some(0))
7163 .unwrap()
7164 }
7165 #[inline]
7166 pub fn boostId(&self) -> i32 {
7167 self._tab
7168 .get::<i32>(PlayerLoadout::VT_BOOSTID, Some(0))
7169 .unwrap()
7170 }
7171 #[inline]
7172 pub fn antennaId(&self) -> i32 {
7173 self._tab
7174 .get::<i32>(PlayerLoadout::VT_ANTENNAID, Some(0))
7175 .unwrap()
7176 }
7177 #[inline]
7178 pub fn hatId(&self) -> i32 {
7179 self._tab
7180 .get::<i32>(PlayerLoadout::VT_HATID, Some(0))
7181 .unwrap()
7182 }
7183 #[inline]
7184 pub fn paintFinishId(&self) -> i32 {
7185 self._tab
7186 .get::<i32>(PlayerLoadout::VT_PAINTFINISHID, Some(0))
7187 .unwrap()
7188 }
7189 #[inline]
7190 pub fn customFinishId(&self) -> i32 {
7191 self._tab
7192 .get::<i32>(PlayerLoadout::VT_CUSTOMFINISHID, Some(0))
7193 .unwrap()
7194 }
7195 #[inline]
7196 pub fn engineAudioId(&self) -> i32 {
7197 self._tab
7198 .get::<i32>(PlayerLoadout::VT_ENGINEAUDIOID, Some(0))
7199 .unwrap()
7200 }
7201 #[inline]
7202 pub fn trailsId(&self) -> i32 {
7203 self._tab
7204 .get::<i32>(PlayerLoadout::VT_TRAILSID, Some(0))
7205 .unwrap()
7206 }
7207 #[inline]
7208 pub fn goalExplosionId(&self) -> i32 {
7209 self._tab
7210 .get::<i32>(PlayerLoadout::VT_GOALEXPLOSIONID, Some(0))
7211 .unwrap()
7212 }
7213 #[inline]
7214 pub fn loadoutPaint(&self) -> Option<LoadoutPaint<'a>> {
7215 self._tab
7216 .get::<flatbuffers::ForwardsUOffset<LoadoutPaint<'a>>>(
7217 PlayerLoadout::VT_LOADOUTPAINT,
7218 None,
7219 )
7220 }
7221 }
7222
7223 pub struct PlayerLoadoutArgs<'a> {
7224 pub teamColorId: i32,
7225 pub customColorId: i32,
7226 pub carId: i32,
7227 pub decalId: i32,
7228 pub wheelsId: i32,
7229 pub boostId: i32,
7230 pub antennaId: i32,
7231 pub hatId: i32,
7232 pub paintFinishId: i32,
7233 pub customFinishId: i32,
7234 pub engineAudioId: i32,
7235 pub trailsId: i32,
7236 pub goalExplosionId: i32,
7237 pub loadoutPaint: Option<flatbuffers::WIPOffset<LoadoutPaint<'a>>>,
7238 }
7239 impl<'a> Default for PlayerLoadoutArgs<'a> {
7240 #[inline]
7241 fn default() -> Self {
7242 PlayerLoadoutArgs {
7243 teamColorId: 0,
7244 customColorId: 0,
7245 carId: 0,
7246 decalId: 0,
7247 wheelsId: 0,
7248 boostId: 0,
7249 antennaId: 0,
7250 hatId: 0,
7251 paintFinishId: 0,
7252 customFinishId: 0,
7253 engineAudioId: 0,
7254 trailsId: 0,
7255 goalExplosionId: 0,
7256 loadoutPaint: None,
7257 }
7258 }
7259 }
7260 pub struct PlayerLoadoutBuilder<'a: 'b, 'b> {
7261 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
7262 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
7263 }
7264 impl<'a: 'b, 'b> PlayerLoadoutBuilder<'a, 'b> {
7265 #[inline]
7266 pub fn add_teamColorId(&mut self, teamColorId: i32) {
7267 self.fbb_
7268 .push_slot::<i32>(PlayerLoadout::VT_TEAMCOLORID, teamColorId, 0);
7269 }
7270 #[inline]
7271 pub fn add_customColorId(&mut self, customColorId: i32) {
7272 self.fbb_
7273 .push_slot::<i32>(PlayerLoadout::VT_CUSTOMCOLORID, customColorId, 0);
7274 }
7275 #[inline]
7276 pub fn add_carId(&mut self, carId: i32) {
7277 self.fbb_
7278 .push_slot::<i32>(PlayerLoadout::VT_CARID, carId, 0);
7279 }
7280 #[inline]
7281 pub fn add_decalId(&mut self, decalId: i32) {
7282 self.fbb_
7283 .push_slot::<i32>(PlayerLoadout::VT_DECALID, decalId, 0);
7284 }
7285 #[inline]
7286 pub fn add_wheelsId(&mut self, wheelsId: i32) {
7287 self.fbb_
7288 .push_slot::<i32>(PlayerLoadout::VT_WHEELSID, wheelsId, 0);
7289 }
7290 #[inline]
7291 pub fn add_boostId(&mut self, boostId: i32) {
7292 self.fbb_
7293 .push_slot::<i32>(PlayerLoadout::VT_BOOSTID, boostId, 0);
7294 }
7295 #[inline]
7296 pub fn add_antennaId(&mut self, antennaId: i32) {
7297 self.fbb_
7298 .push_slot::<i32>(PlayerLoadout::VT_ANTENNAID, antennaId, 0);
7299 }
7300 #[inline]
7301 pub fn add_hatId(&mut self, hatId: i32) {
7302 self.fbb_
7303 .push_slot::<i32>(PlayerLoadout::VT_HATID, hatId, 0);
7304 }
7305 #[inline]
7306 pub fn add_paintFinishId(&mut self, paintFinishId: i32) {
7307 self.fbb_
7308 .push_slot::<i32>(PlayerLoadout::VT_PAINTFINISHID, paintFinishId, 0);
7309 }
7310 #[inline]
7311 pub fn add_customFinishId(&mut self, customFinishId: i32) {
7312 self.fbb_
7313 .push_slot::<i32>(PlayerLoadout::VT_CUSTOMFINISHID, customFinishId, 0);
7314 }
7315 #[inline]
7316 pub fn add_engineAudioId(&mut self, engineAudioId: i32) {
7317 self.fbb_
7318 .push_slot::<i32>(PlayerLoadout::VT_ENGINEAUDIOID, engineAudioId, 0);
7319 }
7320 #[inline]
7321 pub fn add_trailsId(&mut self, trailsId: i32) {
7322 self.fbb_
7323 .push_slot::<i32>(PlayerLoadout::VT_TRAILSID, trailsId, 0);
7324 }
7325 #[inline]
7326 pub fn add_goalExplosionId(&mut self, goalExplosionId: i32) {
7327 self.fbb_
7328 .push_slot::<i32>(PlayerLoadout::VT_GOALEXPLOSIONID, goalExplosionId, 0);
7329 }
7330 #[inline]
7331 pub fn add_loadoutPaint(
7332 &mut self,
7333 loadoutPaint: flatbuffers::WIPOffset<LoadoutPaint<'b>>,
7334 ) {
7335 self.fbb_
7336 .push_slot_always::<flatbuffers::WIPOffset<LoadoutPaint<'_>>>(
7337 PlayerLoadout::VT_LOADOUTPAINT,
7338 loadoutPaint,
7339 );
7340 }
7341 #[inline]
7342 pub fn new(
7343 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
7344 ) -> PlayerLoadoutBuilder<'a, 'b> {
7345 let start = _fbb.start_table();
7346 PlayerLoadoutBuilder {
7347 fbb_: _fbb,
7348 start_: start,
7349 }
7350 }
7351 #[inline]
7352 pub fn finish(self) -> flatbuffers::WIPOffset<PlayerLoadout<'a>> {
7353 let o = self.fbb_.end_table(self.start_);
7354 flatbuffers::WIPOffset::new(o.value())
7355 }
7356 }
7357
7358 pub enum LoadoutPaintOffset {}
7360 #[derive(Copy, Clone, Debug, PartialEq)]
7361
7362 pub struct LoadoutPaint<'a> {
7363 pub _tab: flatbuffers::Table<'a>,
7364 }
7365
7366 impl<'a> flatbuffers::Follow<'a> for LoadoutPaint<'a> {
7367 type Inner = LoadoutPaint<'a>;
7368 #[inline]
7369 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
7370 Self {
7371 _tab: flatbuffers::Table { buf, loc },
7372 }
7373 }
7374 }
7375
7376 impl<'a> LoadoutPaint<'a> {
7377 #[inline]
7378 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
7379 LoadoutPaint { _tab: table }
7380 }
7381 #[allow(unused_mut)]
7382 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
7383 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
7384 args: &'args LoadoutPaintArgs,
7385 ) -> flatbuffers::WIPOffset<LoadoutPaint<'bldr>> {
7386 let mut builder = LoadoutPaintBuilder::new(_fbb);
7387 builder.add_goalExplosionPaintId(args.goalExplosionPaintId);
7388 builder.add_trailsPaintId(args.trailsPaintId);
7389 builder.add_hatPaintId(args.hatPaintId);
7390 builder.add_antennaPaintId(args.antennaPaintId);
7391 builder.add_boostPaintId(args.boostPaintId);
7392 builder.add_wheelsPaintId(args.wheelsPaintId);
7393 builder.add_decalPaintId(args.decalPaintId);
7394 builder.add_carPaintId(args.carPaintId);
7395 builder.finish()
7396 }
7397
7398 pub const VT_CARPAINTID: flatbuffers::VOffsetT = 4;
7399 pub const VT_DECALPAINTID: flatbuffers::VOffsetT = 6;
7400 pub const VT_WHEELSPAINTID: flatbuffers::VOffsetT = 8;
7401 pub const VT_BOOSTPAINTID: flatbuffers::VOffsetT = 10;
7402 pub const VT_ANTENNAPAINTID: flatbuffers::VOffsetT = 12;
7403 pub const VT_HATPAINTID: flatbuffers::VOffsetT = 14;
7404 pub const VT_TRAILSPAINTID: flatbuffers::VOffsetT = 16;
7405 pub const VT_GOALEXPLOSIONPAINTID: flatbuffers::VOffsetT = 18;
7406
7407 #[inline]
7408 pub fn carPaintId(&self) -> i32 {
7409 self._tab
7410 .get::<i32>(LoadoutPaint::VT_CARPAINTID, Some(0))
7411 .unwrap()
7412 }
7413 #[inline]
7414 pub fn decalPaintId(&self) -> i32 {
7415 self._tab
7416 .get::<i32>(LoadoutPaint::VT_DECALPAINTID, Some(0))
7417 .unwrap()
7418 }
7419 #[inline]
7420 pub fn wheelsPaintId(&self) -> i32 {
7421 self._tab
7422 .get::<i32>(LoadoutPaint::VT_WHEELSPAINTID, Some(0))
7423 .unwrap()
7424 }
7425 #[inline]
7426 pub fn boostPaintId(&self) -> i32 {
7427 self._tab
7428 .get::<i32>(LoadoutPaint::VT_BOOSTPAINTID, Some(0))
7429 .unwrap()
7430 }
7431 #[inline]
7432 pub fn antennaPaintId(&self) -> i32 {
7433 self._tab
7434 .get::<i32>(LoadoutPaint::VT_ANTENNAPAINTID, Some(0))
7435 .unwrap()
7436 }
7437 #[inline]
7438 pub fn hatPaintId(&self) -> i32 {
7439 self._tab
7440 .get::<i32>(LoadoutPaint::VT_HATPAINTID, Some(0))
7441 .unwrap()
7442 }
7443 #[inline]
7444 pub fn trailsPaintId(&self) -> i32 {
7445 self._tab
7446 .get::<i32>(LoadoutPaint::VT_TRAILSPAINTID, Some(0))
7447 .unwrap()
7448 }
7449 #[inline]
7450 pub fn goalExplosionPaintId(&self) -> i32 {
7451 self._tab
7452 .get::<i32>(LoadoutPaint::VT_GOALEXPLOSIONPAINTID, Some(0))
7453 .unwrap()
7454 }
7455 }
7456
7457 pub struct LoadoutPaintArgs {
7458 pub carPaintId: i32,
7459 pub decalPaintId: i32,
7460 pub wheelsPaintId: i32,
7461 pub boostPaintId: i32,
7462 pub antennaPaintId: i32,
7463 pub hatPaintId: i32,
7464 pub trailsPaintId: i32,
7465 pub goalExplosionPaintId: i32,
7466 }
7467 impl<'a> Default for LoadoutPaintArgs {
7468 #[inline]
7469 fn default() -> Self {
7470 LoadoutPaintArgs {
7471 carPaintId: 0,
7472 decalPaintId: 0,
7473 wheelsPaintId: 0,
7474 boostPaintId: 0,
7475 antennaPaintId: 0,
7476 hatPaintId: 0,
7477 trailsPaintId: 0,
7478 goalExplosionPaintId: 0,
7479 }
7480 }
7481 }
7482 pub struct LoadoutPaintBuilder<'a: 'b, 'b> {
7483 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
7484 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
7485 }
7486 impl<'a: 'b, 'b> LoadoutPaintBuilder<'a, 'b> {
7487 #[inline]
7488 pub fn add_carPaintId(&mut self, carPaintId: i32) {
7489 self.fbb_
7490 .push_slot::<i32>(LoadoutPaint::VT_CARPAINTID, carPaintId, 0);
7491 }
7492 #[inline]
7493 pub fn add_decalPaintId(&mut self, decalPaintId: i32) {
7494 self.fbb_
7495 .push_slot::<i32>(LoadoutPaint::VT_DECALPAINTID, decalPaintId, 0);
7496 }
7497 #[inline]
7498 pub fn add_wheelsPaintId(&mut self, wheelsPaintId: i32) {
7499 self.fbb_
7500 .push_slot::<i32>(LoadoutPaint::VT_WHEELSPAINTID, wheelsPaintId, 0);
7501 }
7502 #[inline]
7503 pub fn add_boostPaintId(&mut self, boostPaintId: i32) {
7504 self.fbb_
7505 .push_slot::<i32>(LoadoutPaint::VT_BOOSTPAINTID, boostPaintId, 0);
7506 }
7507 #[inline]
7508 pub fn add_antennaPaintId(&mut self, antennaPaintId: i32) {
7509 self.fbb_
7510 .push_slot::<i32>(LoadoutPaint::VT_ANTENNAPAINTID, antennaPaintId, 0);
7511 }
7512 #[inline]
7513 pub fn add_hatPaintId(&mut self, hatPaintId: i32) {
7514 self.fbb_
7515 .push_slot::<i32>(LoadoutPaint::VT_HATPAINTID, hatPaintId, 0);
7516 }
7517 #[inline]
7518 pub fn add_trailsPaintId(&mut self, trailsPaintId: i32) {
7519 self.fbb_
7520 .push_slot::<i32>(LoadoutPaint::VT_TRAILSPAINTID, trailsPaintId, 0);
7521 }
7522 #[inline]
7523 pub fn add_goalExplosionPaintId(&mut self, goalExplosionPaintId: i32) {
7524 self.fbb_.push_slot::<i32>(
7525 LoadoutPaint::VT_GOALEXPLOSIONPAINTID,
7526 goalExplosionPaintId,
7527 0,
7528 );
7529 }
7530 #[inline]
7531 pub fn new(
7532 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
7533 ) -> LoadoutPaintBuilder<'a, 'b> {
7534 let start = _fbb.start_table();
7535 LoadoutPaintBuilder {
7536 fbb_: _fbb,
7537 start_: start,
7538 }
7539 }
7540 #[inline]
7541 pub fn finish(self) -> flatbuffers::WIPOffset<LoadoutPaint<'a>> {
7542 let o = self.fbb_.end_table(self.start_);
7543 flatbuffers::WIPOffset::new(o.value())
7544 }
7545 }
7546
7547 pub enum PlayerConfigurationOffset {}
7548 #[derive(Copy, Clone, Debug, PartialEq)]
7549
7550 pub struct PlayerConfiguration<'a> {
7551 pub _tab: flatbuffers::Table<'a>,
7552 }
7553
7554 impl<'a> flatbuffers::Follow<'a> for PlayerConfiguration<'a> {
7555 type Inner = PlayerConfiguration<'a>;
7556 #[inline]
7557 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
7558 Self {
7559 _tab: flatbuffers::Table { buf, loc },
7560 }
7561 }
7562 }
7563
7564 impl<'a> PlayerConfiguration<'a> {
7565 #[inline]
7566 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
7567 PlayerConfiguration { _tab: table }
7568 }
7569 #[allow(unused_mut)]
7570 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
7571 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
7572 args: &'args PlayerConfigurationArgs<'args>,
7573 ) -> flatbuffers::WIPOffset<PlayerConfiguration<'bldr>> {
7574 let mut builder = PlayerConfigurationBuilder::new(_fbb);
7575 if let Some(x) = args.loadout {
7576 builder.add_loadout(x);
7577 }
7578 builder.add_team(args.team);
7579 if let Some(x) = args.name {
7580 builder.add_name(x);
7581 }
7582 if let Some(x) = args.variety {
7583 builder.add_variety(x);
7584 }
7585 builder.add_variety_type(args.variety_type);
7586 builder.finish()
7587 }
7588
7589 pub const VT_VARIETY_TYPE: flatbuffers::VOffsetT = 4;
7590 pub const VT_VARIETY: flatbuffers::VOffsetT = 6;
7591 pub const VT_NAME: flatbuffers::VOffsetT = 8;
7592 pub const VT_TEAM: flatbuffers::VOffsetT = 10;
7593 pub const VT_LOADOUT: flatbuffers::VOffsetT = 12;
7594
7595 #[inline]
7596 pub fn variety_type(&self) -> PlayerClass {
7597 self._tab
7598 .get::<PlayerClass>(
7599 PlayerConfiguration::VT_VARIETY_TYPE,
7600 Some(PlayerClass::NONE),
7601 )
7602 .unwrap()
7603 }
7604 #[inline]
7605 pub fn variety(&self) -> Option<flatbuffers::Table<'a>> {
7606 self._tab
7607 .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
7608 PlayerConfiguration::VT_VARIETY,
7609 None,
7610 )
7611 }
7612 #[inline]
7613 pub fn name(&self) -> Option<&'a str> {
7614 self._tab
7615 .get::<flatbuffers::ForwardsUOffset<&str>>(PlayerConfiguration::VT_NAME, None)
7616 }
7617 #[inline]
7618 pub fn team(&self) -> i32 {
7619 self._tab
7620 .get::<i32>(PlayerConfiguration::VT_TEAM, Some(0))
7621 .unwrap()
7622 }
7623 #[inline]
7624 pub fn loadout(&self) -> Option<PlayerLoadout<'a>> {
7625 self._tab
7626 .get::<flatbuffers::ForwardsUOffset<PlayerLoadout<'a>>>(
7627 PlayerConfiguration::VT_LOADOUT,
7628 None,
7629 )
7630 }
7631 #[inline]
7632 #[allow(non_snake_case)]
7633 pub fn variety_as_rlbot_player(&'a self) -> Option<RLBotPlayer<'_>> {
7634 if self.variety_type() == PlayerClass::RLBotPlayer {
7635 self.variety().map(|u| RLBotPlayer::init_from_table(u))
7636 } else {
7637 None
7638 }
7639 }
7640
7641 #[inline]
7642 #[allow(non_snake_case)]
7643 pub fn variety_as_human_player(&'a self) -> Option<HumanPlayer<'_>> {
7644 if self.variety_type() == PlayerClass::HumanPlayer {
7645 self.variety().map(|u| HumanPlayer::init_from_table(u))
7646 } else {
7647 None
7648 }
7649 }
7650
7651 #[inline]
7652 #[allow(non_snake_case)]
7653 pub fn variety_as_psyonix_bot_player(&'a self) -> Option<PsyonixBotPlayer<'_>> {
7654 if self.variety_type() == PlayerClass::PsyonixBotPlayer {
7655 self.variety().map(|u| PsyonixBotPlayer::init_from_table(u))
7656 } else {
7657 None
7658 }
7659 }
7660
7661 #[inline]
7662 #[allow(non_snake_case)]
7663 pub fn variety_as_party_member_bot_player(
7664 &'a self,
7665 ) -> Option<PartyMemberBotPlayer<'_>> {
7666 if self.variety_type() == PlayerClass::PartyMemberBotPlayer {
7667 self.variety()
7668 .map(|u| PartyMemberBotPlayer::init_from_table(u))
7669 } else {
7670 None
7671 }
7672 }
7673 }
7674
7675 pub struct PlayerConfigurationArgs<'a> {
7676 pub variety_type: PlayerClass,
7677 pub variety: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
7678 pub name: Option<flatbuffers::WIPOffset<&'a str>>,
7679 pub team: i32,
7680 pub loadout: Option<flatbuffers::WIPOffset<PlayerLoadout<'a>>>,
7681 }
7682 impl<'a> Default for PlayerConfigurationArgs<'a> {
7683 #[inline]
7684 fn default() -> Self {
7685 PlayerConfigurationArgs {
7686 variety_type: PlayerClass::NONE,
7687 variety: None,
7688 name: None,
7689 team: 0,
7690 loadout: None,
7691 }
7692 }
7693 }
7694 pub struct PlayerConfigurationBuilder<'a: 'b, 'b> {
7695 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
7696 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
7697 }
7698 impl<'a: 'b, 'b> PlayerConfigurationBuilder<'a, 'b> {
7699 #[inline]
7700 pub fn add_variety_type(&mut self, variety_type: PlayerClass) {
7701 self.fbb_.push_slot::<PlayerClass>(
7702 PlayerConfiguration::VT_VARIETY_TYPE,
7703 variety_type,
7704 PlayerClass::NONE,
7705 );
7706 }
7707 #[inline]
7708 pub fn add_variety(
7709 &mut self,
7710 variety: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
7711 ) {
7712 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
7713 PlayerConfiguration::VT_VARIETY,
7714 variety,
7715 );
7716 }
7717 #[inline]
7718 pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
7719 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
7720 PlayerConfiguration::VT_NAME,
7721 name,
7722 );
7723 }
7724 #[inline]
7725 pub fn add_team(&mut self, team: i32) {
7726 self.fbb_
7727 .push_slot::<i32>(PlayerConfiguration::VT_TEAM, team, 0);
7728 }
7729 #[inline]
7730 pub fn add_loadout(&mut self, loadout: flatbuffers::WIPOffset<PlayerLoadout<'b>>) {
7731 self.fbb_
7732 .push_slot_always::<flatbuffers::WIPOffset<PlayerLoadout<'_>>>(
7733 PlayerConfiguration::VT_LOADOUT,
7734 loadout,
7735 );
7736 }
7737 #[inline]
7738 pub fn new(
7739 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
7740 ) -> PlayerConfigurationBuilder<'a, 'b> {
7741 let start = _fbb.start_table();
7742 PlayerConfigurationBuilder {
7743 fbb_: _fbb,
7744 start_: start,
7745 }
7746 }
7747 #[inline]
7748 pub fn finish(self) -> flatbuffers::WIPOffset<PlayerConfiguration<'a>> {
7749 let o = self.fbb_.end_table(self.start_);
7750 flatbuffers::WIPOffset::new(o.value())
7751 }
7752 }
7753
7754 pub enum MutatorSettingsOffset {}
7755 #[derive(Copy, Clone, Debug, PartialEq)]
7756
7757 pub struct MutatorSettings<'a> {
7758 pub _tab: flatbuffers::Table<'a>,
7759 }
7760
7761 impl<'a> flatbuffers::Follow<'a> for MutatorSettings<'a> {
7762 type Inner = MutatorSettings<'a>;
7763 #[inline]
7764 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
7765 Self {
7766 _tab: flatbuffers::Table { buf, loc },
7767 }
7768 }
7769 }
7770
7771 impl<'a> MutatorSettings<'a> {
7772 #[inline]
7773 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
7774 MutatorSettings { _tab: table }
7775 }
7776 #[allow(unused_mut)]
7777 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
7778 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
7779 args: &'args MutatorSettingsArgs,
7780 ) -> flatbuffers::WIPOffset<MutatorSettings<'bldr>> {
7781 let mut builder = MutatorSettingsBuilder::new(_fbb);
7782 builder.add_respawnTimeOption(args.respawnTimeOption);
7783 builder.add_demolishOption(args.demolishOption);
7784 builder.add_gravityOption(args.gravityOption);
7785 builder.add_boostStrengthOption(args.boostStrengthOption);
7786 builder.add_rumbleOption(args.rumbleOption);
7787 builder.add_boostOption(args.boostOption);
7788 builder.add_ballBouncinessOption(args.ballBouncinessOption);
7789 builder.add_ballSizeOption(args.ballSizeOption);
7790 builder.add_ballWeightOption(args.ballWeightOption);
7791 builder.add_ballTypeOption(args.ballTypeOption);
7792 builder.add_ballMaxSpeedOption(args.ballMaxSpeedOption);
7793 builder.add_gameSpeedOption(args.gameSpeedOption);
7794 builder.add_seriesLengthOption(args.seriesLengthOption);
7795 builder.add_overtimeOption(args.overtimeOption);
7796 builder.add_maxScore(args.maxScore);
7797 builder.add_matchLength(args.matchLength);
7798 builder.finish()
7799 }
7800
7801 pub const VT_MATCHLENGTH: flatbuffers::VOffsetT = 4;
7802 pub const VT_MAXSCORE: flatbuffers::VOffsetT = 6;
7803 pub const VT_OVERTIMEOPTION: flatbuffers::VOffsetT = 8;
7804 pub const VT_SERIESLENGTHOPTION: flatbuffers::VOffsetT = 10;
7805 pub const VT_GAMESPEEDOPTION: flatbuffers::VOffsetT = 12;
7806 pub const VT_BALLMAXSPEEDOPTION: flatbuffers::VOffsetT = 14;
7807 pub const VT_BALLTYPEOPTION: flatbuffers::VOffsetT = 16;
7808 pub const VT_BALLWEIGHTOPTION: flatbuffers::VOffsetT = 18;
7809 pub const VT_BALLSIZEOPTION: flatbuffers::VOffsetT = 20;
7810 pub const VT_BALLBOUNCINESSOPTION: flatbuffers::VOffsetT = 22;
7811 pub const VT_BOOSTOPTION: flatbuffers::VOffsetT = 24;
7812 pub const VT_RUMBLEOPTION: flatbuffers::VOffsetT = 26;
7813 pub const VT_BOOSTSTRENGTHOPTION: flatbuffers::VOffsetT = 28;
7814 pub const VT_GRAVITYOPTION: flatbuffers::VOffsetT = 30;
7815 pub const VT_DEMOLISHOPTION: flatbuffers::VOffsetT = 32;
7816 pub const VT_RESPAWNTIMEOPTION: flatbuffers::VOffsetT = 34;
7817
7818 #[inline]
7819 pub fn matchLength(&self) -> MatchLength {
7820 self._tab
7821 .get::<MatchLength>(
7822 MutatorSettings::VT_MATCHLENGTH,
7823 Some(MatchLength::Five_Minutes),
7824 )
7825 .unwrap()
7826 }
7827 #[inline]
7828 pub fn maxScore(&self) -> MaxScore {
7829 self._tab
7830 .get::<MaxScore>(MutatorSettings::VT_MAXSCORE, Some(MaxScore::Unlimited))
7831 .unwrap()
7832 }
7833 #[inline]
7834 pub fn overtimeOption(&self) -> OvertimeOption {
7835 self._tab
7836 .get::<OvertimeOption>(
7837 MutatorSettings::VT_OVERTIMEOPTION,
7838 Some(OvertimeOption::Unlimited),
7839 )
7840 .unwrap()
7841 }
7842 #[inline]
7843 pub fn seriesLengthOption(&self) -> SeriesLengthOption {
7844 self._tab
7845 .get::<SeriesLengthOption>(
7846 MutatorSettings::VT_SERIESLENGTHOPTION,
7847 Some(SeriesLengthOption::Unlimited),
7848 )
7849 .unwrap()
7850 }
7851 #[inline]
7852 pub fn gameSpeedOption(&self) -> GameSpeedOption {
7853 self._tab
7854 .get::<GameSpeedOption>(
7855 MutatorSettings::VT_GAMESPEEDOPTION,
7856 Some(GameSpeedOption::Default),
7857 )
7858 .unwrap()
7859 }
7860 #[inline]
7861 pub fn ballMaxSpeedOption(&self) -> BallMaxSpeedOption {
7862 self._tab
7863 .get::<BallMaxSpeedOption>(
7864 MutatorSettings::VT_BALLMAXSPEEDOPTION,
7865 Some(BallMaxSpeedOption::Default),
7866 )
7867 .unwrap()
7868 }
7869 #[inline]
7870 pub fn ballTypeOption(&self) -> BallTypeOption {
7871 self._tab
7872 .get::<BallTypeOption>(
7873 MutatorSettings::VT_BALLTYPEOPTION,
7874 Some(BallTypeOption::Default),
7875 )
7876 .unwrap()
7877 }
7878 #[inline]
7879 pub fn ballWeightOption(&self) -> BallWeightOption {
7880 self._tab
7881 .get::<BallWeightOption>(
7882 MutatorSettings::VT_BALLWEIGHTOPTION,
7883 Some(BallWeightOption::Default),
7884 )
7885 .unwrap()
7886 }
7887 #[inline]
7888 pub fn ballSizeOption(&self) -> BallSizeOption {
7889 self._tab
7890 .get::<BallSizeOption>(
7891 MutatorSettings::VT_BALLSIZEOPTION,
7892 Some(BallSizeOption::Default),
7893 )
7894 .unwrap()
7895 }
7896 #[inline]
7897 pub fn ballBouncinessOption(&self) -> BallBouncinessOption {
7898 self._tab
7899 .get::<BallBouncinessOption>(
7900 MutatorSettings::VT_BALLBOUNCINESSOPTION,
7901 Some(BallBouncinessOption::Default),
7902 )
7903 .unwrap()
7904 }
7905 #[inline]
7906 pub fn boostOption(&self) -> BoostOption {
7907 self._tab
7908 .get::<BoostOption>(
7909 MutatorSettings::VT_BOOSTOPTION,
7910 Some(BoostOption::Normal_Boost),
7911 )
7912 .unwrap()
7913 }
7914 #[inline]
7915 pub fn rumbleOption(&self) -> RumbleOption {
7916 self._tab
7917 .get::<RumbleOption>(MutatorSettings::VT_RUMBLEOPTION, Some(RumbleOption::None))
7918 .unwrap()
7919 }
7920 #[inline]
7921 pub fn boostStrengthOption(&self) -> BoostStrengthOption {
7922 self._tab
7923 .get::<BoostStrengthOption>(
7924 MutatorSettings::VT_BOOSTSTRENGTHOPTION,
7925 Some(BoostStrengthOption::One),
7926 )
7927 .unwrap()
7928 }
7929 #[inline]
7930 pub fn gravityOption(&self) -> GravityOption {
7931 self._tab
7932 .get::<GravityOption>(
7933 MutatorSettings::VT_GRAVITYOPTION,
7934 Some(GravityOption::Default),
7935 )
7936 .unwrap()
7937 }
7938 #[inline]
7939 pub fn demolishOption(&self) -> DemolishOption {
7940 self._tab
7941 .get::<DemolishOption>(
7942 MutatorSettings::VT_DEMOLISHOPTION,
7943 Some(DemolishOption::Default),
7944 )
7945 .unwrap()
7946 }
7947 #[inline]
7948 pub fn respawnTimeOption(&self) -> RespawnTimeOption {
7949 self._tab
7950 .get::<RespawnTimeOption>(
7951 MutatorSettings::VT_RESPAWNTIMEOPTION,
7952 Some(RespawnTimeOption::Three_Seconds),
7953 )
7954 .unwrap()
7955 }
7956 }
7957
7958 pub struct MutatorSettingsArgs {
7959 pub matchLength: MatchLength,
7960 pub maxScore: MaxScore,
7961 pub overtimeOption: OvertimeOption,
7962 pub seriesLengthOption: SeriesLengthOption,
7963 pub gameSpeedOption: GameSpeedOption,
7964 pub ballMaxSpeedOption: BallMaxSpeedOption,
7965 pub ballTypeOption: BallTypeOption,
7966 pub ballWeightOption: BallWeightOption,
7967 pub ballSizeOption: BallSizeOption,
7968 pub ballBouncinessOption: BallBouncinessOption,
7969 pub boostOption: BoostOption,
7970 pub rumbleOption: RumbleOption,
7971 pub boostStrengthOption: BoostStrengthOption,
7972 pub gravityOption: GravityOption,
7973 pub demolishOption: DemolishOption,
7974 pub respawnTimeOption: RespawnTimeOption,
7975 }
7976 impl<'a> Default for MutatorSettingsArgs {
7977 #[inline]
7978 fn default() -> Self {
7979 MutatorSettingsArgs {
7980 matchLength: MatchLength::Five_Minutes,
7981 maxScore: MaxScore::Unlimited,
7982 overtimeOption: OvertimeOption::Unlimited,
7983 seriesLengthOption: SeriesLengthOption::Unlimited,
7984 gameSpeedOption: GameSpeedOption::Default,
7985 ballMaxSpeedOption: BallMaxSpeedOption::Default,
7986 ballTypeOption: BallTypeOption::Default,
7987 ballWeightOption: BallWeightOption::Default,
7988 ballSizeOption: BallSizeOption::Default,
7989 ballBouncinessOption: BallBouncinessOption::Default,
7990 boostOption: BoostOption::Normal_Boost,
7991 rumbleOption: RumbleOption::None,
7992 boostStrengthOption: BoostStrengthOption::One,
7993 gravityOption: GravityOption::Default,
7994 demolishOption: DemolishOption::Default,
7995 respawnTimeOption: RespawnTimeOption::Three_Seconds,
7996 }
7997 }
7998 }
7999 pub struct MutatorSettingsBuilder<'a: 'b, 'b> {
8000 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
8001 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
8002 }
8003 impl<'a: 'b, 'b> MutatorSettingsBuilder<'a, 'b> {
8004 #[inline]
8005 pub fn add_matchLength(&mut self, matchLength: MatchLength) {
8006 self.fbb_.push_slot::<MatchLength>(
8007 MutatorSettings::VT_MATCHLENGTH,
8008 matchLength,
8009 MatchLength::Five_Minutes,
8010 );
8011 }
8012 #[inline]
8013 pub fn add_maxScore(&mut self, maxScore: MaxScore) {
8014 self.fbb_.push_slot::<MaxScore>(
8015 MutatorSettings::VT_MAXSCORE,
8016 maxScore,
8017 MaxScore::Unlimited,
8018 );
8019 }
8020 #[inline]
8021 pub fn add_overtimeOption(&mut self, overtimeOption: OvertimeOption) {
8022 self.fbb_.push_slot::<OvertimeOption>(
8023 MutatorSettings::VT_OVERTIMEOPTION,
8024 overtimeOption,
8025 OvertimeOption::Unlimited,
8026 );
8027 }
8028 #[inline]
8029 pub fn add_seriesLengthOption(&mut self, seriesLengthOption: SeriesLengthOption) {
8030 self.fbb_.push_slot::<SeriesLengthOption>(
8031 MutatorSettings::VT_SERIESLENGTHOPTION,
8032 seriesLengthOption,
8033 SeriesLengthOption::Unlimited,
8034 );
8035 }
8036 #[inline]
8037 pub fn add_gameSpeedOption(&mut self, gameSpeedOption: GameSpeedOption) {
8038 self.fbb_.push_slot::<GameSpeedOption>(
8039 MutatorSettings::VT_GAMESPEEDOPTION,
8040 gameSpeedOption,
8041 GameSpeedOption::Default,
8042 );
8043 }
8044 #[inline]
8045 pub fn add_ballMaxSpeedOption(&mut self, ballMaxSpeedOption: BallMaxSpeedOption) {
8046 self.fbb_.push_slot::<BallMaxSpeedOption>(
8047 MutatorSettings::VT_BALLMAXSPEEDOPTION,
8048 ballMaxSpeedOption,
8049 BallMaxSpeedOption::Default,
8050 );
8051 }
8052 #[inline]
8053 pub fn add_ballTypeOption(&mut self, ballTypeOption: BallTypeOption) {
8054 self.fbb_.push_slot::<BallTypeOption>(
8055 MutatorSettings::VT_BALLTYPEOPTION,
8056 ballTypeOption,
8057 BallTypeOption::Default,
8058 );
8059 }
8060 #[inline]
8061 pub fn add_ballWeightOption(&mut self, ballWeightOption: BallWeightOption) {
8062 self.fbb_.push_slot::<BallWeightOption>(
8063 MutatorSettings::VT_BALLWEIGHTOPTION,
8064 ballWeightOption,
8065 BallWeightOption::Default,
8066 );
8067 }
8068 #[inline]
8069 pub fn add_ballSizeOption(&mut self, ballSizeOption: BallSizeOption) {
8070 self.fbb_.push_slot::<BallSizeOption>(
8071 MutatorSettings::VT_BALLSIZEOPTION,
8072 ballSizeOption,
8073 BallSizeOption::Default,
8074 );
8075 }
8076 #[inline]
8077 pub fn add_ballBouncinessOption(&mut self, ballBouncinessOption: BallBouncinessOption) {
8078 self.fbb_.push_slot::<BallBouncinessOption>(
8079 MutatorSettings::VT_BALLBOUNCINESSOPTION,
8080 ballBouncinessOption,
8081 BallBouncinessOption::Default,
8082 );
8083 }
8084 #[inline]
8085 pub fn add_boostOption(&mut self, boostOption: BoostOption) {
8086 self.fbb_.push_slot::<BoostOption>(
8087 MutatorSettings::VT_BOOSTOPTION,
8088 boostOption,
8089 BoostOption::Normal_Boost,
8090 );
8091 }
8092 #[inline]
8093 pub fn add_rumbleOption(&mut self, rumbleOption: RumbleOption) {
8094 self.fbb_.push_slot::<RumbleOption>(
8095 MutatorSettings::VT_RUMBLEOPTION,
8096 rumbleOption,
8097 RumbleOption::None,
8098 );
8099 }
8100 #[inline]
8101 pub fn add_boostStrengthOption(&mut self, boostStrengthOption: BoostStrengthOption) {
8102 self.fbb_.push_slot::<BoostStrengthOption>(
8103 MutatorSettings::VT_BOOSTSTRENGTHOPTION,
8104 boostStrengthOption,
8105 BoostStrengthOption::One,
8106 );
8107 }
8108 #[inline]
8109 pub fn add_gravityOption(&mut self, gravityOption: GravityOption) {
8110 self.fbb_.push_slot::<GravityOption>(
8111 MutatorSettings::VT_GRAVITYOPTION,
8112 gravityOption,
8113 GravityOption::Default,
8114 );
8115 }
8116 #[inline]
8117 pub fn add_demolishOption(&mut self, demolishOption: DemolishOption) {
8118 self.fbb_.push_slot::<DemolishOption>(
8119 MutatorSettings::VT_DEMOLISHOPTION,
8120 demolishOption,
8121 DemolishOption::Default,
8122 );
8123 }
8124 #[inline]
8125 pub fn add_respawnTimeOption(&mut self, respawnTimeOption: RespawnTimeOption) {
8126 self.fbb_.push_slot::<RespawnTimeOption>(
8127 MutatorSettings::VT_RESPAWNTIMEOPTION,
8128 respawnTimeOption,
8129 RespawnTimeOption::Three_Seconds,
8130 );
8131 }
8132 #[inline]
8133 pub fn new(
8134 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
8135 ) -> MutatorSettingsBuilder<'a, 'b> {
8136 let start = _fbb.start_table();
8137 MutatorSettingsBuilder {
8138 fbb_: _fbb,
8139 start_: start,
8140 }
8141 }
8142 #[inline]
8143 pub fn finish(self) -> flatbuffers::WIPOffset<MutatorSettings<'a>> {
8144 let o = self.fbb_.end_table(self.start_);
8145 flatbuffers::WIPOffset::new(o.value())
8146 }
8147 }
8148
8149 pub enum MatchSettingsOffset {}
8150 #[derive(Copy, Clone, Debug, PartialEq)]
8151
8152 pub struct MatchSettings<'a> {
8153 pub _tab: flatbuffers::Table<'a>,
8154 }
8155
8156 impl<'a> flatbuffers::Follow<'a> for MatchSettings<'a> {
8157 type Inner = MatchSettings<'a>;
8158 #[inline]
8159 fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
8160 Self {
8161 _tab: flatbuffers::Table { buf, loc },
8162 }
8163 }
8164 }
8165
8166 impl<'a> MatchSettings<'a> {
8167 #[inline]
8168 pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
8169 MatchSettings { _tab: table }
8170 }
8171 #[allow(unused_mut)]
8172 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
8173 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
8174 args: &'args MatchSettingsArgs<'args>,
8175 ) -> flatbuffers::WIPOffset<MatchSettings<'bldr>> {
8176 let mut builder = MatchSettingsBuilder::new(_fbb);
8177 if let Some(x) = args.mutatorSettings {
8178 builder.add_mutatorSettings(x);
8179 }
8180 if let Some(x) = args.playerConfigurations {
8181 builder.add_playerConfigurations(x);
8182 }
8183 builder.add_instantStart(args.instantStart);
8184 builder.add_skipReplays(args.skipReplays);
8185 builder.add_gameMap(args.gameMap);
8186 builder.add_gameMode(args.gameMode);
8187 builder.finish()
8188 }
8189
8190 pub const VT_PLAYERCONFIGURATIONS: flatbuffers::VOffsetT = 4;
8191 pub const VT_GAMEMODE: flatbuffers::VOffsetT = 6;
8192 pub const VT_GAMEMAP: flatbuffers::VOffsetT = 8;
8193 pub const VT_SKIPREPLAYS: flatbuffers::VOffsetT = 10;
8194 pub const VT_INSTANTSTART: flatbuffers::VOffsetT = 12;
8195 pub const VT_MUTATORSETTINGS: flatbuffers::VOffsetT = 14;
8196
8197 #[inline]
8198 pub fn playerConfigurations(
8199 &self,
8200 ) -> Option<
8201 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PlayerConfiguration<'a>>>,
8202 > {
8203 self._tab.get::<flatbuffers::ForwardsUOffset<
8204 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<PlayerConfiguration<'a>>>,
8205 >>(MatchSettings::VT_PLAYERCONFIGURATIONS, None)
8206 }
8207 #[inline]
8208 pub fn gameMode(&self) -> GameMode {
8209 self._tab
8210 .get::<GameMode>(MatchSettings::VT_GAMEMODE, Some(GameMode::Soccer))
8211 .unwrap()
8212 }
8213 #[inline]
8214 pub fn gameMap(&self) -> GameMap {
8215 self._tab
8216 .get::<GameMap>(MatchSettings::VT_GAMEMAP, Some(GameMap::DFHStadium))
8217 .unwrap()
8218 }
8219 #[inline]
8220 pub fn skipReplays(&self) -> bool {
8221 self._tab
8222 .get::<bool>(MatchSettings::VT_SKIPREPLAYS, Some(false))
8223 .unwrap()
8224 }
8225 #[inline]
8226 pub fn instantStart(&self) -> bool {
8227 self._tab
8228 .get::<bool>(MatchSettings::VT_INSTANTSTART, Some(false))
8229 .unwrap()
8230 }
8231 #[inline]
8232 pub fn mutatorSettings(&self) -> Option<MutatorSettings<'a>> {
8233 self._tab
8234 .get::<flatbuffers::ForwardsUOffset<MutatorSettings<'a>>>(
8235 MatchSettings::VT_MUTATORSETTINGS,
8236 None,
8237 )
8238 }
8239 }
8240
8241 pub struct MatchSettingsArgs<'a> {
8242 pub playerConfigurations: Option<
8243 flatbuffers::WIPOffset<
8244 flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<PlayerConfiguration<'a>>>,
8245 >,
8246 >,
8247 pub gameMode: GameMode,
8248 pub gameMap: GameMap,
8249 pub skipReplays: bool,
8250 pub instantStart: bool,
8251 pub mutatorSettings: Option<flatbuffers::WIPOffset<MutatorSettings<'a>>>,
8252 }
8253 impl<'a> Default for MatchSettingsArgs<'a> {
8254 #[inline]
8255 fn default() -> Self {
8256 MatchSettingsArgs {
8257 playerConfigurations: None,
8258 gameMode: GameMode::Soccer,
8259 gameMap: GameMap::DFHStadium,
8260 skipReplays: false,
8261 instantStart: false,
8262 mutatorSettings: None,
8263 }
8264 }
8265 }
8266 pub struct MatchSettingsBuilder<'a: 'b, 'b> {
8267 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
8268 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
8269 }
8270 impl<'a: 'b, 'b> MatchSettingsBuilder<'a, 'b> {
8271 #[inline]
8272 pub fn add_playerConfigurations(
8273 &mut self,
8274 playerConfigurations: flatbuffers::WIPOffset<
8275 flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<PlayerConfiguration<'b>>>,
8276 >,
8277 ) {
8278 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
8279 MatchSettings::VT_PLAYERCONFIGURATIONS,
8280 playerConfigurations,
8281 );
8282 }
8283 #[inline]
8284 pub fn add_gameMode(&mut self, gameMode: GameMode) {
8285 self.fbb_.push_slot::<GameMode>(
8286 MatchSettings::VT_GAMEMODE,
8287 gameMode,
8288 GameMode::Soccer,
8289 );
8290 }
8291 #[inline]
8292 pub fn add_gameMap(&mut self, gameMap: GameMap) {
8293 self.fbb_.push_slot::<GameMap>(
8294 MatchSettings::VT_GAMEMAP,
8295 gameMap,
8296 GameMap::DFHStadium,
8297 );
8298 }
8299 #[inline]
8300 pub fn add_skipReplays(&mut self, skipReplays: bool) {
8301 self.fbb_
8302 .push_slot::<bool>(MatchSettings::VT_SKIPREPLAYS, skipReplays, false);
8303 }
8304 #[inline]
8305 pub fn add_instantStart(&mut self, instantStart: bool) {
8306 self.fbb_
8307 .push_slot::<bool>(MatchSettings::VT_INSTANTSTART, instantStart, false);
8308 }
8309 #[inline]
8310 pub fn add_mutatorSettings(
8311 &mut self,
8312 mutatorSettings: flatbuffers::WIPOffset<MutatorSettings<'b>>,
8313 ) {
8314 self.fbb_
8315 .push_slot_always::<flatbuffers::WIPOffset<MutatorSettings<'_>>>(
8316 MatchSettings::VT_MUTATORSETTINGS,
8317 mutatorSettings,
8318 );
8319 }
8320 #[inline]
8321 pub fn new(
8322 _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
8323 ) -> MatchSettingsBuilder<'a, 'b> {
8324 let start = _fbb.start_table();
8325 MatchSettingsBuilder {
8326 fbb_: _fbb,
8327 start_: start,
8328 }
8329 }
8330 #[inline]
8331 pub fn finish(self) -> flatbuffers::WIPOffset<MatchSettings<'a>> {
8332 let o = self.fbb_.end_table(self.start_);
8333 flatbuffers::WIPOffset::new(o.value())
8334 }
8335 }
8336
8337 #[inline]
8338 pub fn get_root_as_quick_chat<'a>(buf: &'a [u8]) -> QuickChat<'a> {
8339 flatbuffers::get_root::<QuickChat<'a>>(buf)
8340 }
8341
8342 #[inline]
8343 pub fn get_size_prefixed_root_as_quick_chat<'a>(buf: &'a [u8]) -> QuickChat<'a> {
8344 flatbuffers::get_size_prefixed_root::<QuickChat<'a>>(buf)
8345 }
8346
8347 #[inline]
8348 pub fn finish_quick_chat_buffer<'a, 'b>(
8349 fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
8350 root: flatbuffers::WIPOffset<QuickChat<'a>>,
8351 ) {
8352 fbb.finish(root, None);
8353 }
8354
8355 #[inline]
8356 pub fn finish_size_prefixed_quick_chat_buffer<'a, 'b>(
8357 fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
8358 root: flatbuffers::WIPOffset<QuickChat<'a>>,
8359 ) {
8360 fbb.finish_size_prefixed(root, None);
8361 }
8362 } }