1use crate::entity_data::{
2 ArmadilloState, BlockPos, DataValue, Direction, EntityData, EntityPose, GlobalPos, HumanoidArm,
3 ParticleData, ParticleList, ParticleOptions, Quaternionf, ResolvableProfile, Rotations,
4 SnifferState, SyncedValue, Vector3f, VillagerData,
5};
6use crate::item_stack::ItemStack;
7use crate::RegistryEntry;
8use steel_utils::BlockStateId;
9use text_components::TextComponent;
10use uuid::Uuid;
11#[doc = r" Common access to the vanilla synchronized entity data root layer."]
12pub trait VanillaEntityData {
13 #[doc = r" Returns the shared vanilla base entity-data layer."]
14 fn base(&self) -> &BaseEntityData;
15 #[doc = r" Returns the mutable shared vanilla base entity-data layer."]
16 fn base_mut(&mut self) -> &mut BaseEntityData;
17 #[doc = r" Packs dirty values for network sync, clearing dirty flags."]
18 fn pack_dirty(&mut self) -> Option<Vec<DataValue>>;
19 #[doc = r" Packs all non-default values for initial entity spawn."]
20 fn pack_all(&self) -> Vec<DataValue>;
21 #[doc = r" Returns `true` if any field has been modified."]
22 fn is_dirty(&self) -> bool;
23}
24#[doc = r" Common access to vanilla synchronized data declared by `LivingEntity`."]
25pub trait VanillaLivingEntityData: VanillaEntityData {
26 #[doc = r" Returns the vanilla living entity-data layer."]
27 fn living_entity(&self) -> &LivingEntityData;
28 #[doc = r" Returns the mutable vanilla living entity-data layer."]
29 fn living_entity_mut(&mut self) -> &mut LivingEntityData;
30}
31#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
32#[derive(Debug, Clone)]
33pub struct BaseEntityData {
34 pub shared_flags: SyncedValue<i8>,
35 pub air_supply: SyncedValue<i32>,
36 pub custom_name: SyncedValue<Option<Box<TextComponent>>>,
37 pub custom_name_visible: SyncedValue<bool>,
38 pub silent: SyncedValue<bool>,
39 pub no_gravity: SyncedValue<bool>,
40 pub pose: SyncedValue<EntityPose>,
41 pub ticks_frozen: SyncedValue<i32>,
42}
43impl BaseEntityData {
44 #[doc = r" Create new entity data with default values."]
45 pub fn new() -> Self {
46 Self {
47 shared_flags: SyncedValue::new(0i8),
48 air_supply: SyncedValue::new(300i32),
49 custom_name: SyncedValue::new(None),
50 custom_name_visible: SyncedValue::new(false),
51 silent: SyncedValue::new(false),
52 no_gravity: SyncedValue::new(false),
53 pose: SyncedValue::new(EntityPose::Standing),
54 ticks_frozen: SyncedValue::new(0i32),
55 }
56 }
57 #[doc = "Returns the `BaseEntityData` layer."]
58 pub fn base(&self) -> &BaseEntityData {
59 self
60 }
61 #[doc = "Returns the mutable `BaseEntityData` layer."]
62 pub fn base_mut(&mut self) -> &mut BaseEntityData {
63 self
64 }
65 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
66 #[doc = r" Returns `None` if no values are dirty."]
67 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
68 let mut values = Vec::new();
69 self.pack_dirty_into(&mut values);
70 if values.is_empty() {
71 None
72 } else {
73 Some(values)
74 }
75 }
76 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
77 if self.shared_flags.is_dirty() {
78 values.push(DataValue {
79 index: 0u8,
80 serializer_id: 0i32,
81 value: EntityData::Byte(*self.shared_flags.get()),
82 });
83 self.shared_flags.clear_dirty();
84 }
85 if self.air_supply.is_dirty() {
86 values.push(DataValue {
87 index: 1u8,
88 serializer_id: 1i32,
89 value: EntityData::Int(*self.air_supply.get()),
90 });
91 self.air_supply.clear_dirty();
92 }
93 if self.custom_name.is_dirty() {
94 values.push(DataValue {
95 index: 2u8,
96 serializer_id: 6i32,
97 value: EntityData::OptionalComponent(self.custom_name.get().clone()),
98 });
99 self.custom_name.clear_dirty();
100 }
101 if self.custom_name_visible.is_dirty() {
102 values.push(DataValue {
103 index: 3u8,
104 serializer_id: 8i32,
105 value: EntityData::Boolean(*self.custom_name_visible.get()),
106 });
107 self.custom_name_visible.clear_dirty();
108 }
109 if self.silent.is_dirty() {
110 values.push(DataValue {
111 index: 4u8,
112 serializer_id: 8i32,
113 value: EntityData::Boolean(*self.silent.get()),
114 });
115 self.silent.clear_dirty();
116 }
117 if self.no_gravity.is_dirty() {
118 values.push(DataValue {
119 index: 5u8,
120 serializer_id: 8i32,
121 value: EntityData::Boolean(*self.no_gravity.get()),
122 });
123 self.no_gravity.clear_dirty();
124 }
125 if self.pose.is_dirty() {
126 values.push(DataValue {
127 index: 6u8,
128 serializer_id: 20i32,
129 value: EntityData::Pose(*self.pose.get()),
130 });
131 self.pose.clear_dirty();
132 }
133 if self.ticks_frozen.is_dirty() {
134 values.push(DataValue {
135 index: 7u8,
136 serializer_id: 1i32,
137 value: EntityData::Int(*self.ticks_frozen.get()),
138 });
139 self.ticks_frozen.clear_dirty();
140 }
141 }
142 #[doc = r" Pack all non-default values (for initial entity spawn)."]
143 pub fn pack_all(&self) -> Vec<DataValue> {
144 let mut values = Vec::new();
145 self.pack_all_into(&mut values);
146 values
147 }
148 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
149 if !self.shared_flags.is_default() {
150 values.push(DataValue {
151 index: 0u8,
152 serializer_id: 0i32,
153 value: EntityData::Byte(*self.shared_flags.get()),
154 });
155 }
156 if !self.air_supply.is_default() {
157 values.push(DataValue {
158 index: 1u8,
159 serializer_id: 1i32,
160 value: EntityData::Int(*self.air_supply.get()),
161 });
162 }
163 if !self.custom_name.is_default() {
164 values.push(DataValue {
165 index: 2u8,
166 serializer_id: 6i32,
167 value: EntityData::OptionalComponent(self.custom_name.get().clone()),
168 });
169 }
170 if !self.custom_name_visible.is_default() {
171 values.push(DataValue {
172 index: 3u8,
173 serializer_id: 8i32,
174 value: EntityData::Boolean(*self.custom_name_visible.get()),
175 });
176 }
177 if !self.silent.is_default() {
178 values.push(DataValue {
179 index: 4u8,
180 serializer_id: 8i32,
181 value: EntityData::Boolean(*self.silent.get()),
182 });
183 }
184 if !self.no_gravity.is_default() {
185 values.push(DataValue {
186 index: 5u8,
187 serializer_id: 8i32,
188 value: EntityData::Boolean(*self.no_gravity.get()),
189 });
190 }
191 if !self.pose.is_default() {
192 values.push(DataValue {
193 index: 6u8,
194 serializer_id: 20i32,
195 value: EntityData::Pose(*self.pose.get()),
196 });
197 }
198 if !self.ticks_frozen.is_default() {
199 values.push(DataValue {
200 index: 7u8,
201 serializer_id: 1i32,
202 value: EntityData::Int(*self.ticks_frozen.get()),
203 });
204 }
205 }
206 #[doc = r" Returns `true` if any field has been modified."]
207 pub fn is_dirty(&self) -> bool {
208 self.shared_flags.is_dirty()
209 || self.air_supply.is_dirty()
210 || self.custom_name.is_dirty()
211 || self.custom_name_visible.is_dirty()
212 || self.silent.is_dirty()
213 || self.no_gravity.is_dirty()
214 || self.pose.is_dirty()
215 || self.ticks_frozen.is_dirty()
216 }
217}
218impl Default for BaseEntityData {
219 fn default() -> Self {
220 Self::new()
221 }
222}
223impl VanillaEntityData for BaseEntityData {
224 fn base(&self) -> &BaseEntityData {
225 BaseEntityData::base(self)
226 }
227 fn base_mut(&mut self) -> &mut BaseEntityData {
228 BaseEntityData::base_mut(self)
229 }
230 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
231 BaseEntityData::pack_dirty(self)
232 }
233 fn pack_all(&self) -> Vec<DataValue> {
234 BaseEntityData::pack_all(self)
235 }
236 fn is_dirty(&self) -> bool {
237 BaseEntityData::is_dirty(self)
238 }
239}
240#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
241#[derive(Debug, Clone)]
242pub struct VehicleEntityData {
243 pub base: BaseEntityData,
244 pub id_hurt: SyncedValue<i32>,
245 pub id_hurtdir: SyncedValue<i32>,
246 pub id_damage: SyncedValue<f32>,
247}
248impl VehicleEntityData {
249 #[doc = r" Create new entity data with default values."]
250 pub fn new() -> Self {
251 Self {
252 base: BaseEntityData::new(),
253 id_hurt: SyncedValue::new(0i32),
254 id_hurtdir: SyncedValue::new(1i32),
255 id_damage: SyncedValue::new(0f32),
256 }
257 }
258 #[doc = "Returns the `VehicleEntityData` layer."]
259 pub fn vehicle_entity(&self) -> &VehicleEntityData {
260 self
261 }
262 #[doc = "Returns the mutable `VehicleEntityData` layer."]
263 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
264 self
265 }
266 #[doc = "Returns the `BaseEntityData` layer."]
267 pub fn base(&self) -> &BaseEntityData {
268 &self.base
269 }
270 #[doc = "Returns the mutable `BaseEntityData` layer."]
271 pub fn base_mut(&mut self) -> &mut BaseEntityData {
272 &mut self.base
273 }
274 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
275 #[doc = r" Returns `None` if no values are dirty."]
276 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
277 let mut values = Vec::new();
278 self.pack_dirty_into(&mut values);
279 if values.is_empty() {
280 None
281 } else {
282 Some(values)
283 }
284 }
285 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
286 self.base.pack_dirty_into(values);
287 if self.id_hurt.is_dirty() {
288 values.push(DataValue {
289 index: 8u8,
290 serializer_id: 1i32,
291 value: EntityData::Int(*self.id_hurt.get()),
292 });
293 self.id_hurt.clear_dirty();
294 }
295 if self.id_hurtdir.is_dirty() {
296 values.push(DataValue {
297 index: 9u8,
298 serializer_id: 1i32,
299 value: EntityData::Int(*self.id_hurtdir.get()),
300 });
301 self.id_hurtdir.clear_dirty();
302 }
303 if self.id_damage.is_dirty() {
304 values.push(DataValue {
305 index: 10u8,
306 serializer_id: 3i32,
307 value: EntityData::Float(*self.id_damage.get()),
308 });
309 self.id_damage.clear_dirty();
310 }
311 }
312 #[doc = r" Pack all non-default values (for initial entity spawn)."]
313 pub fn pack_all(&self) -> Vec<DataValue> {
314 let mut values = Vec::new();
315 self.pack_all_into(&mut values);
316 values
317 }
318 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
319 self.base.pack_all_into(values);
320 if !self.id_hurt.is_default() {
321 values.push(DataValue {
322 index: 8u8,
323 serializer_id: 1i32,
324 value: EntityData::Int(*self.id_hurt.get()),
325 });
326 }
327 if !self.id_hurtdir.is_default() {
328 values.push(DataValue {
329 index: 9u8,
330 serializer_id: 1i32,
331 value: EntityData::Int(*self.id_hurtdir.get()),
332 });
333 }
334 if !self.id_damage.is_default() {
335 values.push(DataValue {
336 index: 10u8,
337 serializer_id: 3i32,
338 value: EntityData::Float(*self.id_damage.get()),
339 });
340 }
341 }
342 #[doc = r" Returns `true` if any field has been modified."]
343 pub fn is_dirty(&self) -> bool {
344 self.base.is_dirty()
345 || self.id_hurt.is_dirty()
346 || self.id_hurtdir.is_dirty()
347 || self.id_damage.is_dirty()
348 }
349}
350impl Default for VehicleEntityData {
351 fn default() -> Self {
352 Self::new()
353 }
354}
355impl VanillaEntityData for VehicleEntityData {
356 fn base(&self) -> &BaseEntityData {
357 VehicleEntityData::base(self)
358 }
359 fn base_mut(&mut self) -> &mut BaseEntityData {
360 VehicleEntityData::base_mut(self)
361 }
362 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
363 VehicleEntityData::pack_dirty(self)
364 }
365 fn pack_all(&self) -> Vec<DataValue> {
366 VehicleEntityData::pack_all(self)
367 }
368 fn is_dirty(&self) -> bool {
369 VehicleEntityData::is_dirty(self)
370 }
371}
372#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
373#[derive(Debug, Clone)]
374pub struct AbstractBoatEntityData {
375 pub vehicle_entity: VehicleEntityData,
376 pub id_paddle_left: SyncedValue<bool>,
377 pub id_paddle_right: SyncedValue<bool>,
378 pub id_bubble_time: SyncedValue<i32>,
379}
380impl AbstractBoatEntityData {
381 #[doc = r" Create new entity data with default values."]
382 pub fn new() -> Self {
383 Self {
384 vehicle_entity: VehicleEntityData::new(),
385 id_paddle_left: SyncedValue::new(false),
386 id_paddle_right: SyncedValue::new(false),
387 id_bubble_time: SyncedValue::new(0i32),
388 }
389 }
390 #[doc = "Returns the `AbstractBoatEntityData` layer."]
391 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
392 self
393 }
394 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
395 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
396 self
397 }
398 #[doc = "Returns the `VehicleEntityData` layer."]
399 pub fn vehicle_entity(&self) -> &VehicleEntityData {
400 &self.vehicle_entity
401 }
402 #[doc = "Returns the mutable `VehicleEntityData` layer."]
403 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
404 &mut self.vehicle_entity
405 }
406 #[doc = "Returns the `BaseEntityData` layer."]
407 pub fn base(&self) -> &BaseEntityData {
408 &self.vehicle_entity.base
409 }
410 #[doc = "Returns the mutable `BaseEntityData` layer."]
411 pub fn base_mut(&mut self) -> &mut BaseEntityData {
412 &mut self.vehicle_entity.base
413 }
414 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
415 #[doc = r" Returns `None` if no values are dirty."]
416 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
417 let mut values = Vec::new();
418 self.pack_dirty_into(&mut values);
419 if values.is_empty() {
420 None
421 } else {
422 Some(values)
423 }
424 }
425 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
426 self.vehicle_entity.pack_dirty_into(values);
427 if self.id_paddle_left.is_dirty() {
428 values.push(DataValue {
429 index: 11u8,
430 serializer_id: 8i32,
431 value: EntityData::Boolean(*self.id_paddle_left.get()),
432 });
433 self.id_paddle_left.clear_dirty();
434 }
435 if self.id_paddle_right.is_dirty() {
436 values.push(DataValue {
437 index: 12u8,
438 serializer_id: 8i32,
439 value: EntityData::Boolean(*self.id_paddle_right.get()),
440 });
441 self.id_paddle_right.clear_dirty();
442 }
443 if self.id_bubble_time.is_dirty() {
444 values.push(DataValue {
445 index: 13u8,
446 serializer_id: 1i32,
447 value: EntityData::Int(*self.id_bubble_time.get()),
448 });
449 self.id_bubble_time.clear_dirty();
450 }
451 }
452 #[doc = r" Pack all non-default values (for initial entity spawn)."]
453 pub fn pack_all(&self) -> Vec<DataValue> {
454 let mut values = Vec::new();
455 self.pack_all_into(&mut values);
456 values
457 }
458 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
459 self.vehicle_entity.pack_all_into(values);
460 if !self.id_paddle_left.is_default() {
461 values.push(DataValue {
462 index: 11u8,
463 serializer_id: 8i32,
464 value: EntityData::Boolean(*self.id_paddle_left.get()),
465 });
466 }
467 if !self.id_paddle_right.is_default() {
468 values.push(DataValue {
469 index: 12u8,
470 serializer_id: 8i32,
471 value: EntityData::Boolean(*self.id_paddle_right.get()),
472 });
473 }
474 if !self.id_bubble_time.is_default() {
475 values.push(DataValue {
476 index: 13u8,
477 serializer_id: 1i32,
478 value: EntityData::Int(*self.id_bubble_time.get()),
479 });
480 }
481 }
482 #[doc = r" Returns `true` if any field has been modified."]
483 pub fn is_dirty(&self) -> bool {
484 self.vehicle_entity.is_dirty()
485 || self.id_paddle_left.is_dirty()
486 || self.id_paddle_right.is_dirty()
487 || self.id_bubble_time.is_dirty()
488 }
489}
490impl Default for AbstractBoatEntityData {
491 fn default() -> Self {
492 Self::new()
493 }
494}
495impl VanillaEntityData for AbstractBoatEntityData {
496 fn base(&self) -> &BaseEntityData {
497 AbstractBoatEntityData::base(self)
498 }
499 fn base_mut(&mut self) -> &mut BaseEntityData {
500 AbstractBoatEntityData::base_mut(self)
501 }
502 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
503 AbstractBoatEntityData::pack_dirty(self)
504 }
505 fn pack_all(&self) -> Vec<DataValue> {
506 AbstractBoatEntityData::pack_all(self)
507 }
508 fn is_dirty(&self) -> bool {
509 AbstractBoatEntityData::is_dirty(self)
510 }
511}
512#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
513#[derive(Debug, Clone)]
514pub struct LivingEntityData {
515 pub base: BaseEntityData,
516 pub living_entity_flags: SyncedValue<i8>,
517 pub health: SyncedValue<f32>,
518 pub effect_particles: SyncedValue<ParticleList>,
519 pub effect_ambience: SyncedValue<bool>,
520 pub arrow_count: SyncedValue<i32>,
521 pub stinger_count: SyncedValue<i32>,
522 pub sleeping_pos: SyncedValue<Option<BlockPos>>,
523}
524impl LivingEntityData {
525 #[doc = r" Create new entity data with default values."]
526 pub fn new() -> Self {
527 Self {
528 base: BaseEntityData::new(),
529 living_entity_flags: SyncedValue::new(0i8),
530 health: SyncedValue::new(1f32),
531 effect_particles: SyncedValue::new(ParticleList::default()),
532 effect_ambience: SyncedValue::new(false),
533 arrow_count: SyncedValue::new(0i32),
534 stinger_count: SyncedValue::new(0i32),
535 sleeping_pos: SyncedValue::new(None),
536 }
537 }
538 #[doc = "Returns the `LivingEntityData` layer."]
539 pub fn living_entity(&self) -> &LivingEntityData {
540 self
541 }
542 #[doc = "Returns the mutable `LivingEntityData` layer."]
543 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
544 self
545 }
546 #[doc = "Returns the `BaseEntityData` layer."]
547 pub fn base(&self) -> &BaseEntityData {
548 &self.base
549 }
550 #[doc = "Returns the mutable `BaseEntityData` layer."]
551 pub fn base_mut(&mut self) -> &mut BaseEntityData {
552 &mut self.base
553 }
554 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
555 #[doc = r" Returns `None` if no values are dirty."]
556 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
557 let mut values = Vec::new();
558 self.pack_dirty_into(&mut values);
559 if values.is_empty() {
560 None
561 } else {
562 Some(values)
563 }
564 }
565 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
566 self.base.pack_dirty_into(values);
567 if self.living_entity_flags.is_dirty() {
568 values.push(DataValue {
569 index: 8u8,
570 serializer_id: 0i32,
571 value: EntityData::Byte(*self.living_entity_flags.get()),
572 });
573 self.living_entity_flags.clear_dirty();
574 }
575 if self.health.is_dirty() {
576 values.push(DataValue {
577 index: 9u8,
578 serializer_id: 3i32,
579 value: EntityData::Float(*self.health.get()),
580 });
581 self.health.clear_dirty();
582 }
583 if self.effect_particles.is_dirty() {
584 values.push(DataValue {
585 index: 10u8,
586 serializer_id: 17i32,
587 value: EntityData::Particles(self.effect_particles.get().clone()),
588 });
589 self.effect_particles.clear_dirty();
590 }
591 if self.effect_ambience.is_dirty() {
592 values.push(DataValue {
593 index: 11u8,
594 serializer_id: 8i32,
595 value: EntityData::Boolean(*self.effect_ambience.get()),
596 });
597 self.effect_ambience.clear_dirty();
598 }
599 if self.arrow_count.is_dirty() {
600 values.push(DataValue {
601 index: 12u8,
602 serializer_id: 1i32,
603 value: EntityData::Int(*self.arrow_count.get()),
604 });
605 self.arrow_count.clear_dirty();
606 }
607 if self.stinger_count.is_dirty() {
608 values.push(DataValue {
609 index: 13u8,
610 serializer_id: 1i32,
611 value: EntityData::Int(*self.stinger_count.get()),
612 });
613 self.stinger_count.clear_dirty();
614 }
615 if self.sleeping_pos.is_dirty() {
616 values.push(DataValue {
617 index: 14u8,
618 serializer_id: 11i32,
619 value: EntityData::OptionalBlockPos(self.sleeping_pos.get().clone()),
620 });
621 self.sleeping_pos.clear_dirty();
622 }
623 }
624 #[doc = r" Pack all non-default values (for initial entity spawn)."]
625 pub fn pack_all(&self) -> Vec<DataValue> {
626 let mut values = Vec::new();
627 self.pack_all_into(&mut values);
628 values
629 }
630 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
631 self.base.pack_all_into(values);
632 if !self.living_entity_flags.is_default() {
633 values.push(DataValue {
634 index: 8u8,
635 serializer_id: 0i32,
636 value: EntityData::Byte(*self.living_entity_flags.get()),
637 });
638 }
639 if !self.health.is_default() {
640 values.push(DataValue {
641 index: 9u8,
642 serializer_id: 3i32,
643 value: EntityData::Float(*self.health.get()),
644 });
645 }
646 if !self.effect_particles.is_default() {
647 values.push(DataValue {
648 index: 10u8,
649 serializer_id: 17i32,
650 value: EntityData::Particles(self.effect_particles.get().clone()),
651 });
652 }
653 if !self.effect_ambience.is_default() {
654 values.push(DataValue {
655 index: 11u8,
656 serializer_id: 8i32,
657 value: EntityData::Boolean(*self.effect_ambience.get()),
658 });
659 }
660 if !self.arrow_count.is_default() {
661 values.push(DataValue {
662 index: 12u8,
663 serializer_id: 1i32,
664 value: EntityData::Int(*self.arrow_count.get()),
665 });
666 }
667 if !self.stinger_count.is_default() {
668 values.push(DataValue {
669 index: 13u8,
670 serializer_id: 1i32,
671 value: EntityData::Int(*self.stinger_count.get()),
672 });
673 }
674 if !self.sleeping_pos.is_default() {
675 values.push(DataValue {
676 index: 14u8,
677 serializer_id: 11i32,
678 value: EntityData::OptionalBlockPos(self.sleeping_pos.get().clone()),
679 });
680 }
681 }
682 #[doc = r" Returns `true` if any field has been modified."]
683 pub fn is_dirty(&self) -> bool {
684 self.base.is_dirty()
685 || self.living_entity_flags.is_dirty()
686 || self.health.is_dirty()
687 || self.effect_particles.is_dirty()
688 || self.effect_ambience.is_dirty()
689 || self.arrow_count.is_dirty()
690 || self.stinger_count.is_dirty()
691 || self.sleeping_pos.is_dirty()
692 }
693}
694impl Default for LivingEntityData {
695 fn default() -> Self {
696 Self::new()
697 }
698}
699impl VanillaEntityData for LivingEntityData {
700 fn base(&self) -> &BaseEntityData {
701 LivingEntityData::base(self)
702 }
703 fn base_mut(&mut self) -> &mut BaseEntityData {
704 LivingEntityData::base_mut(self)
705 }
706 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
707 LivingEntityData::pack_dirty(self)
708 }
709 fn pack_all(&self) -> Vec<DataValue> {
710 LivingEntityData::pack_all(self)
711 }
712 fn is_dirty(&self) -> bool {
713 LivingEntityData::is_dirty(self)
714 }
715}
716impl VanillaLivingEntityData for LivingEntityData {
717 fn living_entity(&self) -> &LivingEntityData {
718 LivingEntityData::living_entity(self)
719 }
720 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
721 LivingEntityData::living_entity_mut(self)
722 }
723}
724#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
725#[derive(Debug, Clone)]
726pub struct MobEntityData {
727 pub living_entity: LivingEntityData,
728 pub mob_flags: SyncedValue<i8>,
729}
730impl MobEntityData {
731 #[doc = r" Create new entity data with default values."]
732 pub fn new() -> Self {
733 Self {
734 living_entity: LivingEntityData::new(),
735 mob_flags: SyncedValue::new(0i8),
736 }
737 }
738 #[doc = "Returns the `MobEntityData` layer."]
739 pub fn mob(&self) -> &MobEntityData {
740 self
741 }
742 #[doc = "Returns the mutable `MobEntityData` layer."]
743 pub fn mob_mut(&mut self) -> &mut MobEntityData {
744 self
745 }
746 #[doc = "Returns the `LivingEntityData` layer."]
747 pub fn living_entity(&self) -> &LivingEntityData {
748 &self.living_entity
749 }
750 #[doc = "Returns the mutable `LivingEntityData` layer."]
751 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
752 &mut self.living_entity
753 }
754 #[doc = "Returns the `BaseEntityData` layer."]
755 pub fn base(&self) -> &BaseEntityData {
756 &self.living_entity.base
757 }
758 #[doc = "Returns the mutable `BaseEntityData` layer."]
759 pub fn base_mut(&mut self) -> &mut BaseEntityData {
760 &mut self.living_entity.base
761 }
762 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
763 #[doc = r" Returns `None` if no values are dirty."]
764 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
765 let mut values = Vec::new();
766 self.pack_dirty_into(&mut values);
767 if values.is_empty() {
768 None
769 } else {
770 Some(values)
771 }
772 }
773 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
774 self.living_entity.pack_dirty_into(values);
775 if self.mob_flags.is_dirty() {
776 values.push(DataValue {
777 index: 15u8,
778 serializer_id: 0i32,
779 value: EntityData::Byte(*self.mob_flags.get()),
780 });
781 self.mob_flags.clear_dirty();
782 }
783 }
784 #[doc = r" Pack all non-default values (for initial entity spawn)."]
785 pub fn pack_all(&self) -> Vec<DataValue> {
786 let mut values = Vec::new();
787 self.pack_all_into(&mut values);
788 values
789 }
790 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
791 self.living_entity.pack_all_into(values);
792 if !self.mob_flags.is_default() {
793 values.push(DataValue {
794 index: 15u8,
795 serializer_id: 0i32,
796 value: EntityData::Byte(*self.mob_flags.get()),
797 });
798 }
799 }
800 #[doc = r" Returns `true` if any field has been modified."]
801 pub fn is_dirty(&self) -> bool {
802 self.living_entity.is_dirty() || self.mob_flags.is_dirty()
803 }
804}
805impl Default for MobEntityData {
806 fn default() -> Self {
807 Self::new()
808 }
809}
810impl VanillaEntityData for MobEntityData {
811 fn base(&self) -> &BaseEntityData {
812 MobEntityData::base(self)
813 }
814 fn base_mut(&mut self) -> &mut BaseEntityData {
815 MobEntityData::base_mut(self)
816 }
817 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
818 MobEntityData::pack_dirty(self)
819 }
820 fn pack_all(&self) -> Vec<DataValue> {
821 MobEntityData::pack_all(self)
822 }
823 fn is_dirty(&self) -> bool {
824 MobEntityData::is_dirty(self)
825 }
826}
827impl VanillaLivingEntityData for MobEntityData {
828 fn living_entity(&self) -> &LivingEntityData {
829 MobEntityData::living_entity(self)
830 }
831 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
832 MobEntityData::living_entity_mut(self)
833 }
834}
835#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
836#[derive(Debug, Clone)]
837pub struct AllayEntityData {
838 pub mob: MobEntityData,
839 pub dancing: SyncedValue<bool>,
840 pub can_duplicate: SyncedValue<bool>,
841}
842impl AllayEntityData {
843 #[doc = r" Create new entity data with default values."]
844 pub fn new() -> Self {
845 Self {
846 mob: MobEntityData::new(),
847 dancing: SyncedValue::new(false),
848 can_duplicate: SyncedValue::new(true),
849 }
850 }
851 #[doc = "Returns the `AllayEntityData` layer."]
852 pub fn allay(&self) -> &AllayEntityData {
853 self
854 }
855 #[doc = "Returns the mutable `AllayEntityData` layer."]
856 pub fn allay_mut(&mut self) -> &mut AllayEntityData {
857 self
858 }
859 #[doc = "Returns the `MobEntityData` layer."]
860 pub fn mob(&self) -> &MobEntityData {
861 &self.mob
862 }
863 #[doc = "Returns the mutable `MobEntityData` layer."]
864 pub fn mob_mut(&mut self) -> &mut MobEntityData {
865 &mut self.mob
866 }
867 #[doc = "Returns the `LivingEntityData` layer."]
868 pub fn living_entity(&self) -> &LivingEntityData {
869 &self.mob.living_entity
870 }
871 #[doc = "Returns the mutable `LivingEntityData` layer."]
872 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
873 &mut self.mob.living_entity
874 }
875 #[doc = "Returns the `BaseEntityData` layer."]
876 pub fn base(&self) -> &BaseEntityData {
877 &self.mob.living_entity.base
878 }
879 #[doc = "Returns the mutable `BaseEntityData` layer."]
880 pub fn base_mut(&mut self) -> &mut BaseEntityData {
881 &mut self.mob.living_entity.base
882 }
883 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
884 #[doc = r" Returns `None` if no values are dirty."]
885 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
886 let mut values = Vec::new();
887 self.pack_dirty_into(&mut values);
888 if values.is_empty() {
889 None
890 } else {
891 Some(values)
892 }
893 }
894 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
895 self.mob.pack_dirty_into(values);
896 if self.dancing.is_dirty() {
897 values.push(DataValue {
898 index: 16u8,
899 serializer_id: 8i32,
900 value: EntityData::Boolean(*self.dancing.get()),
901 });
902 self.dancing.clear_dirty();
903 }
904 if self.can_duplicate.is_dirty() {
905 values.push(DataValue {
906 index: 17u8,
907 serializer_id: 8i32,
908 value: EntityData::Boolean(*self.can_duplicate.get()),
909 });
910 self.can_duplicate.clear_dirty();
911 }
912 }
913 #[doc = r" Pack all non-default values (for initial entity spawn)."]
914 pub fn pack_all(&self) -> Vec<DataValue> {
915 let mut values = Vec::new();
916 self.pack_all_into(&mut values);
917 values
918 }
919 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
920 self.mob.pack_all_into(values);
921 if !self.dancing.is_default() {
922 values.push(DataValue {
923 index: 16u8,
924 serializer_id: 8i32,
925 value: EntityData::Boolean(*self.dancing.get()),
926 });
927 }
928 if !self.can_duplicate.is_default() {
929 values.push(DataValue {
930 index: 17u8,
931 serializer_id: 8i32,
932 value: EntityData::Boolean(*self.can_duplicate.get()),
933 });
934 }
935 }
936 #[doc = r" Returns `true` if any field has been modified."]
937 pub fn is_dirty(&self) -> bool {
938 self.mob.is_dirty() || self.dancing.is_dirty() || self.can_duplicate.is_dirty()
939 }
940}
941impl Default for AllayEntityData {
942 fn default() -> Self {
943 Self::new()
944 }
945}
946impl VanillaEntityData for AllayEntityData {
947 fn base(&self) -> &BaseEntityData {
948 AllayEntityData::base(self)
949 }
950 fn base_mut(&mut self) -> &mut BaseEntityData {
951 AllayEntityData::base_mut(self)
952 }
953 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
954 AllayEntityData::pack_dirty(self)
955 }
956 fn pack_all(&self) -> Vec<DataValue> {
957 AllayEntityData::pack_all(self)
958 }
959 fn is_dirty(&self) -> bool {
960 AllayEntityData::is_dirty(self)
961 }
962}
963impl VanillaLivingEntityData for AllayEntityData {
964 fn living_entity(&self) -> &LivingEntityData {
965 AllayEntityData::living_entity(self)
966 }
967 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
968 AllayEntityData::living_entity_mut(self)
969 }
970}
971#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
972#[derive(Debug, Clone)]
973pub struct AreaEffectCloudEntityData {
974 pub base: BaseEntityData,
975 pub radius: SyncedValue<f32>,
976 pub waiting: SyncedValue<bool>,
977 pub particle: SyncedValue<ParticleData>,
978}
979impl AreaEffectCloudEntityData {
980 #[doc = r" Create new entity data with default values."]
981 pub fn new() -> Self {
982 Self {
983 base: BaseEntityData::new(),
984 radius: SyncedValue::new(3f32),
985 waiting: SyncedValue::new(false),
986 particle: SyncedValue::new(ParticleData::new(
987 21,
988 ParticleOptions::Color { color: -1i32 },
989 )),
990 }
991 }
992 #[doc = "Returns the `AreaEffectCloudEntityData` layer."]
993 pub fn area_effect_cloud(&self) -> &AreaEffectCloudEntityData {
994 self
995 }
996 #[doc = "Returns the mutable `AreaEffectCloudEntityData` layer."]
997 pub fn area_effect_cloud_mut(&mut self) -> &mut AreaEffectCloudEntityData {
998 self
999 }
1000 #[doc = "Returns the `BaseEntityData` layer."]
1001 pub fn base(&self) -> &BaseEntityData {
1002 &self.base
1003 }
1004 #[doc = "Returns the mutable `BaseEntityData` layer."]
1005 pub fn base_mut(&mut self) -> &mut BaseEntityData {
1006 &mut self.base
1007 }
1008 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
1009 #[doc = r" Returns `None` if no values are dirty."]
1010 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1011 let mut values = Vec::new();
1012 self.pack_dirty_into(&mut values);
1013 if values.is_empty() {
1014 None
1015 } else {
1016 Some(values)
1017 }
1018 }
1019 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
1020 self.base.pack_dirty_into(values);
1021 if self.radius.is_dirty() {
1022 values.push(DataValue {
1023 index: 8u8,
1024 serializer_id: 3i32,
1025 value: EntityData::Float(*self.radius.get()),
1026 });
1027 self.radius.clear_dirty();
1028 }
1029 if self.waiting.is_dirty() {
1030 values.push(DataValue {
1031 index: 9u8,
1032 serializer_id: 8i32,
1033 value: EntityData::Boolean(*self.waiting.get()),
1034 });
1035 self.waiting.clear_dirty();
1036 }
1037 if self.particle.is_dirty() {
1038 values.push(DataValue {
1039 index: 10u8,
1040 serializer_id: 16i32,
1041 value: EntityData::Particle(self.particle.get().clone()),
1042 });
1043 self.particle.clear_dirty();
1044 }
1045 }
1046 #[doc = r" Pack all non-default values (for initial entity spawn)."]
1047 pub fn pack_all(&self) -> Vec<DataValue> {
1048 let mut values = Vec::new();
1049 self.pack_all_into(&mut values);
1050 values
1051 }
1052 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
1053 self.base.pack_all_into(values);
1054 if !self.radius.is_default() {
1055 values.push(DataValue {
1056 index: 8u8,
1057 serializer_id: 3i32,
1058 value: EntityData::Float(*self.radius.get()),
1059 });
1060 }
1061 if !self.waiting.is_default() {
1062 values.push(DataValue {
1063 index: 9u8,
1064 serializer_id: 8i32,
1065 value: EntityData::Boolean(*self.waiting.get()),
1066 });
1067 }
1068 if !self.particle.is_default() {
1069 values.push(DataValue {
1070 index: 10u8,
1071 serializer_id: 16i32,
1072 value: EntityData::Particle(self.particle.get().clone()),
1073 });
1074 }
1075 }
1076 #[doc = r" Returns `true` if any field has been modified."]
1077 pub fn is_dirty(&self) -> bool {
1078 self.base.is_dirty()
1079 || self.radius.is_dirty()
1080 || self.waiting.is_dirty()
1081 || self.particle.is_dirty()
1082 }
1083}
1084impl Default for AreaEffectCloudEntityData {
1085 fn default() -> Self {
1086 Self::new()
1087 }
1088}
1089impl VanillaEntityData for AreaEffectCloudEntityData {
1090 fn base(&self) -> &BaseEntityData {
1091 AreaEffectCloudEntityData::base(self)
1092 }
1093 fn base_mut(&mut self) -> &mut BaseEntityData {
1094 AreaEffectCloudEntityData::base_mut(self)
1095 }
1096 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1097 AreaEffectCloudEntityData::pack_dirty(self)
1098 }
1099 fn pack_all(&self) -> Vec<DataValue> {
1100 AreaEffectCloudEntityData::pack_all(self)
1101 }
1102 fn is_dirty(&self) -> bool {
1103 AreaEffectCloudEntityData::is_dirty(self)
1104 }
1105}
1106#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
1107#[derive(Debug, Clone)]
1108pub struct AgeableMobEntityData {
1109 pub mob: MobEntityData,
1110 pub baby: SyncedValue<bool>,
1111 pub age_locked: SyncedValue<bool>,
1112}
1113impl AgeableMobEntityData {
1114 #[doc = r" Create new entity data with default values."]
1115 pub fn new() -> Self {
1116 Self {
1117 mob: MobEntityData::new(),
1118 baby: SyncedValue::new(false),
1119 age_locked: SyncedValue::new(false),
1120 }
1121 }
1122 #[doc = "Returns the `AgeableMobEntityData` layer."]
1123 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
1124 self
1125 }
1126 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
1127 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
1128 self
1129 }
1130 #[doc = "Returns the `MobEntityData` layer."]
1131 pub fn mob(&self) -> &MobEntityData {
1132 &self.mob
1133 }
1134 #[doc = "Returns the mutable `MobEntityData` layer."]
1135 pub fn mob_mut(&mut self) -> &mut MobEntityData {
1136 &mut self.mob
1137 }
1138 #[doc = "Returns the `LivingEntityData` layer."]
1139 pub fn living_entity(&self) -> &LivingEntityData {
1140 &self.mob.living_entity
1141 }
1142 #[doc = "Returns the mutable `LivingEntityData` layer."]
1143 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
1144 &mut self.mob.living_entity
1145 }
1146 #[doc = "Returns the `BaseEntityData` layer."]
1147 pub fn base(&self) -> &BaseEntityData {
1148 &self.mob.living_entity.base
1149 }
1150 #[doc = "Returns the mutable `BaseEntityData` layer."]
1151 pub fn base_mut(&mut self) -> &mut BaseEntityData {
1152 &mut self.mob.living_entity.base
1153 }
1154 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
1155 #[doc = r" Returns `None` if no values are dirty."]
1156 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1157 let mut values = Vec::new();
1158 self.pack_dirty_into(&mut values);
1159 if values.is_empty() {
1160 None
1161 } else {
1162 Some(values)
1163 }
1164 }
1165 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
1166 self.mob.pack_dirty_into(values);
1167 if self.baby.is_dirty() {
1168 values.push(DataValue {
1169 index: 16u8,
1170 serializer_id: 8i32,
1171 value: EntityData::Boolean(*self.baby.get()),
1172 });
1173 self.baby.clear_dirty();
1174 }
1175 if self.age_locked.is_dirty() {
1176 values.push(DataValue {
1177 index: 17u8,
1178 serializer_id: 8i32,
1179 value: EntityData::Boolean(*self.age_locked.get()),
1180 });
1181 self.age_locked.clear_dirty();
1182 }
1183 }
1184 #[doc = r" Pack all non-default values (for initial entity spawn)."]
1185 pub fn pack_all(&self) -> Vec<DataValue> {
1186 let mut values = Vec::new();
1187 self.pack_all_into(&mut values);
1188 values
1189 }
1190 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
1191 self.mob.pack_all_into(values);
1192 if !self.baby.is_default() {
1193 values.push(DataValue {
1194 index: 16u8,
1195 serializer_id: 8i32,
1196 value: EntityData::Boolean(*self.baby.get()),
1197 });
1198 }
1199 if !self.age_locked.is_default() {
1200 values.push(DataValue {
1201 index: 17u8,
1202 serializer_id: 8i32,
1203 value: EntityData::Boolean(*self.age_locked.get()),
1204 });
1205 }
1206 }
1207 #[doc = r" Returns `true` if any field has been modified."]
1208 pub fn is_dirty(&self) -> bool {
1209 self.mob.is_dirty() || self.baby.is_dirty() || self.age_locked.is_dirty()
1210 }
1211}
1212impl Default for AgeableMobEntityData {
1213 fn default() -> Self {
1214 Self::new()
1215 }
1216}
1217impl VanillaEntityData for AgeableMobEntityData {
1218 fn base(&self) -> &BaseEntityData {
1219 AgeableMobEntityData::base(self)
1220 }
1221 fn base_mut(&mut self) -> &mut BaseEntityData {
1222 AgeableMobEntityData::base_mut(self)
1223 }
1224 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1225 AgeableMobEntityData::pack_dirty(self)
1226 }
1227 fn pack_all(&self) -> Vec<DataValue> {
1228 AgeableMobEntityData::pack_all(self)
1229 }
1230 fn is_dirty(&self) -> bool {
1231 AgeableMobEntityData::is_dirty(self)
1232 }
1233}
1234impl VanillaLivingEntityData for AgeableMobEntityData {
1235 fn living_entity(&self) -> &LivingEntityData {
1236 AgeableMobEntityData::living_entity(self)
1237 }
1238 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
1239 AgeableMobEntityData::living_entity_mut(self)
1240 }
1241}
1242#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
1243#[derive(Debug, Clone)]
1244pub struct ArmadilloEntityData {
1245 pub ageable_mob: AgeableMobEntityData,
1246 pub armadillo_state: SyncedValue<ArmadilloState>,
1247}
1248impl ArmadilloEntityData {
1249 #[doc = r" Create new entity data with default values."]
1250 pub fn new() -> Self {
1251 Self {
1252 ageable_mob: AgeableMobEntityData::new(),
1253 armadillo_state: SyncedValue::new(ArmadilloState::Idle),
1254 }
1255 }
1256 #[doc = "Returns the `ArmadilloEntityData` layer."]
1257 pub fn armadillo(&self) -> &ArmadilloEntityData {
1258 self
1259 }
1260 #[doc = "Returns the mutable `ArmadilloEntityData` layer."]
1261 pub fn armadillo_mut(&mut self) -> &mut ArmadilloEntityData {
1262 self
1263 }
1264 #[doc = "Returns the `AgeableMobEntityData` layer."]
1265 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
1266 &self.ageable_mob
1267 }
1268 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
1269 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
1270 &mut self.ageable_mob
1271 }
1272 #[doc = "Returns the `MobEntityData` layer."]
1273 pub fn mob(&self) -> &MobEntityData {
1274 &self.ageable_mob.mob
1275 }
1276 #[doc = "Returns the mutable `MobEntityData` layer."]
1277 pub fn mob_mut(&mut self) -> &mut MobEntityData {
1278 &mut self.ageable_mob.mob
1279 }
1280 #[doc = "Returns the `LivingEntityData` layer."]
1281 pub fn living_entity(&self) -> &LivingEntityData {
1282 &self.ageable_mob.mob.living_entity
1283 }
1284 #[doc = "Returns the mutable `LivingEntityData` layer."]
1285 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
1286 &mut self.ageable_mob.mob.living_entity
1287 }
1288 #[doc = "Returns the `BaseEntityData` layer."]
1289 pub fn base(&self) -> &BaseEntityData {
1290 &self.ageable_mob.mob.living_entity.base
1291 }
1292 #[doc = "Returns the mutable `BaseEntityData` layer."]
1293 pub fn base_mut(&mut self) -> &mut BaseEntityData {
1294 &mut self.ageable_mob.mob.living_entity.base
1295 }
1296 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
1297 #[doc = r" Returns `None` if no values are dirty."]
1298 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1299 let mut values = Vec::new();
1300 self.pack_dirty_into(&mut values);
1301 if values.is_empty() {
1302 None
1303 } else {
1304 Some(values)
1305 }
1306 }
1307 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
1308 self.ageable_mob.pack_dirty_into(values);
1309 if self.armadillo_state.is_dirty() {
1310 values.push(DataValue {
1311 index: 18u8,
1312 serializer_id: 36i32,
1313 value: EntityData::ArmadilloState(*self.armadillo_state.get()),
1314 });
1315 self.armadillo_state.clear_dirty();
1316 }
1317 }
1318 #[doc = r" Pack all non-default values (for initial entity spawn)."]
1319 pub fn pack_all(&self) -> Vec<DataValue> {
1320 let mut values = Vec::new();
1321 self.pack_all_into(&mut values);
1322 values
1323 }
1324 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
1325 self.ageable_mob.pack_all_into(values);
1326 if !self.armadillo_state.is_default() {
1327 values.push(DataValue {
1328 index: 18u8,
1329 serializer_id: 36i32,
1330 value: EntityData::ArmadilloState(*self.armadillo_state.get()),
1331 });
1332 }
1333 }
1334 #[doc = r" Returns `true` if any field has been modified."]
1335 pub fn is_dirty(&self) -> bool {
1336 self.ageable_mob.is_dirty() || self.armadillo_state.is_dirty()
1337 }
1338}
1339impl Default for ArmadilloEntityData {
1340 fn default() -> Self {
1341 Self::new()
1342 }
1343}
1344impl VanillaEntityData for ArmadilloEntityData {
1345 fn base(&self) -> &BaseEntityData {
1346 ArmadilloEntityData::base(self)
1347 }
1348 fn base_mut(&mut self) -> &mut BaseEntityData {
1349 ArmadilloEntityData::base_mut(self)
1350 }
1351 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1352 ArmadilloEntityData::pack_dirty(self)
1353 }
1354 fn pack_all(&self) -> Vec<DataValue> {
1355 ArmadilloEntityData::pack_all(self)
1356 }
1357 fn is_dirty(&self) -> bool {
1358 ArmadilloEntityData::is_dirty(self)
1359 }
1360}
1361impl VanillaLivingEntityData for ArmadilloEntityData {
1362 fn living_entity(&self) -> &LivingEntityData {
1363 ArmadilloEntityData::living_entity(self)
1364 }
1365 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
1366 ArmadilloEntityData::living_entity_mut(self)
1367 }
1368}
1369#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
1370#[derive(Debug, Clone)]
1371pub struct ArmorStandEntityData {
1372 pub living_entity: LivingEntityData,
1373 pub client_flags: SyncedValue<i8>,
1374 pub head_pose: SyncedValue<Rotations>,
1375 pub body_pose: SyncedValue<Rotations>,
1376 pub left_arm_pose: SyncedValue<Rotations>,
1377 pub right_arm_pose: SyncedValue<Rotations>,
1378 pub left_leg_pose: SyncedValue<Rotations>,
1379 pub right_leg_pose: SyncedValue<Rotations>,
1380}
1381impl ArmorStandEntityData {
1382 #[doc = r" Create new entity data with default values."]
1383 pub fn new() -> Self {
1384 Self {
1385 living_entity: LivingEntityData::new(),
1386 client_flags: SyncedValue::new(0i8),
1387 head_pose: SyncedValue::new(Rotations::new(0f32, 0f32, 0f32)),
1388 body_pose: SyncedValue::new(Rotations::new(0f32, 0f32, 0f32)),
1389 left_arm_pose: SyncedValue::new(Rotations::new(-10f32, 0f32, -10f32)),
1390 right_arm_pose: SyncedValue::new(Rotations::new(-15f32, 0f32, 10f32)),
1391 left_leg_pose: SyncedValue::new(Rotations::new(-1f32, 0f32, -1f32)),
1392 right_leg_pose: SyncedValue::new(Rotations::new(1f32, 0f32, 1f32)),
1393 }
1394 }
1395 #[doc = "Returns the `ArmorStandEntityData` layer."]
1396 pub fn armor_stand(&self) -> &ArmorStandEntityData {
1397 self
1398 }
1399 #[doc = "Returns the mutable `ArmorStandEntityData` layer."]
1400 pub fn armor_stand_mut(&mut self) -> &mut ArmorStandEntityData {
1401 self
1402 }
1403 #[doc = "Returns the `LivingEntityData` layer."]
1404 pub fn living_entity(&self) -> &LivingEntityData {
1405 &self.living_entity
1406 }
1407 #[doc = "Returns the mutable `LivingEntityData` layer."]
1408 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
1409 &mut self.living_entity
1410 }
1411 #[doc = "Returns the `BaseEntityData` layer."]
1412 pub fn base(&self) -> &BaseEntityData {
1413 &self.living_entity.base
1414 }
1415 #[doc = "Returns the mutable `BaseEntityData` layer."]
1416 pub fn base_mut(&mut self) -> &mut BaseEntityData {
1417 &mut self.living_entity.base
1418 }
1419 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
1420 #[doc = r" Returns `None` if no values are dirty."]
1421 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1422 let mut values = Vec::new();
1423 self.pack_dirty_into(&mut values);
1424 if values.is_empty() {
1425 None
1426 } else {
1427 Some(values)
1428 }
1429 }
1430 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
1431 self.living_entity.pack_dirty_into(values);
1432 if self.client_flags.is_dirty() {
1433 values.push(DataValue {
1434 index: 15u8,
1435 serializer_id: 0i32,
1436 value: EntityData::Byte(*self.client_flags.get()),
1437 });
1438 self.client_flags.clear_dirty();
1439 }
1440 if self.head_pose.is_dirty() {
1441 values.push(DataValue {
1442 index: 16u8,
1443 serializer_id: 9i32,
1444 value: EntityData::Rotations(*self.head_pose.get()),
1445 });
1446 self.head_pose.clear_dirty();
1447 }
1448 if self.body_pose.is_dirty() {
1449 values.push(DataValue {
1450 index: 17u8,
1451 serializer_id: 9i32,
1452 value: EntityData::Rotations(*self.body_pose.get()),
1453 });
1454 self.body_pose.clear_dirty();
1455 }
1456 if self.left_arm_pose.is_dirty() {
1457 values.push(DataValue {
1458 index: 18u8,
1459 serializer_id: 9i32,
1460 value: EntityData::Rotations(*self.left_arm_pose.get()),
1461 });
1462 self.left_arm_pose.clear_dirty();
1463 }
1464 if self.right_arm_pose.is_dirty() {
1465 values.push(DataValue {
1466 index: 19u8,
1467 serializer_id: 9i32,
1468 value: EntityData::Rotations(*self.right_arm_pose.get()),
1469 });
1470 self.right_arm_pose.clear_dirty();
1471 }
1472 if self.left_leg_pose.is_dirty() {
1473 values.push(DataValue {
1474 index: 20u8,
1475 serializer_id: 9i32,
1476 value: EntityData::Rotations(*self.left_leg_pose.get()),
1477 });
1478 self.left_leg_pose.clear_dirty();
1479 }
1480 if self.right_leg_pose.is_dirty() {
1481 values.push(DataValue {
1482 index: 21u8,
1483 serializer_id: 9i32,
1484 value: EntityData::Rotations(*self.right_leg_pose.get()),
1485 });
1486 self.right_leg_pose.clear_dirty();
1487 }
1488 }
1489 #[doc = r" Pack all non-default values (for initial entity spawn)."]
1490 pub fn pack_all(&self) -> Vec<DataValue> {
1491 let mut values = Vec::new();
1492 self.pack_all_into(&mut values);
1493 values
1494 }
1495 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
1496 self.living_entity.pack_all_into(values);
1497 if !self.client_flags.is_default() {
1498 values.push(DataValue {
1499 index: 15u8,
1500 serializer_id: 0i32,
1501 value: EntityData::Byte(*self.client_flags.get()),
1502 });
1503 }
1504 if !self.head_pose.is_default() {
1505 values.push(DataValue {
1506 index: 16u8,
1507 serializer_id: 9i32,
1508 value: EntityData::Rotations(*self.head_pose.get()),
1509 });
1510 }
1511 if !self.body_pose.is_default() {
1512 values.push(DataValue {
1513 index: 17u8,
1514 serializer_id: 9i32,
1515 value: EntityData::Rotations(*self.body_pose.get()),
1516 });
1517 }
1518 if !self.left_arm_pose.is_default() {
1519 values.push(DataValue {
1520 index: 18u8,
1521 serializer_id: 9i32,
1522 value: EntityData::Rotations(*self.left_arm_pose.get()),
1523 });
1524 }
1525 if !self.right_arm_pose.is_default() {
1526 values.push(DataValue {
1527 index: 19u8,
1528 serializer_id: 9i32,
1529 value: EntityData::Rotations(*self.right_arm_pose.get()),
1530 });
1531 }
1532 if !self.left_leg_pose.is_default() {
1533 values.push(DataValue {
1534 index: 20u8,
1535 serializer_id: 9i32,
1536 value: EntityData::Rotations(*self.left_leg_pose.get()),
1537 });
1538 }
1539 if !self.right_leg_pose.is_default() {
1540 values.push(DataValue {
1541 index: 21u8,
1542 serializer_id: 9i32,
1543 value: EntityData::Rotations(*self.right_leg_pose.get()),
1544 });
1545 }
1546 }
1547 #[doc = r" Returns `true` if any field has been modified."]
1548 pub fn is_dirty(&self) -> bool {
1549 self.living_entity.is_dirty()
1550 || self.client_flags.is_dirty()
1551 || self.head_pose.is_dirty()
1552 || self.body_pose.is_dirty()
1553 || self.left_arm_pose.is_dirty()
1554 || self.right_arm_pose.is_dirty()
1555 || self.left_leg_pose.is_dirty()
1556 || self.right_leg_pose.is_dirty()
1557 }
1558}
1559impl Default for ArmorStandEntityData {
1560 fn default() -> Self {
1561 Self::new()
1562 }
1563}
1564impl VanillaEntityData for ArmorStandEntityData {
1565 fn base(&self) -> &BaseEntityData {
1566 ArmorStandEntityData::base(self)
1567 }
1568 fn base_mut(&mut self) -> &mut BaseEntityData {
1569 ArmorStandEntityData::base_mut(self)
1570 }
1571 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1572 ArmorStandEntityData::pack_dirty(self)
1573 }
1574 fn pack_all(&self) -> Vec<DataValue> {
1575 ArmorStandEntityData::pack_all(self)
1576 }
1577 fn is_dirty(&self) -> bool {
1578 ArmorStandEntityData::is_dirty(self)
1579 }
1580}
1581impl VanillaLivingEntityData for ArmorStandEntityData {
1582 fn living_entity(&self) -> &LivingEntityData {
1583 ArmorStandEntityData::living_entity(self)
1584 }
1585 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
1586 ArmorStandEntityData::living_entity_mut(self)
1587 }
1588}
1589#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
1590#[derive(Debug, Clone)]
1591pub struct AbstractArrowEntityData {
1592 pub base: BaseEntityData,
1593 pub id_flags: SyncedValue<i8>,
1594 pub pierce_level: SyncedValue<i8>,
1595 pub in_ground: SyncedValue<bool>,
1596}
1597impl AbstractArrowEntityData {
1598 #[doc = r" Create new entity data with default values."]
1599 pub fn new() -> Self {
1600 Self {
1601 base: BaseEntityData::new(),
1602 id_flags: SyncedValue::new(0i8),
1603 pierce_level: SyncedValue::new(0i8),
1604 in_ground: SyncedValue::new(false),
1605 }
1606 }
1607 #[doc = "Returns the `AbstractArrowEntityData` layer."]
1608 pub fn abstract_arrow(&self) -> &AbstractArrowEntityData {
1609 self
1610 }
1611 #[doc = "Returns the mutable `AbstractArrowEntityData` layer."]
1612 pub fn abstract_arrow_mut(&mut self) -> &mut AbstractArrowEntityData {
1613 self
1614 }
1615 #[doc = "Returns the `BaseEntityData` layer."]
1616 pub fn base(&self) -> &BaseEntityData {
1617 &self.base
1618 }
1619 #[doc = "Returns the mutable `BaseEntityData` layer."]
1620 pub fn base_mut(&mut self) -> &mut BaseEntityData {
1621 &mut self.base
1622 }
1623 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
1624 #[doc = r" Returns `None` if no values are dirty."]
1625 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1626 let mut values = Vec::new();
1627 self.pack_dirty_into(&mut values);
1628 if values.is_empty() {
1629 None
1630 } else {
1631 Some(values)
1632 }
1633 }
1634 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
1635 self.base.pack_dirty_into(values);
1636 if self.id_flags.is_dirty() {
1637 values.push(DataValue {
1638 index: 8u8,
1639 serializer_id: 0i32,
1640 value: EntityData::Byte(*self.id_flags.get()),
1641 });
1642 self.id_flags.clear_dirty();
1643 }
1644 if self.pierce_level.is_dirty() {
1645 values.push(DataValue {
1646 index: 9u8,
1647 serializer_id: 0i32,
1648 value: EntityData::Byte(*self.pierce_level.get()),
1649 });
1650 self.pierce_level.clear_dirty();
1651 }
1652 if self.in_ground.is_dirty() {
1653 values.push(DataValue {
1654 index: 10u8,
1655 serializer_id: 8i32,
1656 value: EntityData::Boolean(*self.in_ground.get()),
1657 });
1658 self.in_ground.clear_dirty();
1659 }
1660 }
1661 #[doc = r" Pack all non-default values (for initial entity spawn)."]
1662 pub fn pack_all(&self) -> Vec<DataValue> {
1663 let mut values = Vec::new();
1664 self.pack_all_into(&mut values);
1665 values
1666 }
1667 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
1668 self.base.pack_all_into(values);
1669 if !self.id_flags.is_default() {
1670 values.push(DataValue {
1671 index: 8u8,
1672 serializer_id: 0i32,
1673 value: EntityData::Byte(*self.id_flags.get()),
1674 });
1675 }
1676 if !self.pierce_level.is_default() {
1677 values.push(DataValue {
1678 index: 9u8,
1679 serializer_id: 0i32,
1680 value: EntityData::Byte(*self.pierce_level.get()),
1681 });
1682 }
1683 if !self.in_ground.is_default() {
1684 values.push(DataValue {
1685 index: 10u8,
1686 serializer_id: 8i32,
1687 value: EntityData::Boolean(*self.in_ground.get()),
1688 });
1689 }
1690 }
1691 #[doc = r" Returns `true` if any field has been modified."]
1692 pub fn is_dirty(&self) -> bool {
1693 self.base.is_dirty()
1694 || self.id_flags.is_dirty()
1695 || self.pierce_level.is_dirty()
1696 || self.in_ground.is_dirty()
1697 }
1698}
1699impl Default for AbstractArrowEntityData {
1700 fn default() -> Self {
1701 Self::new()
1702 }
1703}
1704impl VanillaEntityData for AbstractArrowEntityData {
1705 fn base(&self) -> &BaseEntityData {
1706 AbstractArrowEntityData::base(self)
1707 }
1708 fn base_mut(&mut self) -> &mut BaseEntityData {
1709 AbstractArrowEntityData::base_mut(self)
1710 }
1711 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1712 AbstractArrowEntityData::pack_dirty(self)
1713 }
1714 fn pack_all(&self) -> Vec<DataValue> {
1715 AbstractArrowEntityData::pack_all(self)
1716 }
1717 fn is_dirty(&self) -> bool {
1718 AbstractArrowEntityData::is_dirty(self)
1719 }
1720}
1721#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
1722#[derive(Debug, Clone)]
1723pub struct ArrowEntityData {
1724 pub abstract_arrow: AbstractArrowEntityData,
1725 pub id_effect_color: SyncedValue<i32>,
1726}
1727impl ArrowEntityData {
1728 #[doc = r" Create new entity data with default values."]
1729 pub fn new() -> Self {
1730 Self {
1731 abstract_arrow: AbstractArrowEntityData::new(),
1732 id_effect_color: SyncedValue::new(-1i32),
1733 }
1734 }
1735 #[doc = "Returns the `ArrowEntityData` layer."]
1736 pub fn arrow(&self) -> &ArrowEntityData {
1737 self
1738 }
1739 #[doc = "Returns the mutable `ArrowEntityData` layer."]
1740 pub fn arrow_mut(&mut self) -> &mut ArrowEntityData {
1741 self
1742 }
1743 #[doc = "Returns the `AbstractArrowEntityData` layer."]
1744 pub fn abstract_arrow(&self) -> &AbstractArrowEntityData {
1745 &self.abstract_arrow
1746 }
1747 #[doc = "Returns the mutable `AbstractArrowEntityData` layer."]
1748 pub fn abstract_arrow_mut(&mut self) -> &mut AbstractArrowEntityData {
1749 &mut self.abstract_arrow
1750 }
1751 #[doc = "Returns the `BaseEntityData` layer."]
1752 pub fn base(&self) -> &BaseEntityData {
1753 &self.abstract_arrow.base
1754 }
1755 #[doc = "Returns the mutable `BaseEntityData` layer."]
1756 pub fn base_mut(&mut self) -> &mut BaseEntityData {
1757 &mut self.abstract_arrow.base
1758 }
1759 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
1760 #[doc = r" Returns `None` if no values are dirty."]
1761 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1762 let mut values = Vec::new();
1763 self.pack_dirty_into(&mut values);
1764 if values.is_empty() {
1765 None
1766 } else {
1767 Some(values)
1768 }
1769 }
1770 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
1771 self.abstract_arrow.pack_dirty_into(values);
1772 if self.id_effect_color.is_dirty() {
1773 values.push(DataValue {
1774 index: 11u8,
1775 serializer_id: 1i32,
1776 value: EntityData::Int(*self.id_effect_color.get()),
1777 });
1778 self.id_effect_color.clear_dirty();
1779 }
1780 }
1781 #[doc = r" Pack all non-default values (for initial entity spawn)."]
1782 pub fn pack_all(&self) -> Vec<DataValue> {
1783 let mut values = Vec::new();
1784 self.pack_all_into(&mut values);
1785 values
1786 }
1787 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
1788 self.abstract_arrow.pack_all_into(values);
1789 if !self.id_effect_color.is_default() {
1790 values.push(DataValue {
1791 index: 11u8,
1792 serializer_id: 1i32,
1793 value: EntityData::Int(*self.id_effect_color.get()),
1794 });
1795 }
1796 }
1797 #[doc = r" Returns `true` if any field has been modified."]
1798 pub fn is_dirty(&self) -> bool {
1799 self.abstract_arrow.is_dirty() || self.id_effect_color.is_dirty()
1800 }
1801}
1802impl Default for ArrowEntityData {
1803 fn default() -> Self {
1804 Self::new()
1805 }
1806}
1807impl VanillaEntityData for ArrowEntityData {
1808 fn base(&self) -> &BaseEntityData {
1809 ArrowEntityData::base(self)
1810 }
1811 fn base_mut(&mut self) -> &mut BaseEntityData {
1812 ArrowEntityData::base_mut(self)
1813 }
1814 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1815 ArrowEntityData::pack_dirty(self)
1816 }
1817 fn pack_all(&self) -> Vec<DataValue> {
1818 ArrowEntityData::pack_all(self)
1819 }
1820 fn is_dirty(&self) -> bool {
1821 ArrowEntityData::is_dirty(self)
1822 }
1823}
1824#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
1825#[derive(Debug, Clone)]
1826pub struct AxolotlEntityData {
1827 pub ageable_mob: AgeableMobEntityData,
1828 pub variant: SyncedValue<i32>,
1829 pub playing_dead: SyncedValue<bool>,
1830 pub from_bucket: SyncedValue<bool>,
1831}
1832impl AxolotlEntityData {
1833 #[doc = r" Create new entity data with default values."]
1834 pub fn new() -> Self {
1835 let mut data = Self {
1836 ageable_mob: AgeableMobEntityData::new(),
1837 variant: SyncedValue::new(0i32),
1838 playing_dead: SyncedValue::new(false),
1839 from_bucket: SyncedValue::new(false),
1840 };
1841 data.ageable_mob.mob.living_entity.base.air_supply = SyncedValue::new(6000i32);
1842 data
1843 }
1844 #[doc = "Returns the `AxolotlEntityData` layer."]
1845 pub fn axolotl(&self) -> &AxolotlEntityData {
1846 self
1847 }
1848 #[doc = "Returns the mutable `AxolotlEntityData` layer."]
1849 pub fn axolotl_mut(&mut self) -> &mut AxolotlEntityData {
1850 self
1851 }
1852 #[doc = "Returns the `AgeableMobEntityData` layer."]
1853 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
1854 &self.ageable_mob
1855 }
1856 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
1857 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
1858 &mut self.ageable_mob
1859 }
1860 #[doc = "Returns the `MobEntityData` layer."]
1861 pub fn mob(&self) -> &MobEntityData {
1862 &self.ageable_mob.mob
1863 }
1864 #[doc = "Returns the mutable `MobEntityData` layer."]
1865 pub fn mob_mut(&mut self) -> &mut MobEntityData {
1866 &mut self.ageable_mob.mob
1867 }
1868 #[doc = "Returns the `LivingEntityData` layer."]
1869 pub fn living_entity(&self) -> &LivingEntityData {
1870 &self.ageable_mob.mob.living_entity
1871 }
1872 #[doc = "Returns the mutable `LivingEntityData` layer."]
1873 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
1874 &mut self.ageable_mob.mob.living_entity
1875 }
1876 #[doc = "Returns the `BaseEntityData` layer."]
1877 pub fn base(&self) -> &BaseEntityData {
1878 &self.ageable_mob.mob.living_entity.base
1879 }
1880 #[doc = "Returns the mutable `BaseEntityData` layer."]
1881 pub fn base_mut(&mut self) -> &mut BaseEntityData {
1882 &mut self.ageable_mob.mob.living_entity.base
1883 }
1884 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
1885 #[doc = r" Returns `None` if no values are dirty."]
1886 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1887 let mut values = Vec::new();
1888 self.pack_dirty_into(&mut values);
1889 if values.is_empty() {
1890 None
1891 } else {
1892 Some(values)
1893 }
1894 }
1895 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
1896 self.ageable_mob.pack_dirty_into(values);
1897 if self.variant.is_dirty() {
1898 values.push(DataValue {
1899 index: 18u8,
1900 serializer_id: 1i32,
1901 value: EntityData::Int(*self.variant.get()),
1902 });
1903 self.variant.clear_dirty();
1904 }
1905 if self.playing_dead.is_dirty() {
1906 values.push(DataValue {
1907 index: 19u8,
1908 serializer_id: 8i32,
1909 value: EntityData::Boolean(*self.playing_dead.get()),
1910 });
1911 self.playing_dead.clear_dirty();
1912 }
1913 if self.from_bucket.is_dirty() {
1914 values.push(DataValue {
1915 index: 20u8,
1916 serializer_id: 8i32,
1917 value: EntityData::Boolean(*self.from_bucket.get()),
1918 });
1919 self.from_bucket.clear_dirty();
1920 }
1921 }
1922 #[doc = r" Pack all non-default values (for initial entity spawn)."]
1923 pub fn pack_all(&self) -> Vec<DataValue> {
1924 let mut values = Vec::new();
1925 self.pack_all_into(&mut values);
1926 values
1927 }
1928 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
1929 self.ageable_mob.pack_all_into(values);
1930 if !self.variant.is_default() {
1931 values.push(DataValue {
1932 index: 18u8,
1933 serializer_id: 1i32,
1934 value: EntityData::Int(*self.variant.get()),
1935 });
1936 }
1937 if !self.playing_dead.is_default() {
1938 values.push(DataValue {
1939 index: 19u8,
1940 serializer_id: 8i32,
1941 value: EntityData::Boolean(*self.playing_dead.get()),
1942 });
1943 }
1944 if !self.from_bucket.is_default() {
1945 values.push(DataValue {
1946 index: 20u8,
1947 serializer_id: 8i32,
1948 value: EntityData::Boolean(*self.from_bucket.get()),
1949 });
1950 }
1951 }
1952 #[doc = r" Returns `true` if any field has been modified."]
1953 pub fn is_dirty(&self) -> bool {
1954 self.ageable_mob.is_dirty()
1955 || self.variant.is_dirty()
1956 || self.playing_dead.is_dirty()
1957 || self.from_bucket.is_dirty()
1958 }
1959}
1960impl Default for AxolotlEntityData {
1961 fn default() -> Self {
1962 Self::new()
1963 }
1964}
1965impl VanillaEntityData for AxolotlEntityData {
1966 fn base(&self) -> &BaseEntityData {
1967 AxolotlEntityData::base(self)
1968 }
1969 fn base_mut(&mut self) -> &mut BaseEntityData {
1970 AxolotlEntityData::base_mut(self)
1971 }
1972 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
1973 AxolotlEntityData::pack_dirty(self)
1974 }
1975 fn pack_all(&self) -> Vec<DataValue> {
1976 AxolotlEntityData::pack_all(self)
1977 }
1978 fn is_dirty(&self) -> bool {
1979 AxolotlEntityData::is_dirty(self)
1980 }
1981}
1982impl VanillaLivingEntityData for AxolotlEntityData {
1983 fn living_entity(&self) -> &LivingEntityData {
1984 AxolotlEntityData::living_entity(self)
1985 }
1986 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
1987 AxolotlEntityData::living_entity_mut(self)
1988 }
1989}
1990#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
1991#[derive(Debug, Clone)]
1992pub struct BatEntityData {
1993 pub mob: MobEntityData,
1994 pub id_flags: SyncedValue<i8>,
1995}
1996impl BatEntityData {
1997 #[doc = r" Create new entity data with default values."]
1998 pub fn new() -> Self {
1999 Self {
2000 mob: MobEntityData::new(),
2001 id_flags: SyncedValue::new(0i8),
2002 }
2003 }
2004 #[doc = "Returns the `BatEntityData` layer."]
2005 pub fn bat(&self) -> &BatEntityData {
2006 self
2007 }
2008 #[doc = "Returns the mutable `BatEntityData` layer."]
2009 pub fn bat_mut(&mut self) -> &mut BatEntityData {
2010 self
2011 }
2012 #[doc = "Returns the `MobEntityData` layer."]
2013 pub fn mob(&self) -> &MobEntityData {
2014 &self.mob
2015 }
2016 #[doc = "Returns the mutable `MobEntityData` layer."]
2017 pub fn mob_mut(&mut self) -> &mut MobEntityData {
2018 &mut self.mob
2019 }
2020 #[doc = "Returns the `LivingEntityData` layer."]
2021 pub fn living_entity(&self) -> &LivingEntityData {
2022 &self.mob.living_entity
2023 }
2024 #[doc = "Returns the mutable `LivingEntityData` layer."]
2025 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
2026 &mut self.mob.living_entity
2027 }
2028 #[doc = "Returns the `BaseEntityData` layer."]
2029 pub fn base(&self) -> &BaseEntityData {
2030 &self.mob.living_entity.base
2031 }
2032 #[doc = "Returns the mutable `BaseEntityData` layer."]
2033 pub fn base_mut(&mut self) -> &mut BaseEntityData {
2034 &mut self.mob.living_entity.base
2035 }
2036 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
2037 #[doc = r" Returns `None` if no values are dirty."]
2038 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2039 let mut values = Vec::new();
2040 self.pack_dirty_into(&mut values);
2041 if values.is_empty() {
2042 None
2043 } else {
2044 Some(values)
2045 }
2046 }
2047 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
2048 self.mob.pack_dirty_into(values);
2049 if self.id_flags.is_dirty() {
2050 values.push(DataValue {
2051 index: 16u8,
2052 serializer_id: 0i32,
2053 value: EntityData::Byte(*self.id_flags.get()),
2054 });
2055 self.id_flags.clear_dirty();
2056 }
2057 }
2058 #[doc = r" Pack all non-default values (for initial entity spawn)."]
2059 pub fn pack_all(&self) -> Vec<DataValue> {
2060 let mut values = Vec::new();
2061 self.pack_all_into(&mut values);
2062 values
2063 }
2064 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
2065 self.mob.pack_all_into(values);
2066 if !self.id_flags.is_default() {
2067 values.push(DataValue {
2068 index: 16u8,
2069 serializer_id: 0i32,
2070 value: EntityData::Byte(*self.id_flags.get()),
2071 });
2072 }
2073 }
2074 #[doc = r" Returns `true` if any field has been modified."]
2075 pub fn is_dirty(&self) -> bool {
2076 self.mob.is_dirty() || self.id_flags.is_dirty()
2077 }
2078}
2079impl Default for BatEntityData {
2080 fn default() -> Self {
2081 Self::new()
2082 }
2083}
2084impl VanillaEntityData for BatEntityData {
2085 fn base(&self) -> &BaseEntityData {
2086 BatEntityData::base(self)
2087 }
2088 fn base_mut(&mut self) -> &mut BaseEntityData {
2089 BatEntityData::base_mut(self)
2090 }
2091 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2092 BatEntityData::pack_dirty(self)
2093 }
2094 fn pack_all(&self) -> Vec<DataValue> {
2095 BatEntityData::pack_all(self)
2096 }
2097 fn is_dirty(&self) -> bool {
2098 BatEntityData::is_dirty(self)
2099 }
2100}
2101impl VanillaLivingEntityData for BatEntityData {
2102 fn living_entity(&self) -> &LivingEntityData {
2103 BatEntityData::living_entity(self)
2104 }
2105 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
2106 BatEntityData::living_entity_mut(self)
2107 }
2108}
2109#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
2110#[derive(Debug, Clone)]
2111pub struct BeeEntityData {
2112 pub ageable_mob: AgeableMobEntityData,
2113 pub flags: SyncedValue<i8>,
2114 pub anger_end_time: SyncedValue<i64>,
2115}
2116impl BeeEntityData {
2117 #[doc = r" Create new entity data with default values."]
2118 pub fn new() -> Self {
2119 Self {
2120 ageable_mob: AgeableMobEntityData::new(),
2121 flags: SyncedValue::new(0i8),
2122 anger_end_time: SyncedValue::new(-1i64),
2123 }
2124 }
2125 #[doc = "Returns the `BeeEntityData` layer."]
2126 pub fn bee(&self) -> &BeeEntityData {
2127 self
2128 }
2129 #[doc = "Returns the mutable `BeeEntityData` layer."]
2130 pub fn bee_mut(&mut self) -> &mut BeeEntityData {
2131 self
2132 }
2133 #[doc = "Returns the `AgeableMobEntityData` layer."]
2134 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
2135 &self.ageable_mob
2136 }
2137 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
2138 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
2139 &mut self.ageable_mob
2140 }
2141 #[doc = "Returns the `MobEntityData` layer."]
2142 pub fn mob(&self) -> &MobEntityData {
2143 &self.ageable_mob.mob
2144 }
2145 #[doc = "Returns the mutable `MobEntityData` layer."]
2146 pub fn mob_mut(&mut self) -> &mut MobEntityData {
2147 &mut self.ageable_mob.mob
2148 }
2149 #[doc = "Returns the `LivingEntityData` layer."]
2150 pub fn living_entity(&self) -> &LivingEntityData {
2151 &self.ageable_mob.mob.living_entity
2152 }
2153 #[doc = "Returns the mutable `LivingEntityData` layer."]
2154 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
2155 &mut self.ageable_mob.mob.living_entity
2156 }
2157 #[doc = "Returns the `BaseEntityData` layer."]
2158 pub fn base(&self) -> &BaseEntityData {
2159 &self.ageable_mob.mob.living_entity.base
2160 }
2161 #[doc = "Returns the mutable `BaseEntityData` layer."]
2162 pub fn base_mut(&mut self) -> &mut BaseEntityData {
2163 &mut self.ageable_mob.mob.living_entity.base
2164 }
2165 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
2166 #[doc = r" Returns `None` if no values are dirty."]
2167 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2168 let mut values = Vec::new();
2169 self.pack_dirty_into(&mut values);
2170 if values.is_empty() {
2171 None
2172 } else {
2173 Some(values)
2174 }
2175 }
2176 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
2177 self.ageable_mob.pack_dirty_into(values);
2178 if self.flags.is_dirty() {
2179 values.push(DataValue {
2180 index: 18u8,
2181 serializer_id: 0i32,
2182 value: EntityData::Byte(*self.flags.get()),
2183 });
2184 self.flags.clear_dirty();
2185 }
2186 if self.anger_end_time.is_dirty() {
2187 values.push(DataValue {
2188 index: 19u8,
2189 serializer_id: 2i32,
2190 value: EntityData::Long(*self.anger_end_time.get()),
2191 });
2192 self.anger_end_time.clear_dirty();
2193 }
2194 }
2195 #[doc = r" Pack all non-default values (for initial entity spawn)."]
2196 pub fn pack_all(&self) -> Vec<DataValue> {
2197 let mut values = Vec::new();
2198 self.pack_all_into(&mut values);
2199 values
2200 }
2201 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
2202 self.ageable_mob.pack_all_into(values);
2203 if !self.flags.is_default() {
2204 values.push(DataValue {
2205 index: 18u8,
2206 serializer_id: 0i32,
2207 value: EntityData::Byte(*self.flags.get()),
2208 });
2209 }
2210 if !self.anger_end_time.is_default() {
2211 values.push(DataValue {
2212 index: 19u8,
2213 serializer_id: 2i32,
2214 value: EntityData::Long(*self.anger_end_time.get()),
2215 });
2216 }
2217 }
2218 #[doc = r" Returns `true` if any field has been modified."]
2219 pub fn is_dirty(&self) -> bool {
2220 self.ageable_mob.is_dirty() || self.flags.is_dirty() || self.anger_end_time.is_dirty()
2221 }
2222}
2223impl Default for BeeEntityData {
2224 fn default() -> Self {
2225 Self::new()
2226 }
2227}
2228impl VanillaEntityData for BeeEntityData {
2229 fn base(&self) -> &BaseEntityData {
2230 BeeEntityData::base(self)
2231 }
2232 fn base_mut(&mut self) -> &mut BaseEntityData {
2233 BeeEntityData::base_mut(self)
2234 }
2235 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2236 BeeEntityData::pack_dirty(self)
2237 }
2238 fn pack_all(&self) -> Vec<DataValue> {
2239 BeeEntityData::pack_all(self)
2240 }
2241 fn is_dirty(&self) -> bool {
2242 BeeEntityData::is_dirty(self)
2243 }
2244}
2245impl VanillaLivingEntityData for BeeEntityData {
2246 fn living_entity(&self) -> &LivingEntityData {
2247 BeeEntityData::living_entity(self)
2248 }
2249 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
2250 BeeEntityData::living_entity_mut(self)
2251 }
2252}
2253#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
2254#[derive(Debug, Clone)]
2255pub struct BlazeEntityData {
2256 pub mob: MobEntityData,
2257 pub flags: SyncedValue<i8>,
2258}
2259impl BlazeEntityData {
2260 #[doc = r" Create new entity data with default values."]
2261 pub fn new() -> Self {
2262 Self {
2263 mob: MobEntityData::new(),
2264 flags: SyncedValue::new(0i8),
2265 }
2266 }
2267 #[doc = "Returns the `BlazeEntityData` layer."]
2268 pub fn blaze(&self) -> &BlazeEntityData {
2269 self
2270 }
2271 #[doc = "Returns the mutable `BlazeEntityData` layer."]
2272 pub fn blaze_mut(&mut self) -> &mut BlazeEntityData {
2273 self
2274 }
2275 #[doc = "Returns the `MobEntityData` layer."]
2276 pub fn mob(&self) -> &MobEntityData {
2277 &self.mob
2278 }
2279 #[doc = "Returns the mutable `MobEntityData` layer."]
2280 pub fn mob_mut(&mut self) -> &mut MobEntityData {
2281 &mut self.mob
2282 }
2283 #[doc = "Returns the `LivingEntityData` layer."]
2284 pub fn living_entity(&self) -> &LivingEntityData {
2285 &self.mob.living_entity
2286 }
2287 #[doc = "Returns the mutable `LivingEntityData` layer."]
2288 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
2289 &mut self.mob.living_entity
2290 }
2291 #[doc = "Returns the `BaseEntityData` layer."]
2292 pub fn base(&self) -> &BaseEntityData {
2293 &self.mob.living_entity.base
2294 }
2295 #[doc = "Returns the mutable `BaseEntityData` layer."]
2296 pub fn base_mut(&mut self) -> &mut BaseEntityData {
2297 &mut self.mob.living_entity.base
2298 }
2299 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
2300 #[doc = r" Returns `None` if no values are dirty."]
2301 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2302 let mut values = Vec::new();
2303 self.pack_dirty_into(&mut values);
2304 if values.is_empty() {
2305 None
2306 } else {
2307 Some(values)
2308 }
2309 }
2310 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
2311 self.mob.pack_dirty_into(values);
2312 if self.flags.is_dirty() {
2313 values.push(DataValue {
2314 index: 16u8,
2315 serializer_id: 0i32,
2316 value: EntityData::Byte(*self.flags.get()),
2317 });
2318 self.flags.clear_dirty();
2319 }
2320 }
2321 #[doc = r" Pack all non-default values (for initial entity spawn)."]
2322 pub fn pack_all(&self) -> Vec<DataValue> {
2323 let mut values = Vec::new();
2324 self.pack_all_into(&mut values);
2325 values
2326 }
2327 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
2328 self.mob.pack_all_into(values);
2329 if !self.flags.is_default() {
2330 values.push(DataValue {
2331 index: 16u8,
2332 serializer_id: 0i32,
2333 value: EntityData::Byte(*self.flags.get()),
2334 });
2335 }
2336 }
2337 #[doc = r" Returns `true` if any field has been modified."]
2338 pub fn is_dirty(&self) -> bool {
2339 self.mob.is_dirty() || self.flags.is_dirty()
2340 }
2341}
2342impl Default for BlazeEntityData {
2343 fn default() -> Self {
2344 Self::new()
2345 }
2346}
2347impl VanillaEntityData for BlazeEntityData {
2348 fn base(&self) -> &BaseEntityData {
2349 BlazeEntityData::base(self)
2350 }
2351 fn base_mut(&mut self) -> &mut BaseEntityData {
2352 BlazeEntityData::base_mut(self)
2353 }
2354 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2355 BlazeEntityData::pack_dirty(self)
2356 }
2357 fn pack_all(&self) -> Vec<DataValue> {
2358 BlazeEntityData::pack_all(self)
2359 }
2360 fn is_dirty(&self) -> bool {
2361 BlazeEntityData::is_dirty(self)
2362 }
2363}
2364impl VanillaLivingEntityData for BlazeEntityData {
2365 fn living_entity(&self) -> &LivingEntityData {
2366 BlazeEntityData::living_entity(self)
2367 }
2368 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
2369 BlazeEntityData::living_entity_mut(self)
2370 }
2371}
2372#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
2373#[derive(Debug, Clone)]
2374pub struct DisplayEntityData {
2375 pub base: BaseEntityData,
2376 pub transformation_interpolation_start_delta_ticks: SyncedValue<i32>,
2377 pub transformation_interpolation_duration: SyncedValue<i32>,
2378 pub pos_rot_interpolation_duration: SyncedValue<i32>,
2379 pub translation: SyncedValue<Vector3f>,
2380 pub scale: SyncedValue<Vector3f>,
2381 pub left_rotation: SyncedValue<Quaternionf>,
2382 pub right_rotation: SyncedValue<Quaternionf>,
2383 pub billboard_render_constraints: SyncedValue<i8>,
2384 pub brightness_override: SyncedValue<i32>,
2385 pub view_range: SyncedValue<f32>,
2386 pub shadow_radius: SyncedValue<f32>,
2387 pub shadow_strength: SyncedValue<f32>,
2388 pub width: SyncedValue<f32>,
2389 pub height: SyncedValue<f32>,
2390 pub glow_color_override: SyncedValue<i32>,
2391}
2392impl DisplayEntityData {
2393 #[doc = r" Create new entity data with default values."]
2394 pub fn new() -> Self {
2395 Self {
2396 base: BaseEntityData::new(),
2397 transformation_interpolation_start_delta_ticks: SyncedValue::new(0i32),
2398 transformation_interpolation_duration: SyncedValue::new(0i32),
2399 pos_rot_interpolation_duration: SyncedValue::new(0i32),
2400 translation: SyncedValue::new(Vector3f::new(0f32, 0f32, 0f32)),
2401 scale: SyncedValue::new(Vector3f::new(1f32, 1f32, 1f32)),
2402 left_rotation: SyncedValue::new(Quaternionf::new(0f32, 0f32, 0f32, 1f32)),
2403 right_rotation: SyncedValue::new(Quaternionf::new(0f32, 0f32, 0f32, 1f32)),
2404 billboard_render_constraints: SyncedValue::new(0i8),
2405 brightness_override: SyncedValue::new(-1i32),
2406 view_range: SyncedValue::new(1f32),
2407 shadow_radius: SyncedValue::new(0f32),
2408 shadow_strength: SyncedValue::new(1f32),
2409 width: SyncedValue::new(0f32),
2410 height: SyncedValue::new(0f32),
2411 glow_color_override: SyncedValue::new(-1i32),
2412 }
2413 }
2414 #[doc = "Returns the `DisplayEntityData` layer."]
2415 pub fn display(&self) -> &DisplayEntityData {
2416 self
2417 }
2418 #[doc = "Returns the mutable `DisplayEntityData` layer."]
2419 pub fn display_mut(&mut self) -> &mut DisplayEntityData {
2420 self
2421 }
2422 #[doc = "Returns the `BaseEntityData` layer."]
2423 pub fn base(&self) -> &BaseEntityData {
2424 &self.base
2425 }
2426 #[doc = "Returns the mutable `BaseEntityData` layer."]
2427 pub fn base_mut(&mut self) -> &mut BaseEntityData {
2428 &mut self.base
2429 }
2430 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
2431 #[doc = r" Returns `None` if no values are dirty."]
2432 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2433 let mut values = Vec::new();
2434 self.pack_dirty_into(&mut values);
2435 if values.is_empty() {
2436 None
2437 } else {
2438 Some(values)
2439 }
2440 }
2441 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
2442 self.base.pack_dirty_into(values);
2443 if self
2444 .transformation_interpolation_start_delta_ticks
2445 .is_dirty()
2446 {
2447 values.push(DataValue {
2448 index: 8u8,
2449 serializer_id: 1i32,
2450 value: EntityData::Int(*self.transformation_interpolation_start_delta_ticks.get()),
2451 });
2452 self.transformation_interpolation_start_delta_ticks
2453 .clear_dirty();
2454 }
2455 if self.transformation_interpolation_duration.is_dirty() {
2456 values.push(DataValue {
2457 index: 9u8,
2458 serializer_id: 1i32,
2459 value: EntityData::Int(*self.transformation_interpolation_duration.get()),
2460 });
2461 self.transformation_interpolation_duration.clear_dirty();
2462 }
2463 if self.pos_rot_interpolation_duration.is_dirty() {
2464 values.push(DataValue {
2465 index: 10u8,
2466 serializer_id: 1i32,
2467 value: EntityData::Int(*self.pos_rot_interpolation_duration.get()),
2468 });
2469 self.pos_rot_interpolation_duration.clear_dirty();
2470 }
2471 if self.translation.is_dirty() {
2472 values.push(DataValue {
2473 index: 11u8,
2474 serializer_id: 39i32,
2475 value: EntityData::Vector3(*self.translation.get()),
2476 });
2477 self.translation.clear_dirty();
2478 }
2479 if self.scale.is_dirty() {
2480 values.push(DataValue {
2481 index: 12u8,
2482 serializer_id: 39i32,
2483 value: EntityData::Vector3(*self.scale.get()),
2484 });
2485 self.scale.clear_dirty();
2486 }
2487 if self.left_rotation.is_dirty() {
2488 values.push(DataValue {
2489 index: 13u8,
2490 serializer_id: 40i32,
2491 value: EntityData::Quaternion(*self.left_rotation.get()),
2492 });
2493 self.left_rotation.clear_dirty();
2494 }
2495 if self.right_rotation.is_dirty() {
2496 values.push(DataValue {
2497 index: 14u8,
2498 serializer_id: 40i32,
2499 value: EntityData::Quaternion(*self.right_rotation.get()),
2500 });
2501 self.right_rotation.clear_dirty();
2502 }
2503 if self.billboard_render_constraints.is_dirty() {
2504 values.push(DataValue {
2505 index: 15u8,
2506 serializer_id: 0i32,
2507 value: EntityData::Byte(*self.billboard_render_constraints.get()),
2508 });
2509 self.billboard_render_constraints.clear_dirty();
2510 }
2511 if self.brightness_override.is_dirty() {
2512 values.push(DataValue {
2513 index: 16u8,
2514 serializer_id: 1i32,
2515 value: EntityData::Int(*self.brightness_override.get()),
2516 });
2517 self.brightness_override.clear_dirty();
2518 }
2519 if self.view_range.is_dirty() {
2520 values.push(DataValue {
2521 index: 17u8,
2522 serializer_id: 3i32,
2523 value: EntityData::Float(*self.view_range.get()),
2524 });
2525 self.view_range.clear_dirty();
2526 }
2527 if self.shadow_radius.is_dirty() {
2528 values.push(DataValue {
2529 index: 18u8,
2530 serializer_id: 3i32,
2531 value: EntityData::Float(*self.shadow_radius.get()),
2532 });
2533 self.shadow_radius.clear_dirty();
2534 }
2535 if self.shadow_strength.is_dirty() {
2536 values.push(DataValue {
2537 index: 19u8,
2538 serializer_id: 3i32,
2539 value: EntityData::Float(*self.shadow_strength.get()),
2540 });
2541 self.shadow_strength.clear_dirty();
2542 }
2543 if self.width.is_dirty() {
2544 values.push(DataValue {
2545 index: 20u8,
2546 serializer_id: 3i32,
2547 value: EntityData::Float(*self.width.get()),
2548 });
2549 self.width.clear_dirty();
2550 }
2551 if self.height.is_dirty() {
2552 values.push(DataValue {
2553 index: 21u8,
2554 serializer_id: 3i32,
2555 value: EntityData::Float(*self.height.get()),
2556 });
2557 self.height.clear_dirty();
2558 }
2559 if self.glow_color_override.is_dirty() {
2560 values.push(DataValue {
2561 index: 22u8,
2562 serializer_id: 1i32,
2563 value: EntityData::Int(*self.glow_color_override.get()),
2564 });
2565 self.glow_color_override.clear_dirty();
2566 }
2567 }
2568 #[doc = r" Pack all non-default values (for initial entity spawn)."]
2569 pub fn pack_all(&self) -> Vec<DataValue> {
2570 let mut values = Vec::new();
2571 self.pack_all_into(&mut values);
2572 values
2573 }
2574 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
2575 self.base.pack_all_into(values);
2576 if !self
2577 .transformation_interpolation_start_delta_ticks
2578 .is_default()
2579 {
2580 values.push(DataValue {
2581 index: 8u8,
2582 serializer_id: 1i32,
2583 value: EntityData::Int(*self.transformation_interpolation_start_delta_ticks.get()),
2584 });
2585 }
2586 if !self.transformation_interpolation_duration.is_default() {
2587 values.push(DataValue {
2588 index: 9u8,
2589 serializer_id: 1i32,
2590 value: EntityData::Int(*self.transformation_interpolation_duration.get()),
2591 });
2592 }
2593 if !self.pos_rot_interpolation_duration.is_default() {
2594 values.push(DataValue {
2595 index: 10u8,
2596 serializer_id: 1i32,
2597 value: EntityData::Int(*self.pos_rot_interpolation_duration.get()),
2598 });
2599 }
2600 if !self.translation.is_default() {
2601 values.push(DataValue {
2602 index: 11u8,
2603 serializer_id: 39i32,
2604 value: EntityData::Vector3(*self.translation.get()),
2605 });
2606 }
2607 if !self.scale.is_default() {
2608 values.push(DataValue {
2609 index: 12u8,
2610 serializer_id: 39i32,
2611 value: EntityData::Vector3(*self.scale.get()),
2612 });
2613 }
2614 if !self.left_rotation.is_default() {
2615 values.push(DataValue {
2616 index: 13u8,
2617 serializer_id: 40i32,
2618 value: EntityData::Quaternion(*self.left_rotation.get()),
2619 });
2620 }
2621 if !self.right_rotation.is_default() {
2622 values.push(DataValue {
2623 index: 14u8,
2624 serializer_id: 40i32,
2625 value: EntityData::Quaternion(*self.right_rotation.get()),
2626 });
2627 }
2628 if !self.billboard_render_constraints.is_default() {
2629 values.push(DataValue {
2630 index: 15u8,
2631 serializer_id: 0i32,
2632 value: EntityData::Byte(*self.billboard_render_constraints.get()),
2633 });
2634 }
2635 if !self.brightness_override.is_default() {
2636 values.push(DataValue {
2637 index: 16u8,
2638 serializer_id: 1i32,
2639 value: EntityData::Int(*self.brightness_override.get()),
2640 });
2641 }
2642 if !self.view_range.is_default() {
2643 values.push(DataValue {
2644 index: 17u8,
2645 serializer_id: 3i32,
2646 value: EntityData::Float(*self.view_range.get()),
2647 });
2648 }
2649 if !self.shadow_radius.is_default() {
2650 values.push(DataValue {
2651 index: 18u8,
2652 serializer_id: 3i32,
2653 value: EntityData::Float(*self.shadow_radius.get()),
2654 });
2655 }
2656 if !self.shadow_strength.is_default() {
2657 values.push(DataValue {
2658 index: 19u8,
2659 serializer_id: 3i32,
2660 value: EntityData::Float(*self.shadow_strength.get()),
2661 });
2662 }
2663 if !self.width.is_default() {
2664 values.push(DataValue {
2665 index: 20u8,
2666 serializer_id: 3i32,
2667 value: EntityData::Float(*self.width.get()),
2668 });
2669 }
2670 if !self.height.is_default() {
2671 values.push(DataValue {
2672 index: 21u8,
2673 serializer_id: 3i32,
2674 value: EntityData::Float(*self.height.get()),
2675 });
2676 }
2677 if !self.glow_color_override.is_default() {
2678 values.push(DataValue {
2679 index: 22u8,
2680 serializer_id: 1i32,
2681 value: EntityData::Int(*self.glow_color_override.get()),
2682 });
2683 }
2684 }
2685 #[doc = r" Returns `true` if any field has been modified."]
2686 pub fn is_dirty(&self) -> bool {
2687 self.base.is_dirty()
2688 || self
2689 .transformation_interpolation_start_delta_ticks
2690 .is_dirty()
2691 || self.transformation_interpolation_duration.is_dirty()
2692 || self.pos_rot_interpolation_duration.is_dirty()
2693 || self.translation.is_dirty()
2694 || self.scale.is_dirty()
2695 || self.left_rotation.is_dirty()
2696 || self.right_rotation.is_dirty()
2697 || self.billboard_render_constraints.is_dirty()
2698 || self.brightness_override.is_dirty()
2699 || self.view_range.is_dirty()
2700 || self.shadow_radius.is_dirty()
2701 || self.shadow_strength.is_dirty()
2702 || self.width.is_dirty()
2703 || self.height.is_dirty()
2704 || self.glow_color_override.is_dirty()
2705 }
2706}
2707impl Default for DisplayEntityData {
2708 fn default() -> Self {
2709 Self::new()
2710 }
2711}
2712impl VanillaEntityData for DisplayEntityData {
2713 fn base(&self) -> &BaseEntityData {
2714 DisplayEntityData::base(self)
2715 }
2716 fn base_mut(&mut self) -> &mut BaseEntityData {
2717 DisplayEntityData::base_mut(self)
2718 }
2719 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2720 DisplayEntityData::pack_dirty(self)
2721 }
2722 fn pack_all(&self) -> Vec<DataValue> {
2723 DisplayEntityData::pack_all(self)
2724 }
2725 fn is_dirty(&self) -> bool {
2726 DisplayEntityData::is_dirty(self)
2727 }
2728}
2729#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
2730#[derive(Debug, Clone)]
2731pub struct BlockDisplayEntityData {
2732 pub display: DisplayEntityData,
2733 pub block_state: SyncedValue<BlockStateId>,
2734}
2735impl BlockDisplayEntityData {
2736 #[doc = r" Create new entity data with default values."]
2737 pub fn new() -> Self {
2738 Self {
2739 display: DisplayEntityData::new(),
2740 block_state: SyncedValue::new(crate::vanilla_blocks::AIR.default_state()),
2741 }
2742 }
2743 #[doc = "Returns the `BlockDisplayEntityData` layer."]
2744 pub fn block_display(&self) -> &BlockDisplayEntityData {
2745 self
2746 }
2747 #[doc = "Returns the mutable `BlockDisplayEntityData` layer."]
2748 pub fn block_display_mut(&mut self) -> &mut BlockDisplayEntityData {
2749 self
2750 }
2751 #[doc = "Returns the `DisplayEntityData` layer."]
2752 pub fn display(&self) -> &DisplayEntityData {
2753 &self.display
2754 }
2755 #[doc = "Returns the mutable `DisplayEntityData` layer."]
2756 pub fn display_mut(&mut self) -> &mut DisplayEntityData {
2757 &mut self.display
2758 }
2759 #[doc = "Returns the `BaseEntityData` layer."]
2760 pub fn base(&self) -> &BaseEntityData {
2761 &self.display.base
2762 }
2763 #[doc = "Returns the mutable `BaseEntityData` layer."]
2764 pub fn base_mut(&mut self) -> &mut BaseEntityData {
2765 &mut self.display.base
2766 }
2767 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
2768 #[doc = r" Returns `None` if no values are dirty."]
2769 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2770 let mut values = Vec::new();
2771 self.pack_dirty_into(&mut values);
2772 if values.is_empty() {
2773 None
2774 } else {
2775 Some(values)
2776 }
2777 }
2778 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
2779 self.display.pack_dirty_into(values);
2780 if self.block_state.is_dirty() {
2781 values.push(DataValue {
2782 index: 23u8,
2783 serializer_id: 14i32,
2784 value: EntityData::BlockState(*self.block_state.get()),
2785 });
2786 self.block_state.clear_dirty();
2787 }
2788 }
2789 #[doc = r" Pack all non-default values (for initial entity spawn)."]
2790 pub fn pack_all(&self) -> Vec<DataValue> {
2791 let mut values = Vec::new();
2792 self.pack_all_into(&mut values);
2793 values
2794 }
2795 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
2796 self.display.pack_all_into(values);
2797 if !self.block_state.is_default() {
2798 values.push(DataValue {
2799 index: 23u8,
2800 serializer_id: 14i32,
2801 value: EntityData::BlockState(*self.block_state.get()),
2802 });
2803 }
2804 }
2805 #[doc = r" Returns `true` if any field has been modified."]
2806 pub fn is_dirty(&self) -> bool {
2807 self.display.is_dirty() || self.block_state.is_dirty()
2808 }
2809}
2810impl Default for BlockDisplayEntityData {
2811 fn default() -> Self {
2812 Self::new()
2813 }
2814}
2815impl VanillaEntityData for BlockDisplayEntityData {
2816 fn base(&self) -> &BaseEntityData {
2817 BlockDisplayEntityData::base(self)
2818 }
2819 fn base_mut(&mut self) -> &mut BaseEntityData {
2820 BlockDisplayEntityData::base_mut(self)
2821 }
2822 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2823 BlockDisplayEntityData::pack_dirty(self)
2824 }
2825 fn pack_all(&self) -> Vec<DataValue> {
2826 BlockDisplayEntityData::pack_all(self)
2827 }
2828 fn is_dirty(&self) -> bool {
2829 BlockDisplayEntityData::is_dirty(self)
2830 }
2831}
2832#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
2833#[derive(Debug, Clone)]
2834pub struct BoggedEntityData {
2835 pub mob: MobEntityData,
2836 pub sheared: SyncedValue<bool>,
2837}
2838impl BoggedEntityData {
2839 #[doc = r" Create new entity data with default values."]
2840 pub fn new() -> Self {
2841 Self {
2842 mob: MobEntityData::new(),
2843 sheared: SyncedValue::new(false),
2844 }
2845 }
2846 #[doc = "Returns the `BoggedEntityData` layer."]
2847 pub fn bogged(&self) -> &BoggedEntityData {
2848 self
2849 }
2850 #[doc = "Returns the mutable `BoggedEntityData` layer."]
2851 pub fn bogged_mut(&mut self) -> &mut BoggedEntityData {
2852 self
2853 }
2854 #[doc = "Returns the `MobEntityData` layer."]
2855 pub fn mob(&self) -> &MobEntityData {
2856 &self.mob
2857 }
2858 #[doc = "Returns the mutable `MobEntityData` layer."]
2859 pub fn mob_mut(&mut self) -> &mut MobEntityData {
2860 &mut self.mob
2861 }
2862 #[doc = "Returns the `LivingEntityData` layer."]
2863 pub fn living_entity(&self) -> &LivingEntityData {
2864 &self.mob.living_entity
2865 }
2866 #[doc = "Returns the mutable `LivingEntityData` layer."]
2867 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
2868 &mut self.mob.living_entity
2869 }
2870 #[doc = "Returns the `BaseEntityData` layer."]
2871 pub fn base(&self) -> &BaseEntityData {
2872 &self.mob.living_entity.base
2873 }
2874 #[doc = "Returns the mutable `BaseEntityData` layer."]
2875 pub fn base_mut(&mut self) -> &mut BaseEntityData {
2876 &mut self.mob.living_entity.base
2877 }
2878 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
2879 #[doc = r" Returns `None` if no values are dirty."]
2880 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2881 let mut values = Vec::new();
2882 self.pack_dirty_into(&mut values);
2883 if values.is_empty() {
2884 None
2885 } else {
2886 Some(values)
2887 }
2888 }
2889 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
2890 self.mob.pack_dirty_into(values);
2891 if self.sheared.is_dirty() {
2892 values.push(DataValue {
2893 index: 16u8,
2894 serializer_id: 8i32,
2895 value: EntityData::Boolean(*self.sheared.get()),
2896 });
2897 self.sheared.clear_dirty();
2898 }
2899 }
2900 #[doc = r" Pack all non-default values (for initial entity spawn)."]
2901 pub fn pack_all(&self) -> Vec<DataValue> {
2902 let mut values = Vec::new();
2903 self.pack_all_into(&mut values);
2904 values
2905 }
2906 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
2907 self.mob.pack_all_into(values);
2908 if !self.sheared.is_default() {
2909 values.push(DataValue {
2910 index: 16u8,
2911 serializer_id: 8i32,
2912 value: EntityData::Boolean(*self.sheared.get()),
2913 });
2914 }
2915 }
2916 #[doc = r" Returns `true` if any field has been modified."]
2917 pub fn is_dirty(&self) -> bool {
2918 self.mob.is_dirty() || self.sheared.is_dirty()
2919 }
2920}
2921impl Default for BoggedEntityData {
2922 fn default() -> Self {
2923 Self::new()
2924 }
2925}
2926impl VanillaEntityData for BoggedEntityData {
2927 fn base(&self) -> &BaseEntityData {
2928 BoggedEntityData::base(self)
2929 }
2930 fn base_mut(&mut self) -> &mut BaseEntityData {
2931 BoggedEntityData::base_mut(self)
2932 }
2933 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
2934 BoggedEntityData::pack_dirty(self)
2935 }
2936 fn pack_all(&self) -> Vec<DataValue> {
2937 BoggedEntityData::pack_all(self)
2938 }
2939 fn is_dirty(&self) -> bool {
2940 BoggedEntityData::is_dirty(self)
2941 }
2942}
2943impl VanillaLivingEntityData for BoggedEntityData {
2944 fn living_entity(&self) -> &LivingEntityData {
2945 BoggedEntityData::living_entity(self)
2946 }
2947 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
2948 BoggedEntityData::living_entity_mut(self)
2949 }
2950}
2951#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
2952#[derive(Debug, Clone)]
2953pub struct AbstractHorseEntityData {
2954 pub ageable_mob: AgeableMobEntityData,
2955 pub id_flags: SyncedValue<i8>,
2956}
2957impl AbstractHorseEntityData {
2958 #[doc = r" Create new entity data with default values."]
2959 pub fn new() -> Self {
2960 Self {
2961 ageable_mob: AgeableMobEntityData::new(),
2962 id_flags: SyncedValue::new(0i8),
2963 }
2964 }
2965 #[doc = "Returns the `AbstractHorseEntityData` layer."]
2966 pub fn abstract_horse(&self) -> &AbstractHorseEntityData {
2967 self
2968 }
2969 #[doc = "Returns the mutable `AbstractHorseEntityData` layer."]
2970 pub fn abstract_horse_mut(&mut self) -> &mut AbstractHorseEntityData {
2971 self
2972 }
2973 #[doc = "Returns the `AgeableMobEntityData` layer."]
2974 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
2975 &self.ageable_mob
2976 }
2977 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
2978 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
2979 &mut self.ageable_mob
2980 }
2981 #[doc = "Returns the `MobEntityData` layer."]
2982 pub fn mob(&self) -> &MobEntityData {
2983 &self.ageable_mob.mob
2984 }
2985 #[doc = "Returns the mutable `MobEntityData` layer."]
2986 pub fn mob_mut(&mut self) -> &mut MobEntityData {
2987 &mut self.ageable_mob.mob
2988 }
2989 #[doc = "Returns the `LivingEntityData` layer."]
2990 pub fn living_entity(&self) -> &LivingEntityData {
2991 &self.ageable_mob.mob.living_entity
2992 }
2993 #[doc = "Returns the mutable `LivingEntityData` layer."]
2994 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
2995 &mut self.ageable_mob.mob.living_entity
2996 }
2997 #[doc = "Returns the `BaseEntityData` layer."]
2998 pub fn base(&self) -> &BaseEntityData {
2999 &self.ageable_mob.mob.living_entity.base
3000 }
3001 #[doc = "Returns the mutable `BaseEntityData` layer."]
3002 pub fn base_mut(&mut self) -> &mut BaseEntityData {
3003 &mut self.ageable_mob.mob.living_entity.base
3004 }
3005 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
3006 #[doc = r" Returns `None` if no values are dirty."]
3007 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3008 let mut values = Vec::new();
3009 self.pack_dirty_into(&mut values);
3010 if values.is_empty() {
3011 None
3012 } else {
3013 Some(values)
3014 }
3015 }
3016 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
3017 self.ageable_mob.pack_dirty_into(values);
3018 if self.id_flags.is_dirty() {
3019 values.push(DataValue {
3020 index: 18u8,
3021 serializer_id: 0i32,
3022 value: EntityData::Byte(*self.id_flags.get()),
3023 });
3024 self.id_flags.clear_dirty();
3025 }
3026 }
3027 #[doc = r" Pack all non-default values (for initial entity spawn)."]
3028 pub fn pack_all(&self) -> Vec<DataValue> {
3029 let mut values = Vec::new();
3030 self.pack_all_into(&mut values);
3031 values
3032 }
3033 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
3034 self.ageable_mob.pack_all_into(values);
3035 if !self.id_flags.is_default() {
3036 values.push(DataValue {
3037 index: 18u8,
3038 serializer_id: 0i32,
3039 value: EntityData::Byte(*self.id_flags.get()),
3040 });
3041 }
3042 }
3043 #[doc = r" Returns `true` if any field has been modified."]
3044 pub fn is_dirty(&self) -> bool {
3045 self.ageable_mob.is_dirty() || self.id_flags.is_dirty()
3046 }
3047}
3048impl Default for AbstractHorseEntityData {
3049 fn default() -> Self {
3050 Self::new()
3051 }
3052}
3053impl VanillaEntityData for AbstractHorseEntityData {
3054 fn base(&self) -> &BaseEntityData {
3055 AbstractHorseEntityData::base(self)
3056 }
3057 fn base_mut(&mut self) -> &mut BaseEntityData {
3058 AbstractHorseEntityData::base_mut(self)
3059 }
3060 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3061 AbstractHorseEntityData::pack_dirty(self)
3062 }
3063 fn pack_all(&self) -> Vec<DataValue> {
3064 AbstractHorseEntityData::pack_all(self)
3065 }
3066 fn is_dirty(&self) -> bool {
3067 AbstractHorseEntityData::is_dirty(self)
3068 }
3069}
3070impl VanillaLivingEntityData for AbstractHorseEntityData {
3071 fn living_entity(&self) -> &LivingEntityData {
3072 AbstractHorseEntityData::living_entity(self)
3073 }
3074 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
3075 AbstractHorseEntityData::living_entity_mut(self)
3076 }
3077}
3078#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
3079#[derive(Debug, Clone)]
3080pub struct CamelEntityData {
3081 pub abstract_horse: AbstractHorseEntityData,
3082 pub dash: SyncedValue<bool>,
3083 pub last_pose_change_tick: SyncedValue<i64>,
3084}
3085impl CamelEntityData {
3086 #[doc = r" Create new entity data with default values."]
3087 pub fn new() -> Self {
3088 Self {
3089 abstract_horse: AbstractHorseEntityData::new(),
3090 dash: SyncedValue::new(false),
3091 last_pose_change_tick: SyncedValue::new(0i64),
3092 }
3093 }
3094 #[doc = "Returns the `CamelEntityData` layer."]
3095 pub fn camel(&self) -> &CamelEntityData {
3096 self
3097 }
3098 #[doc = "Returns the mutable `CamelEntityData` layer."]
3099 pub fn camel_mut(&mut self) -> &mut CamelEntityData {
3100 self
3101 }
3102 #[doc = "Returns the `AbstractHorseEntityData` layer."]
3103 pub fn abstract_horse(&self) -> &AbstractHorseEntityData {
3104 &self.abstract_horse
3105 }
3106 #[doc = "Returns the mutable `AbstractHorseEntityData` layer."]
3107 pub fn abstract_horse_mut(&mut self) -> &mut AbstractHorseEntityData {
3108 &mut self.abstract_horse
3109 }
3110 #[doc = "Returns the `AgeableMobEntityData` layer."]
3111 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
3112 &self.abstract_horse.ageable_mob
3113 }
3114 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
3115 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
3116 &mut self.abstract_horse.ageable_mob
3117 }
3118 #[doc = "Returns the `MobEntityData` layer."]
3119 pub fn mob(&self) -> &MobEntityData {
3120 &self.abstract_horse.ageable_mob.mob
3121 }
3122 #[doc = "Returns the mutable `MobEntityData` layer."]
3123 pub fn mob_mut(&mut self) -> &mut MobEntityData {
3124 &mut self.abstract_horse.ageable_mob.mob
3125 }
3126 #[doc = "Returns the `LivingEntityData` layer."]
3127 pub fn living_entity(&self) -> &LivingEntityData {
3128 &self.abstract_horse.ageable_mob.mob.living_entity
3129 }
3130 #[doc = "Returns the mutable `LivingEntityData` layer."]
3131 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
3132 &mut self.abstract_horse.ageable_mob.mob.living_entity
3133 }
3134 #[doc = "Returns the `BaseEntityData` layer."]
3135 pub fn base(&self) -> &BaseEntityData {
3136 &self.abstract_horse.ageable_mob.mob.living_entity.base
3137 }
3138 #[doc = "Returns the mutable `BaseEntityData` layer."]
3139 pub fn base_mut(&mut self) -> &mut BaseEntityData {
3140 &mut self.abstract_horse.ageable_mob.mob.living_entity.base
3141 }
3142 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
3143 #[doc = r" Returns `None` if no values are dirty."]
3144 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3145 let mut values = Vec::new();
3146 self.pack_dirty_into(&mut values);
3147 if values.is_empty() {
3148 None
3149 } else {
3150 Some(values)
3151 }
3152 }
3153 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
3154 self.abstract_horse.pack_dirty_into(values);
3155 if self.dash.is_dirty() {
3156 values.push(DataValue {
3157 index: 19u8,
3158 serializer_id: 8i32,
3159 value: EntityData::Boolean(*self.dash.get()),
3160 });
3161 self.dash.clear_dirty();
3162 }
3163 if self.last_pose_change_tick.is_dirty() {
3164 values.push(DataValue {
3165 index: 20u8,
3166 serializer_id: 2i32,
3167 value: EntityData::Long(*self.last_pose_change_tick.get()),
3168 });
3169 self.last_pose_change_tick.clear_dirty();
3170 }
3171 }
3172 #[doc = r" Pack all non-default values (for initial entity spawn)."]
3173 pub fn pack_all(&self) -> Vec<DataValue> {
3174 let mut values = Vec::new();
3175 self.pack_all_into(&mut values);
3176 values
3177 }
3178 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
3179 self.abstract_horse.pack_all_into(values);
3180 if !self.dash.is_default() {
3181 values.push(DataValue {
3182 index: 19u8,
3183 serializer_id: 8i32,
3184 value: EntityData::Boolean(*self.dash.get()),
3185 });
3186 }
3187 if !self.last_pose_change_tick.is_default() {
3188 values.push(DataValue {
3189 index: 20u8,
3190 serializer_id: 2i32,
3191 value: EntityData::Long(*self.last_pose_change_tick.get()),
3192 });
3193 }
3194 }
3195 #[doc = r" Returns `true` if any field has been modified."]
3196 pub fn is_dirty(&self) -> bool {
3197 self.abstract_horse.is_dirty()
3198 || self.dash.is_dirty()
3199 || self.last_pose_change_tick.is_dirty()
3200 }
3201}
3202impl Default for CamelEntityData {
3203 fn default() -> Self {
3204 Self::new()
3205 }
3206}
3207impl VanillaEntityData for CamelEntityData {
3208 fn base(&self) -> &BaseEntityData {
3209 CamelEntityData::base(self)
3210 }
3211 fn base_mut(&mut self) -> &mut BaseEntityData {
3212 CamelEntityData::base_mut(self)
3213 }
3214 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3215 CamelEntityData::pack_dirty(self)
3216 }
3217 fn pack_all(&self) -> Vec<DataValue> {
3218 CamelEntityData::pack_all(self)
3219 }
3220 fn is_dirty(&self) -> bool {
3221 CamelEntityData::is_dirty(self)
3222 }
3223}
3224impl VanillaLivingEntityData for CamelEntityData {
3225 fn living_entity(&self) -> &LivingEntityData {
3226 CamelEntityData::living_entity(self)
3227 }
3228 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
3229 CamelEntityData::living_entity_mut(self)
3230 }
3231}
3232#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
3233#[derive(Debug, Clone)]
3234pub struct TamableAnimalEntityData {
3235 pub ageable_mob: AgeableMobEntityData,
3236 pub flags: SyncedValue<i8>,
3237 pub owneruuid: SyncedValue<Option<Uuid>>,
3238}
3239impl TamableAnimalEntityData {
3240 #[doc = r" Create new entity data with default values."]
3241 pub fn new() -> Self {
3242 Self {
3243 ageable_mob: AgeableMobEntityData::new(),
3244 flags: SyncedValue::new(0i8),
3245 owneruuid: SyncedValue::new(None),
3246 }
3247 }
3248 #[doc = "Returns the `TamableAnimalEntityData` layer."]
3249 pub fn tamable_animal(&self) -> &TamableAnimalEntityData {
3250 self
3251 }
3252 #[doc = "Returns the mutable `TamableAnimalEntityData` layer."]
3253 pub fn tamable_animal_mut(&mut self) -> &mut TamableAnimalEntityData {
3254 self
3255 }
3256 #[doc = "Returns the `AgeableMobEntityData` layer."]
3257 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
3258 &self.ageable_mob
3259 }
3260 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
3261 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
3262 &mut self.ageable_mob
3263 }
3264 #[doc = "Returns the `MobEntityData` layer."]
3265 pub fn mob(&self) -> &MobEntityData {
3266 &self.ageable_mob.mob
3267 }
3268 #[doc = "Returns the mutable `MobEntityData` layer."]
3269 pub fn mob_mut(&mut self) -> &mut MobEntityData {
3270 &mut self.ageable_mob.mob
3271 }
3272 #[doc = "Returns the `LivingEntityData` layer."]
3273 pub fn living_entity(&self) -> &LivingEntityData {
3274 &self.ageable_mob.mob.living_entity
3275 }
3276 #[doc = "Returns the mutable `LivingEntityData` layer."]
3277 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
3278 &mut self.ageable_mob.mob.living_entity
3279 }
3280 #[doc = "Returns the `BaseEntityData` layer."]
3281 pub fn base(&self) -> &BaseEntityData {
3282 &self.ageable_mob.mob.living_entity.base
3283 }
3284 #[doc = "Returns the mutable `BaseEntityData` layer."]
3285 pub fn base_mut(&mut self) -> &mut BaseEntityData {
3286 &mut self.ageable_mob.mob.living_entity.base
3287 }
3288 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
3289 #[doc = r" Returns `None` if no values are dirty."]
3290 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3291 let mut values = Vec::new();
3292 self.pack_dirty_into(&mut values);
3293 if values.is_empty() {
3294 None
3295 } else {
3296 Some(values)
3297 }
3298 }
3299 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
3300 self.ageable_mob.pack_dirty_into(values);
3301 if self.flags.is_dirty() {
3302 values.push(DataValue {
3303 index: 18u8,
3304 serializer_id: 0i32,
3305 value: EntityData::Byte(*self.flags.get()),
3306 });
3307 self.flags.clear_dirty();
3308 }
3309 if self.owneruuid.is_dirty() {
3310 values.push(DataValue {
3311 index: 19u8,
3312 serializer_id: 13i32,
3313 value: EntityData::OptionalLivingEntityRef(self.owneruuid.get().clone()),
3314 });
3315 self.owneruuid.clear_dirty();
3316 }
3317 }
3318 #[doc = r" Pack all non-default values (for initial entity spawn)."]
3319 pub fn pack_all(&self) -> Vec<DataValue> {
3320 let mut values = Vec::new();
3321 self.pack_all_into(&mut values);
3322 values
3323 }
3324 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
3325 self.ageable_mob.pack_all_into(values);
3326 if !self.flags.is_default() {
3327 values.push(DataValue {
3328 index: 18u8,
3329 serializer_id: 0i32,
3330 value: EntityData::Byte(*self.flags.get()),
3331 });
3332 }
3333 if !self.owneruuid.is_default() {
3334 values.push(DataValue {
3335 index: 19u8,
3336 serializer_id: 13i32,
3337 value: EntityData::OptionalLivingEntityRef(self.owneruuid.get().clone()),
3338 });
3339 }
3340 }
3341 #[doc = r" Returns `true` if any field has been modified."]
3342 pub fn is_dirty(&self) -> bool {
3343 self.ageable_mob.is_dirty() || self.flags.is_dirty() || self.owneruuid.is_dirty()
3344 }
3345}
3346impl Default for TamableAnimalEntityData {
3347 fn default() -> Self {
3348 Self::new()
3349 }
3350}
3351impl VanillaEntityData for TamableAnimalEntityData {
3352 fn base(&self) -> &BaseEntityData {
3353 TamableAnimalEntityData::base(self)
3354 }
3355 fn base_mut(&mut self) -> &mut BaseEntityData {
3356 TamableAnimalEntityData::base_mut(self)
3357 }
3358 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3359 TamableAnimalEntityData::pack_dirty(self)
3360 }
3361 fn pack_all(&self) -> Vec<DataValue> {
3362 TamableAnimalEntityData::pack_all(self)
3363 }
3364 fn is_dirty(&self) -> bool {
3365 TamableAnimalEntityData::is_dirty(self)
3366 }
3367}
3368impl VanillaLivingEntityData for TamableAnimalEntityData {
3369 fn living_entity(&self) -> &LivingEntityData {
3370 TamableAnimalEntityData::living_entity(self)
3371 }
3372 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
3373 TamableAnimalEntityData::living_entity_mut(self)
3374 }
3375}
3376#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
3377#[derive(Debug, Clone)]
3378pub struct CatEntityData {
3379 pub tamable_animal: TamableAnimalEntityData,
3380 pub variant: SyncedValue<i32>,
3381 pub is_lying: SyncedValue<bool>,
3382 pub relax_state_one: SyncedValue<bool>,
3383 pub collar_color: SyncedValue<i32>,
3384 pub sound_variant: SyncedValue<i32>,
3385}
3386impl CatEntityData {
3387 #[doc = r" Create new entity data with default values."]
3388 pub fn new() -> Self {
3389 Self {
3390 tamable_animal: TamableAnimalEntityData::new(),
3391 variant: SyncedValue::new(1),
3392 is_lying: SyncedValue::new(false),
3393 relax_state_one: SyncedValue::new(false),
3394 collar_color: SyncedValue::new(14i32),
3395 sound_variant: SyncedValue::new(0),
3396 }
3397 }
3398 #[doc = "Returns the `CatEntityData` layer."]
3399 pub fn cat(&self) -> &CatEntityData {
3400 self
3401 }
3402 #[doc = "Returns the mutable `CatEntityData` layer."]
3403 pub fn cat_mut(&mut self) -> &mut CatEntityData {
3404 self
3405 }
3406 #[doc = "Returns the `TamableAnimalEntityData` layer."]
3407 pub fn tamable_animal(&self) -> &TamableAnimalEntityData {
3408 &self.tamable_animal
3409 }
3410 #[doc = "Returns the mutable `TamableAnimalEntityData` layer."]
3411 pub fn tamable_animal_mut(&mut self) -> &mut TamableAnimalEntityData {
3412 &mut self.tamable_animal
3413 }
3414 #[doc = "Returns the `AgeableMobEntityData` layer."]
3415 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
3416 &self.tamable_animal.ageable_mob
3417 }
3418 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
3419 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
3420 &mut self.tamable_animal.ageable_mob
3421 }
3422 #[doc = "Returns the `MobEntityData` layer."]
3423 pub fn mob(&self) -> &MobEntityData {
3424 &self.tamable_animal.ageable_mob.mob
3425 }
3426 #[doc = "Returns the mutable `MobEntityData` layer."]
3427 pub fn mob_mut(&mut self) -> &mut MobEntityData {
3428 &mut self.tamable_animal.ageable_mob.mob
3429 }
3430 #[doc = "Returns the `LivingEntityData` layer."]
3431 pub fn living_entity(&self) -> &LivingEntityData {
3432 &self.tamable_animal.ageable_mob.mob.living_entity
3433 }
3434 #[doc = "Returns the mutable `LivingEntityData` layer."]
3435 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
3436 &mut self.tamable_animal.ageable_mob.mob.living_entity
3437 }
3438 #[doc = "Returns the `BaseEntityData` layer."]
3439 pub fn base(&self) -> &BaseEntityData {
3440 &self.tamable_animal.ageable_mob.mob.living_entity.base
3441 }
3442 #[doc = "Returns the mutable `BaseEntityData` layer."]
3443 pub fn base_mut(&mut self) -> &mut BaseEntityData {
3444 &mut self.tamable_animal.ageable_mob.mob.living_entity.base
3445 }
3446 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
3447 #[doc = r" Returns `None` if no values are dirty."]
3448 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3449 let mut values = Vec::new();
3450 self.pack_dirty_into(&mut values);
3451 if values.is_empty() {
3452 None
3453 } else {
3454 Some(values)
3455 }
3456 }
3457 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
3458 self.tamable_animal.pack_dirty_into(values);
3459 if self.variant.is_dirty() {
3460 values.push(DataValue {
3461 index: 20u8,
3462 serializer_id: 21i32,
3463 value: EntityData::CatVariant(*self.variant.get()),
3464 });
3465 self.variant.clear_dirty();
3466 }
3467 if self.is_lying.is_dirty() {
3468 values.push(DataValue {
3469 index: 21u8,
3470 serializer_id: 8i32,
3471 value: EntityData::Boolean(*self.is_lying.get()),
3472 });
3473 self.is_lying.clear_dirty();
3474 }
3475 if self.relax_state_one.is_dirty() {
3476 values.push(DataValue {
3477 index: 22u8,
3478 serializer_id: 8i32,
3479 value: EntityData::Boolean(*self.relax_state_one.get()),
3480 });
3481 self.relax_state_one.clear_dirty();
3482 }
3483 if self.collar_color.is_dirty() {
3484 values.push(DataValue {
3485 index: 23u8,
3486 serializer_id: 1i32,
3487 value: EntityData::Int(*self.collar_color.get()),
3488 });
3489 self.collar_color.clear_dirty();
3490 }
3491 if self.sound_variant.is_dirty() {
3492 values.push(DataValue {
3493 index: 24u8,
3494 serializer_id: 22i32,
3495 value: EntityData::CatSoundVariant(*self.sound_variant.get()),
3496 });
3497 self.sound_variant.clear_dirty();
3498 }
3499 }
3500 #[doc = r" Pack all non-default values (for initial entity spawn)."]
3501 pub fn pack_all(&self) -> Vec<DataValue> {
3502 let mut values = Vec::new();
3503 self.pack_all_into(&mut values);
3504 values
3505 }
3506 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
3507 self.tamable_animal.pack_all_into(values);
3508 if !self.variant.is_default() {
3509 values.push(DataValue {
3510 index: 20u8,
3511 serializer_id: 21i32,
3512 value: EntityData::CatVariant(*self.variant.get()),
3513 });
3514 }
3515 if !self.is_lying.is_default() {
3516 values.push(DataValue {
3517 index: 21u8,
3518 serializer_id: 8i32,
3519 value: EntityData::Boolean(*self.is_lying.get()),
3520 });
3521 }
3522 if !self.relax_state_one.is_default() {
3523 values.push(DataValue {
3524 index: 22u8,
3525 serializer_id: 8i32,
3526 value: EntityData::Boolean(*self.relax_state_one.get()),
3527 });
3528 }
3529 if !self.collar_color.is_default() {
3530 values.push(DataValue {
3531 index: 23u8,
3532 serializer_id: 1i32,
3533 value: EntityData::Int(*self.collar_color.get()),
3534 });
3535 }
3536 if !self.sound_variant.is_default() {
3537 values.push(DataValue {
3538 index: 24u8,
3539 serializer_id: 22i32,
3540 value: EntityData::CatSoundVariant(*self.sound_variant.get()),
3541 });
3542 }
3543 }
3544 #[doc = r" Returns `true` if any field has been modified."]
3545 pub fn is_dirty(&self) -> bool {
3546 self.tamable_animal.is_dirty()
3547 || self.variant.is_dirty()
3548 || self.is_lying.is_dirty()
3549 || self.relax_state_one.is_dirty()
3550 || self.collar_color.is_dirty()
3551 || self.sound_variant.is_dirty()
3552 }
3553}
3554impl Default for CatEntityData {
3555 fn default() -> Self {
3556 Self::new()
3557 }
3558}
3559impl VanillaEntityData for CatEntityData {
3560 fn base(&self) -> &BaseEntityData {
3561 CatEntityData::base(self)
3562 }
3563 fn base_mut(&mut self) -> &mut BaseEntityData {
3564 CatEntityData::base_mut(self)
3565 }
3566 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3567 CatEntityData::pack_dirty(self)
3568 }
3569 fn pack_all(&self) -> Vec<DataValue> {
3570 CatEntityData::pack_all(self)
3571 }
3572 fn is_dirty(&self) -> bool {
3573 CatEntityData::is_dirty(self)
3574 }
3575}
3576impl VanillaLivingEntityData for CatEntityData {
3577 fn living_entity(&self) -> &LivingEntityData {
3578 CatEntityData::living_entity(self)
3579 }
3580 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
3581 CatEntityData::living_entity_mut(self)
3582 }
3583}
3584#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
3585#[derive(Debug, Clone)]
3586pub struct SpiderEntityData {
3587 pub mob: MobEntityData,
3588 pub flags: SyncedValue<i8>,
3589}
3590impl SpiderEntityData {
3591 #[doc = r" Create new entity data with default values."]
3592 pub fn new() -> Self {
3593 Self {
3594 mob: MobEntityData::new(),
3595 flags: SyncedValue::new(0i8),
3596 }
3597 }
3598 #[doc = "Returns the `SpiderEntityData` layer."]
3599 pub fn spider(&self) -> &SpiderEntityData {
3600 self
3601 }
3602 #[doc = "Returns the mutable `SpiderEntityData` layer."]
3603 pub fn spider_mut(&mut self) -> &mut SpiderEntityData {
3604 self
3605 }
3606 #[doc = "Returns the `MobEntityData` layer."]
3607 pub fn mob(&self) -> &MobEntityData {
3608 &self.mob
3609 }
3610 #[doc = "Returns the mutable `MobEntityData` layer."]
3611 pub fn mob_mut(&mut self) -> &mut MobEntityData {
3612 &mut self.mob
3613 }
3614 #[doc = "Returns the `LivingEntityData` layer."]
3615 pub fn living_entity(&self) -> &LivingEntityData {
3616 &self.mob.living_entity
3617 }
3618 #[doc = "Returns the mutable `LivingEntityData` layer."]
3619 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
3620 &mut self.mob.living_entity
3621 }
3622 #[doc = "Returns the `BaseEntityData` layer."]
3623 pub fn base(&self) -> &BaseEntityData {
3624 &self.mob.living_entity.base
3625 }
3626 #[doc = "Returns the mutable `BaseEntityData` layer."]
3627 pub fn base_mut(&mut self) -> &mut BaseEntityData {
3628 &mut self.mob.living_entity.base
3629 }
3630 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
3631 #[doc = r" Returns `None` if no values are dirty."]
3632 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3633 let mut values = Vec::new();
3634 self.pack_dirty_into(&mut values);
3635 if values.is_empty() {
3636 None
3637 } else {
3638 Some(values)
3639 }
3640 }
3641 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
3642 self.mob.pack_dirty_into(values);
3643 if self.flags.is_dirty() {
3644 values.push(DataValue {
3645 index: 16u8,
3646 serializer_id: 0i32,
3647 value: EntityData::Byte(*self.flags.get()),
3648 });
3649 self.flags.clear_dirty();
3650 }
3651 }
3652 #[doc = r" Pack all non-default values (for initial entity spawn)."]
3653 pub fn pack_all(&self) -> Vec<DataValue> {
3654 let mut values = Vec::new();
3655 self.pack_all_into(&mut values);
3656 values
3657 }
3658 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
3659 self.mob.pack_all_into(values);
3660 if !self.flags.is_default() {
3661 values.push(DataValue {
3662 index: 16u8,
3663 serializer_id: 0i32,
3664 value: EntityData::Byte(*self.flags.get()),
3665 });
3666 }
3667 }
3668 #[doc = r" Returns `true` if any field has been modified."]
3669 pub fn is_dirty(&self) -> bool {
3670 self.mob.is_dirty() || self.flags.is_dirty()
3671 }
3672}
3673impl Default for SpiderEntityData {
3674 fn default() -> Self {
3675 Self::new()
3676 }
3677}
3678impl VanillaEntityData for SpiderEntityData {
3679 fn base(&self) -> &BaseEntityData {
3680 SpiderEntityData::base(self)
3681 }
3682 fn base_mut(&mut self) -> &mut BaseEntityData {
3683 SpiderEntityData::base_mut(self)
3684 }
3685 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3686 SpiderEntityData::pack_dirty(self)
3687 }
3688 fn pack_all(&self) -> Vec<DataValue> {
3689 SpiderEntityData::pack_all(self)
3690 }
3691 fn is_dirty(&self) -> bool {
3692 SpiderEntityData::is_dirty(self)
3693 }
3694}
3695impl VanillaLivingEntityData for SpiderEntityData {
3696 fn living_entity(&self) -> &LivingEntityData {
3697 SpiderEntityData::living_entity(self)
3698 }
3699 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
3700 SpiderEntityData::living_entity_mut(self)
3701 }
3702}
3703#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
3704#[derive(Debug, Clone)]
3705pub struct AbstractMinecartEntityData {
3706 pub vehicle_entity: VehicleEntityData,
3707 pub id_custom_display_block: SyncedValue<Option<BlockStateId>>,
3708 pub id_display_offset: SyncedValue<i32>,
3709}
3710impl AbstractMinecartEntityData {
3711 #[doc = r" Create new entity data with default values."]
3712 pub fn new() -> Self {
3713 Self {
3714 vehicle_entity: VehicleEntityData::new(),
3715 id_custom_display_block: SyncedValue::new(None),
3716 id_display_offset: SyncedValue::new(8i32),
3717 }
3718 }
3719 #[doc = "Returns the `AbstractMinecartEntityData` layer."]
3720 pub fn abstract_minecart(&self) -> &AbstractMinecartEntityData {
3721 self
3722 }
3723 #[doc = "Returns the mutable `AbstractMinecartEntityData` layer."]
3724 pub fn abstract_minecart_mut(&mut self) -> &mut AbstractMinecartEntityData {
3725 self
3726 }
3727 #[doc = "Returns the `VehicleEntityData` layer."]
3728 pub fn vehicle_entity(&self) -> &VehicleEntityData {
3729 &self.vehicle_entity
3730 }
3731 #[doc = "Returns the mutable `VehicleEntityData` layer."]
3732 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
3733 &mut self.vehicle_entity
3734 }
3735 #[doc = "Returns the `BaseEntityData` layer."]
3736 pub fn base(&self) -> &BaseEntityData {
3737 &self.vehicle_entity.base
3738 }
3739 #[doc = "Returns the mutable `BaseEntityData` layer."]
3740 pub fn base_mut(&mut self) -> &mut BaseEntityData {
3741 &mut self.vehicle_entity.base
3742 }
3743 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
3744 #[doc = r" Returns `None` if no values are dirty."]
3745 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3746 let mut values = Vec::new();
3747 self.pack_dirty_into(&mut values);
3748 if values.is_empty() {
3749 None
3750 } else {
3751 Some(values)
3752 }
3753 }
3754 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
3755 self.vehicle_entity.pack_dirty_into(values);
3756 if self.id_custom_display_block.is_dirty() {
3757 values.push(DataValue {
3758 index: 11u8,
3759 serializer_id: 15i32,
3760 value: EntityData::OptionalBlockState(self.id_custom_display_block.get().clone()),
3761 });
3762 self.id_custom_display_block.clear_dirty();
3763 }
3764 if self.id_display_offset.is_dirty() {
3765 values.push(DataValue {
3766 index: 12u8,
3767 serializer_id: 1i32,
3768 value: EntityData::Int(*self.id_display_offset.get()),
3769 });
3770 self.id_display_offset.clear_dirty();
3771 }
3772 }
3773 #[doc = r" Pack all non-default values (for initial entity spawn)."]
3774 pub fn pack_all(&self) -> Vec<DataValue> {
3775 let mut values = Vec::new();
3776 self.pack_all_into(&mut values);
3777 values
3778 }
3779 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
3780 self.vehicle_entity.pack_all_into(values);
3781 if !self.id_custom_display_block.is_default() {
3782 values.push(DataValue {
3783 index: 11u8,
3784 serializer_id: 15i32,
3785 value: EntityData::OptionalBlockState(self.id_custom_display_block.get().clone()),
3786 });
3787 }
3788 if !self.id_display_offset.is_default() {
3789 values.push(DataValue {
3790 index: 12u8,
3791 serializer_id: 1i32,
3792 value: EntityData::Int(*self.id_display_offset.get()),
3793 });
3794 }
3795 }
3796 #[doc = r" Returns `true` if any field has been modified."]
3797 pub fn is_dirty(&self) -> bool {
3798 self.vehicle_entity.is_dirty()
3799 || self.id_custom_display_block.is_dirty()
3800 || self.id_display_offset.is_dirty()
3801 }
3802}
3803impl Default for AbstractMinecartEntityData {
3804 fn default() -> Self {
3805 Self::new()
3806 }
3807}
3808impl VanillaEntityData for AbstractMinecartEntityData {
3809 fn base(&self) -> &BaseEntityData {
3810 AbstractMinecartEntityData::base(self)
3811 }
3812 fn base_mut(&mut self) -> &mut BaseEntityData {
3813 AbstractMinecartEntityData::base_mut(self)
3814 }
3815 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3816 AbstractMinecartEntityData::pack_dirty(self)
3817 }
3818 fn pack_all(&self) -> Vec<DataValue> {
3819 AbstractMinecartEntityData::pack_all(self)
3820 }
3821 fn is_dirty(&self) -> bool {
3822 AbstractMinecartEntityData::is_dirty(self)
3823 }
3824}
3825#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
3826#[derive(Debug, Clone)]
3827pub struct ChickenEntityData {
3828 pub ageable_mob: AgeableMobEntityData,
3829 pub variant: SyncedValue<i32>,
3830 pub sound_variant: SyncedValue<i32>,
3831}
3832impl ChickenEntityData {
3833 #[doc = r" Create new entity data with default values."]
3834 pub fn new() -> Self {
3835 Self {
3836 ageable_mob: AgeableMobEntityData::new(),
3837 variant: SyncedValue::new(0),
3838 sound_variant: SyncedValue::new(0),
3839 }
3840 }
3841 #[doc = "Returns the `ChickenEntityData` layer."]
3842 pub fn chicken(&self) -> &ChickenEntityData {
3843 self
3844 }
3845 #[doc = "Returns the mutable `ChickenEntityData` layer."]
3846 pub fn chicken_mut(&mut self) -> &mut ChickenEntityData {
3847 self
3848 }
3849 #[doc = "Returns the `AgeableMobEntityData` layer."]
3850 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
3851 &self.ageable_mob
3852 }
3853 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
3854 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
3855 &mut self.ageable_mob
3856 }
3857 #[doc = "Returns the `MobEntityData` layer."]
3858 pub fn mob(&self) -> &MobEntityData {
3859 &self.ageable_mob.mob
3860 }
3861 #[doc = "Returns the mutable `MobEntityData` layer."]
3862 pub fn mob_mut(&mut self) -> &mut MobEntityData {
3863 &mut self.ageable_mob.mob
3864 }
3865 #[doc = "Returns the `LivingEntityData` layer."]
3866 pub fn living_entity(&self) -> &LivingEntityData {
3867 &self.ageable_mob.mob.living_entity
3868 }
3869 #[doc = "Returns the mutable `LivingEntityData` layer."]
3870 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
3871 &mut self.ageable_mob.mob.living_entity
3872 }
3873 #[doc = "Returns the `BaseEntityData` layer."]
3874 pub fn base(&self) -> &BaseEntityData {
3875 &self.ageable_mob.mob.living_entity.base
3876 }
3877 #[doc = "Returns the mutable `BaseEntityData` layer."]
3878 pub fn base_mut(&mut self) -> &mut BaseEntityData {
3879 &mut self.ageable_mob.mob.living_entity.base
3880 }
3881 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
3882 #[doc = r" Returns `None` if no values are dirty."]
3883 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3884 let mut values = Vec::new();
3885 self.pack_dirty_into(&mut values);
3886 if values.is_empty() {
3887 None
3888 } else {
3889 Some(values)
3890 }
3891 }
3892 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
3893 self.ageable_mob.pack_dirty_into(values);
3894 if self.variant.is_dirty() {
3895 values.push(DataValue {
3896 index: 18u8,
3897 serializer_id: 30i32,
3898 value: EntityData::ChickenVariant(*self.variant.get()),
3899 });
3900 self.variant.clear_dirty();
3901 }
3902 if self.sound_variant.is_dirty() {
3903 values.push(DataValue {
3904 index: 19u8,
3905 serializer_id: 31i32,
3906 value: EntityData::ChickenSoundVariant(*self.sound_variant.get()),
3907 });
3908 self.sound_variant.clear_dirty();
3909 }
3910 }
3911 #[doc = r" Pack all non-default values (for initial entity spawn)."]
3912 pub fn pack_all(&self) -> Vec<DataValue> {
3913 let mut values = Vec::new();
3914 self.pack_all_into(&mut values);
3915 values
3916 }
3917 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
3918 self.ageable_mob.pack_all_into(values);
3919 if !self.variant.is_default() {
3920 values.push(DataValue {
3921 index: 18u8,
3922 serializer_id: 30i32,
3923 value: EntityData::ChickenVariant(*self.variant.get()),
3924 });
3925 }
3926 if !self.sound_variant.is_default() {
3927 values.push(DataValue {
3928 index: 19u8,
3929 serializer_id: 31i32,
3930 value: EntityData::ChickenSoundVariant(*self.sound_variant.get()),
3931 });
3932 }
3933 }
3934 #[doc = r" Returns `true` if any field has been modified."]
3935 pub fn is_dirty(&self) -> bool {
3936 self.ageable_mob.is_dirty() || self.variant.is_dirty() || self.sound_variant.is_dirty()
3937 }
3938}
3939impl Default for ChickenEntityData {
3940 fn default() -> Self {
3941 Self::new()
3942 }
3943}
3944impl VanillaEntityData for ChickenEntityData {
3945 fn base(&self) -> &BaseEntityData {
3946 ChickenEntityData::base(self)
3947 }
3948 fn base_mut(&mut self) -> &mut BaseEntityData {
3949 ChickenEntityData::base_mut(self)
3950 }
3951 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
3952 ChickenEntityData::pack_dirty(self)
3953 }
3954 fn pack_all(&self) -> Vec<DataValue> {
3955 ChickenEntityData::pack_all(self)
3956 }
3957 fn is_dirty(&self) -> bool {
3958 ChickenEntityData::is_dirty(self)
3959 }
3960}
3961impl VanillaLivingEntityData for ChickenEntityData {
3962 fn living_entity(&self) -> &LivingEntityData {
3963 ChickenEntityData::living_entity(self)
3964 }
3965 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
3966 ChickenEntityData::living_entity_mut(self)
3967 }
3968}
3969#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
3970#[derive(Debug, Clone)]
3971pub struct AbstractFishEntityData {
3972 pub mob: MobEntityData,
3973 pub from_bucket: SyncedValue<bool>,
3974}
3975impl AbstractFishEntityData {
3976 #[doc = r" Create new entity data with default values."]
3977 pub fn new() -> Self {
3978 Self {
3979 mob: MobEntityData::new(),
3980 from_bucket: SyncedValue::new(false),
3981 }
3982 }
3983 #[doc = "Returns the `AbstractFishEntityData` layer."]
3984 pub fn abstract_fish(&self) -> &AbstractFishEntityData {
3985 self
3986 }
3987 #[doc = "Returns the mutable `AbstractFishEntityData` layer."]
3988 pub fn abstract_fish_mut(&mut self) -> &mut AbstractFishEntityData {
3989 self
3990 }
3991 #[doc = "Returns the `MobEntityData` layer."]
3992 pub fn mob(&self) -> &MobEntityData {
3993 &self.mob
3994 }
3995 #[doc = "Returns the mutable `MobEntityData` layer."]
3996 pub fn mob_mut(&mut self) -> &mut MobEntityData {
3997 &mut self.mob
3998 }
3999 #[doc = "Returns the `LivingEntityData` layer."]
4000 pub fn living_entity(&self) -> &LivingEntityData {
4001 &self.mob.living_entity
4002 }
4003 #[doc = "Returns the mutable `LivingEntityData` layer."]
4004 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4005 &mut self.mob.living_entity
4006 }
4007 #[doc = "Returns the `BaseEntityData` layer."]
4008 pub fn base(&self) -> &BaseEntityData {
4009 &self.mob.living_entity.base
4010 }
4011 #[doc = "Returns the mutable `BaseEntityData` layer."]
4012 pub fn base_mut(&mut self) -> &mut BaseEntityData {
4013 &mut self.mob.living_entity.base
4014 }
4015 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
4016 #[doc = r" Returns `None` if no values are dirty."]
4017 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4018 let mut values = Vec::new();
4019 self.pack_dirty_into(&mut values);
4020 if values.is_empty() {
4021 None
4022 } else {
4023 Some(values)
4024 }
4025 }
4026 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
4027 self.mob.pack_dirty_into(values);
4028 if self.from_bucket.is_dirty() {
4029 values.push(DataValue {
4030 index: 16u8,
4031 serializer_id: 8i32,
4032 value: EntityData::Boolean(*self.from_bucket.get()),
4033 });
4034 self.from_bucket.clear_dirty();
4035 }
4036 }
4037 #[doc = r" Pack all non-default values (for initial entity spawn)."]
4038 pub fn pack_all(&self) -> Vec<DataValue> {
4039 let mut values = Vec::new();
4040 self.pack_all_into(&mut values);
4041 values
4042 }
4043 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
4044 self.mob.pack_all_into(values);
4045 if !self.from_bucket.is_default() {
4046 values.push(DataValue {
4047 index: 16u8,
4048 serializer_id: 8i32,
4049 value: EntityData::Boolean(*self.from_bucket.get()),
4050 });
4051 }
4052 }
4053 #[doc = r" Returns `true` if any field has been modified."]
4054 pub fn is_dirty(&self) -> bool {
4055 self.mob.is_dirty() || self.from_bucket.is_dirty()
4056 }
4057}
4058impl Default for AbstractFishEntityData {
4059 fn default() -> Self {
4060 Self::new()
4061 }
4062}
4063impl VanillaEntityData for AbstractFishEntityData {
4064 fn base(&self) -> &BaseEntityData {
4065 AbstractFishEntityData::base(self)
4066 }
4067 fn base_mut(&mut self) -> &mut BaseEntityData {
4068 AbstractFishEntityData::base_mut(self)
4069 }
4070 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4071 AbstractFishEntityData::pack_dirty(self)
4072 }
4073 fn pack_all(&self) -> Vec<DataValue> {
4074 AbstractFishEntityData::pack_all(self)
4075 }
4076 fn is_dirty(&self) -> bool {
4077 AbstractFishEntityData::is_dirty(self)
4078 }
4079}
4080impl VanillaLivingEntityData for AbstractFishEntityData {
4081 fn living_entity(&self) -> &LivingEntityData {
4082 AbstractFishEntityData::living_entity(self)
4083 }
4084 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4085 AbstractFishEntityData::living_entity_mut(self)
4086 }
4087}
4088#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
4089#[derive(Debug, Clone)]
4090pub struct CopperGolemEntityData {
4091 pub mob: MobEntityData,
4092 pub weather_state: SyncedValue<i32>,
4093 pub copper_golem_state: SyncedValue<i32>,
4094}
4095impl CopperGolemEntityData {
4096 #[doc = r" Create new entity data with default values."]
4097 pub fn new() -> Self {
4098 Self {
4099 mob: MobEntityData::new(),
4100 weather_state: SyncedValue::new(0i32),
4101 copper_golem_state: SyncedValue::new(0i32),
4102 }
4103 }
4104 #[doc = "Returns the `CopperGolemEntityData` layer."]
4105 pub fn copper_golem(&self) -> &CopperGolemEntityData {
4106 self
4107 }
4108 #[doc = "Returns the mutable `CopperGolemEntityData` layer."]
4109 pub fn copper_golem_mut(&mut self) -> &mut CopperGolemEntityData {
4110 self
4111 }
4112 #[doc = "Returns the `MobEntityData` layer."]
4113 pub fn mob(&self) -> &MobEntityData {
4114 &self.mob
4115 }
4116 #[doc = "Returns the mutable `MobEntityData` layer."]
4117 pub fn mob_mut(&mut self) -> &mut MobEntityData {
4118 &mut self.mob
4119 }
4120 #[doc = "Returns the `LivingEntityData` layer."]
4121 pub fn living_entity(&self) -> &LivingEntityData {
4122 &self.mob.living_entity
4123 }
4124 #[doc = "Returns the mutable `LivingEntityData` layer."]
4125 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4126 &mut self.mob.living_entity
4127 }
4128 #[doc = "Returns the `BaseEntityData` layer."]
4129 pub fn base(&self) -> &BaseEntityData {
4130 &self.mob.living_entity.base
4131 }
4132 #[doc = "Returns the mutable `BaseEntityData` layer."]
4133 pub fn base_mut(&mut self) -> &mut BaseEntityData {
4134 &mut self.mob.living_entity.base
4135 }
4136 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
4137 #[doc = r" Returns `None` if no values are dirty."]
4138 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4139 let mut values = Vec::new();
4140 self.pack_dirty_into(&mut values);
4141 if values.is_empty() {
4142 None
4143 } else {
4144 Some(values)
4145 }
4146 }
4147 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
4148 self.mob.pack_dirty_into(values);
4149 if self.weather_state.is_dirty() {
4150 values.push(DataValue {
4151 index: 16u8,
4152 serializer_id: 38i32,
4153 value: EntityData::WeatheringCopperState(*self.weather_state.get()),
4154 });
4155 self.weather_state.clear_dirty();
4156 }
4157 if self.copper_golem_state.is_dirty() {
4158 values.push(DataValue {
4159 index: 17u8,
4160 serializer_id: 37i32,
4161 value: EntityData::CopperGolemState(*self.copper_golem_state.get()),
4162 });
4163 self.copper_golem_state.clear_dirty();
4164 }
4165 }
4166 #[doc = r" Pack all non-default values (for initial entity spawn)."]
4167 pub fn pack_all(&self) -> Vec<DataValue> {
4168 let mut values = Vec::new();
4169 self.pack_all_into(&mut values);
4170 values
4171 }
4172 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
4173 self.mob.pack_all_into(values);
4174 if !self.weather_state.is_default() {
4175 values.push(DataValue {
4176 index: 16u8,
4177 serializer_id: 38i32,
4178 value: EntityData::WeatheringCopperState(*self.weather_state.get()),
4179 });
4180 }
4181 if !self.copper_golem_state.is_default() {
4182 values.push(DataValue {
4183 index: 17u8,
4184 serializer_id: 37i32,
4185 value: EntityData::CopperGolemState(*self.copper_golem_state.get()),
4186 });
4187 }
4188 }
4189 #[doc = r" Returns `true` if any field has been modified."]
4190 pub fn is_dirty(&self) -> bool {
4191 self.mob.is_dirty() || self.weather_state.is_dirty() || self.copper_golem_state.is_dirty()
4192 }
4193}
4194impl Default for CopperGolemEntityData {
4195 fn default() -> Self {
4196 Self::new()
4197 }
4198}
4199impl VanillaEntityData for CopperGolemEntityData {
4200 fn base(&self) -> &BaseEntityData {
4201 CopperGolemEntityData::base(self)
4202 }
4203 fn base_mut(&mut self) -> &mut BaseEntityData {
4204 CopperGolemEntityData::base_mut(self)
4205 }
4206 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4207 CopperGolemEntityData::pack_dirty(self)
4208 }
4209 fn pack_all(&self) -> Vec<DataValue> {
4210 CopperGolemEntityData::pack_all(self)
4211 }
4212 fn is_dirty(&self) -> bool {
4213 CopperGolemEntityData::is_dirty(self)
4214 }
4215}
4216impl VanillaLivingEntityData for CopperGolemEntityData {
4217 fn living_entity(&self) -> &LivingEntityData {
4218 CopperGolemEntityData::living_entity(self)
4219 }
4220 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4221 CopperGolemEntityData::living_entity_mut(self)
4222 }
4223}
4224#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
4225#[derive(Debug, Clone)]
4226pub struct MinecartCommandBlockEntityData {
4227 pub abstract_minecart: AbstractMinecartEntityData,
4228 pub id_command_name: SyncedValue<String>,
4229 pub id_last_output: SyncedValue<Box<TextComponent>>,
4230}
4231impl MinecartCommandBlockEntityData {
4232 #[doc = r" Create new entity data with default values."]
4233 pub fn new() -> Self {
4234 Self {
4235 abstract_minecart: AbstractMinecartEntityData::new(),
4236 id_command_name: SyncedValue::new("".to_string()),
4237 id_last_output: SyncedValue::new(Box::new(TextComponent::default())),
4238 }
4239 }
4240 #[doc = "Returns the `MinecartCommandBlockEntityData` layer."]
4241 pub fn minecart_command_block(&self) -> &MinecartCommandBlockEntityData {
4242 self
4243 }
4244 #[doc = "Returns the mutable `MinecartCommandBlockEntityData` layer."]
4245 pub fn minecart_command_block_mut(&mut self) -> &mut MinecartCommandBlockEntityData {
4246 self
4247 }
4248 #[doc = "Returns the `AbstractMinecartEntityData` layer."]
4249 pub fn abstract_minecart(&self) -> &AbstractMinecartEntityData {
4250 &self.abstract_minecart
4251 }
4252 #[doc = "Returns the mutable `AbstractMinecartEntityData` layer."]
4253 pub fn abstract_minecart_mut(&mut self) -> &mut AbstractMinecartEntityData {
4254 &mut self.abstract_minecart
4255 }
4256 #[doc = "Returns the `VehicleEntityData` layer."]
4257 pub fn vehicle_entity(&self) -> &VehicleEntityData {
4258 &self.abstract_minecart.vehicle_entity
4259 }
4260 #[doc = "Returns the mutable `VehicleEntityData` layer."]
4261 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
4262 &mut self.abstract_minecart.vehicle_entity
4263 }
4264 #[doc = "Returns the `BaseEntityData` layer."]
4265 pub fn base(&self) -> &BaseEntityData {
4266 &self.abstract_minecart.vehicle_entity.base
4267 }
4268 #[doc = "Returns the mutable `BaseEntityData` layer."]
4269 pub fn base_mut(&mut self) -> &mut BaseEntityData {
4270 &mut self.abstract_minecart.vehicle_entity.base
4271 }
4272 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
4273 #[doc = r" Returns `None` if no values are dirty."]
4274 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4275 let mut values = Vec::new();
4276 self.pack_dirty_into(&mut values);
4277 if values.is_empty() {
4278 None
4279 } else {
4280 Some(values)
4281 }
4282 }
4283 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
4284 self.abstract_minecart.pack_dirty_into(values);
4285 if self.id_command_name.is_dirty() {
4286 values.push(DataValue {
4287 index: 13u8,
4288 serializer_id: 4i32,
4289 value: EntityData::String(self.id_command_name.get().clone()),
4290 });
4291 self.id_command_name.clear_dirty();
4292 }
4293 if self.id_last_output.is_dirty() {
4294 values.push(DataValue {
4295 index: 14u8,
4296 serializer_id: 5i32,
4297 value: EntityData::Component(self.id_last_output.get().clone()),
4298 });
4299 self.id_last_output.clear_dirty();
4300 }
4301 }
4302 #[doc = r" Pack all non-default values (for initial entity spawn)."]
4303 pub fn pack_all(&self) -> Vec<DataValue> {
4304 let mut values = Vec::new();
4305 self.pack_all_into(&mut values);
4306 values
4307 }
4308 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
4309 self.abstract_minecart.pack_all_into(values);
4310 if !self.id_command_name.is_default() {
4311 values.push(DataValue {
4312 index: 13u8,
4313 serializer_id: 4i32,
4314 value: EntityData::String(self.id_command_name.get().clone()),
4315 });
4316 }
4317 if !self.id_last_output.is_default() {
4318 values.push(DataValue {
4319 index: 14u8,
4320 serializer_id: 5i32,
4321 value: EntityData::Component(self.id_last_output.get().clone()),
4322 });
4323 }
4324 }
4325 #[doc = r" Returns `true` if any field has been modified."]
4326 pub fn is_dirty(&self) -> bool {
4327 self.abstract_minecart.is_dirty()
4328 || self.id_command_name.is_dirty()
4329 || self.id_last_output.is_dirty()
4330 }
4331}
4332impl Default for MinecartCommandBlockEntityData {
4333 fn default() -> Self {
4334 Self::new()
4335 }
4336}
4337impl VanillaEntityData for MinecartCommandBlockEntityData {
4338 fn base(&self) -> &BaseEntityData {
4339 MinecartCommandBlockEntityData::base(self)
4340 }
4341 fn base_mut(&mut self) -> &mut BaseEntityData {
4342 MinecartCommandBlockEntityData::base_mut(self)
4343 }
4344 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4345 MinecartCommandBlockEntityData::pack_dirty(self)
4346 }
4347 fn pack_all(&self) -> Vec<DataValue> {
4348 MinecartCommandBlockEntityData::pack_all(self)
4349 }
4350 fn is_dirty(&self) -> bool {
4351 MinecartCommandBlockEntityData::is_dirty(self)
4352 }
4353}
4354#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
4355#[derive(Debug, Clone)]
4356pub struct CowEntityData {
4357 pub ageable_mob: AgeableMobEntityData,
4358 pub variant: SyncedValue<i32>,
4359 pub sound_variant: SyncedValue<i32>,
4360}
4361impl CowEntityData {
4362 #[doc = r" Create new entity data with default values."]
4363 pub fn new() -> Self {
4364 Self {
4365 ageable_mob: AgeableMobEntityData::new(),
4366 variant: SyncedValue::new(0),
4367 sound_variant: SyncedValue::new(0),
4368 }
4369 }
4370 #[doc = "Returns the `CowEntityData` layer."]
4371 pub fn cow(&self) -> &CowEntityData {
4372 self
4373 }
4374 #[doc = "Returns the mutable `CowEntityData` layer."]
4375 pub fn cow_mut(&mut self) -> &mut CowEntityData {
4376 self
4377 }
4378 #[doc = "Returns the `AgeableMobEntityData` layer."]
4379 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
4380 &self.ageable_mob
4381 }
4382 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
4383 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
4384 &mut self.ageable_mob
4385 }
4386 #[doc = "Returns the `MobEntityData` layer."]
4387 pub fn mob(&self) -> &MobEntityData {
4388 &self.ageable_mob.mob
4389 }
4390 #[doc = "Returns the mutable `MobEntityData` layer."]
4391 pub fn mob_mut(&mut self) -> &mut MobEntityData {
4392 &mut self.ageable_mob.mob
4393 }
4394 #[doc = "Returns the `LivingEntityData` layer."]
4395 pub fn living_entity(&self) -> &LivingEntityData {
4396 &self.ageable_mob.mob.living_entity
4397 }
4398 #[doc = "Returns the mutable `LivingEntityData` layer."]
4399 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4400 &mut self.ageable_mob.mob.living_entity
4401 }
4402 #[doc = "Returns the `BaseEntityData` layer."]
4403 pub fn base(&self) -> &BaseEntityData {
4404 &self.ageable_mob.mob.living_entity.base
4405 }
4406 #[doc = "Returns the mutable `BaseEntityData` layer."]
4407 pub fn base_mut(&mut self) -> &mut BaseEntityData {
4408 &mut self.ageable_mob.mob.living_entity.base
4409 }
4410 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
4411 #[doc = r" Returns `None` if no values are dirty."]
4412 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4413 let mut values = Vec::new();
4414 self.pack_dirty_into(&mut values);
4415 if values.is_empty() {
4416 None
4417 } else {
4418 Some(values)
4419 }
4420 }
4421 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
4422 self.ageable_mob.pack_dirty_into(values);
4423 if self.variant.is_dirty() {
4424 values.push(DataValue {
4425 index: 18u8,
4426 serializer_id: 23i32,
4427 value: EntityData::CowVariant(*self.variant.get()),
4428 });
4429 self.variant.clear_dirty();
4430 }
4431 if self.sound_variant.is_dirty() {
4432 values.push(DataValue {
4433 index: 19u8,
4434 serializer_id: 24i32,
4435 value: EntityData::CowSoundVariant(*self.sound_variant.get()),
4436 });
4437 self.sound_variant.clear_dirty();
4438 }
4439 }
4440 #[doc = r" Pack all non-default values (for initial entity spawn)."]
4441 pub fn pack_all(&self) -> Vec<DataValue> {
4442 let mut values = Vec::new();
4443 self.pack_all_into(&mut values);
4444 values
4445 }
4446 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
4447 self.ageable_mob.pack_all_into(values);
4448 if !self.variant.is_default() {
4449 values.push(DataValue {
4450 index: 18u8,
4451 serializer_id: 23i32,
4452 value: EntityData::CowVariant(*self.variant.get()),
4453 });
4454 }
4455 if !self.sound_variant.is_default() {
4456 values.push(DataValue {
4457 index: 19u8,
4458 serializer_id: 24i32,
4459 value: EntityData::CowSoundVariant(*self.sound_variant.get()),
4460 });
4461 }
4462 }
4463 #[doc = r" Returns `true` if any field has been modified."]
4464 pub fn is_dirty(&self) -> bool {
4465 self.ageable_mob.is_dirty() || self.variant.is_dirty() || self.sound_variant.is_dirty()
4466 }
4467}
4468impl Default for CowEntityData {
4469 fn default() -> Self {
4470 Self::new()
4471 }
4472}
4473impl VanillaEntityData for CowEntityData {
4474 fn base(&self) -> &BaseEntityData {
4475 CowEntityData::base(self)
4476 }
4477 fn base_mut(&mut self) -> &mut BaseEntityData {
4478 CowEntityData::base_mut(self)
4479 }
4480 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4481 CowEntityData::pack_dirty(self)
4482 }
4483 fn pack_all(&self) -> Vec<DataValue> {
4484 CowEntityData::pack_all(self)
4485 }
4486 fn is_dirty(&self) -> bool {
4487 CowEntityData::is_dirty(self)
4488 }
4489}
4490impl VanillaLivingEntityData for CowEntityData {
4491 fn living_entity(&self) -> &LivingEntityData {
4492 CowEntityData::living_entity(self)
4493 }
4494 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4495 CowEntityData::living_entity_mut(self)
4496 }
4497}
4498#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
4499#[derive(Debug, Clone)]
4500pub struct CreakingEntityData {
4501 pub mob: MobEntityData,
4502 pub can_move: SyncedValue<bool>,
4503 pub is_active: SyncedValue<bool>,
4504 pub is_tearing_down: SyncedValue<bool>,
4505 pub home_pos: SyncedValue<Option<BlockPos>>,
4506}
4507impl CreakingEntityData {
4508 #[doc = r" Create new entity data with default values."]
4509 pub fn new() -> Self {
4510 Self {
4511 mob: MobEntityData::new(),
4512 can_move: SyncedValue::new(true),
4513 is_active: SyncedValue::new(false),
4514 is_tearing_down: SyncedValue::new(false),
4515 home_pos: SyncedValue::new(None),
4516 }
4517 }
4518 #[doc = "Returns the `CreakingEntityData` layer."]
4519 pub fn creaking(&self) -> &CreakingEntityData {
4520 self
4521 }
4522 #[doc = "Returns the mutable `CreakingEntityData` layer."]
4523 pub fn creaking_mut(&mut self) -> &mut CreakingEntityData {
4524 self
4525 }
4526 #[doc = "Returns the `MobEntityData` layer."]
4527 pub fn mob(&self) -> &MobEntityData {
4528 &self.mob
4529 }
4530 #[doc = "Returns the mutable `MobEntityData` layer."]
4531 pub fn mob_mut(&mut self) -> &mut MobEntityData {
4532 &mut self.mob
4533 }
4534 #[doc = "Returns the `LivingEntityData` layer."]
4535 pub fn living_entity(&self) -> &LivingEntityData {
4536 &self.mob.living_entity
4537 }
4538 #[doc = "Returns the mutable `LivingEntityData` layer."]
4539 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4540 &mut self.mob.living_entity
4541 }
4542 #[doc = "Returns the `BaseEntityData` layer."]
4543 pub fn base(&self) -> &BaseEntityData {
4544 &self.mob.living_entity.base
4545 }
4546 #[doc = "Returns the mutable `BaseEntityData` layer."]
4547 pub fn base_mut(&mut self) -> &mut BaseEntityData {
4548 &mut self.mob.living_entity.base
4549 }
4550 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
4551 #[doc = r" Returns `None` if no values are dirty."]
4552 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4553 let mut values = Vec::new();
4554 self.pack_dirty_into(&mut values);
4555 if values.is_empty() {
4556 None
4557 } else {
4558 Some(values)
4559 }
4560 }
4561 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
4562 self.mob.pack_dirty_into(values);
4563 if self.can_move.is_dirty() {
4564 values.push(DataValue {
4565 index: 16u8,
4566 serializer_id: 8i32,
4567 value: EntityData::Boolean(*self.can_move.get()),
4568 });
4569 self.can_move.clear_dirty();
4570 }
4571 if self.is_active.is_dirty() {
4572 values.push(DataValue {
4573 index: 17u8,
4574 serializer_id: 8i32,
4575 value: EntityData::Boolean(*self.is_active.get()),
4576 });
4577 self.is_active.clear_dirty();
4578 }
4579 if self.is_tearing_down.is_dirty() {
4580 values.push(DataValue {
4581 index: 18u8,
4582 serializer_id: 8i32,
4583 value: EntityData::Boolean(*self.is_tearing_down.get()),
4584 });
4585 self.is_tearing_down.clear_dirty();
4586 }
4587 if self.home_pos.is_dirty() {
4588 values.push(DataValue {
4589 index: 19u8,
4590 serializer_id: 11i32,
4591 value: EntityData::OptionalBlockPos(self.home_pos.get().clone()),
4592 });
4593 self.home_pos.clear_dirty();
4594 }
4595 }
4596 #[doc = r" Pack all non-default values (for initial entity spawn)."]
4597 pub fn pack_all(&self) -> Vec<DataValue> {
4598 let mut values = Vec::new();
4599 self.pack_all_into(&mut values);
4600 values
4601 }
4602 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
4603 self.mob.pack_all_into(values);
4604 if !self.can_move.is_default() {
4605 values.push(DataValue {
4606 index: 16u8,
4607 serializer_id: 8i32,
4608 value: EntityData::Boolean(*self.can_move.get()),
4609 });
4610 }
4611 if !self.is_active.is_default() {
4612 values.push(DataValue {
4613 index: 17u8,
4614 serializer_id: 8i32,
4615 value: EntityData::Boolean(*self.is_active.get()),
4616 });
4617 }
4618 if !self.is_tearing_down.is_default() {
4619 values.push(DataValue {
4620 index: 18u8,
4621 serializer_id: 8i32,
4622 value: EntityData::Boolean(*self.is_tearing_down.get()),
4623 });
4624 }
4625 if !self.home_pos.is_default() {
4626 values.push(DataValue {
4627 index: 19u8,
4628 serializer_id: 11i32,
4629 value: EntityData::OptionalBlockPos(self.home_pos.get().clone()),
4630 });
4631 }
4632 }
4633 #[doc = r" Returns `true` if any field has been modified."]
4634 pub fn is_dirty(&self) -> bool {
4635 self.mob.is_dirty()
4636 || self.can_move.is_dirty()
4637 || self.is_active.is_dirty()
4638 || self.is_tearing_down.is_dirty()
4639 || self.home_pos.is_dirty()
4640 }
4641}
4642impl Default for CreakingEntityData {
4643 fn default() -> Self {
4644 Self::new()
4645 }
4646}
4647impl VanillaEntityData for CreakingEntityData {
4648 fn base(&self) -> &BaseEntityData {
4649 CreakingEntityData::base(self)
4650 }
4651 fn base_mut(&mut self) -> &mut BaseEntityData {
4652 CreakingEntityData::base_mut(self)
4653 }
4654 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4655 CreakingEntityData::pack_dirty(self)
4656 }
4657 fn pack_all(&self) -> Vec<DataValue> {
4658 CreakingEntityData::pack_all(self)
4659 }
4660 fn is_dirty(&self) -> bool {
4661 CreakingEntityData::is_dirty(self)
4662 }
4663}
4664impl VanillaLivingEntityData for CreakingEntityData {
4665 fn living_entity(&self) -> &LivingEntityData {
4666 CreakingEntityData::living_entity(self)
4667 }
4668 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4669 CreakingEntityData::living_entity_mut(self)
4670 }
4671}
4672#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
4673#[derive(Debug, Clone)]
4674pub struct CreeperEntityData {
4675 pub mob: MobEntityData,
4676 pub swell_dir: SyncedValue<i32>,
4677 pub is_powered: SyncedValue<bool>,
4678 pub is_ignited: SyncedValue<bool>,
4679}
4680impl CreeperEntityData {
4681 #[doc = r" Create new entity data with default values."]
4682 pub fn new() -> Self {
4683 Self {
4684 mob: MobEntityData::new(),
4685 swell_dir: SyncedValue::new(-1i32),
4686 is_powered: SyncedValue::new(false),
4687 is_ignited: SyncedValue::new(false),
4688 }
4689 }
4690 #[doc = "Returns the `CreeperEntityData` layer."]
4691 pub fn creeper(&self) -> &CreeperEntityData {
4692 self
4693 }
4694 #[doc = "Returns the mutable `CreeperEntityData` layer."]
4695 pub fn creeper_mut(&mut self) -> &mut CreeperEntityData {
4696 self
4697 }
4698 #[doc = "Returns the `MobEntityData` layer."]
4699 pub fn mob(&self) -> &MobEntityData {
4700 &self.mob
4701 }
4702 #[doc = "Returns the mutable `MobEntityData` layer."]
4703 pub fn mob_mut(&mut self) -> &mut MobEntityData {
4704 &mut self.mob
4705 }
4706 #[doc = "Returns the `LivingEntityData` layer."]
4707 pub fn living_entity(&self) -> &LivingEntityData {
4708 &self.mob.living_entity
4709 }
4710 #[doc = "Returns the mutable `LivingEntityData` layer."]
4711 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4712 &mut self.mob.living_entity
4713 }
4714 #[doc = "Returns the `BaseEntityData` layer."]
4715 pub fn base(&self) -> &BaseEntityData {
4716 &self.mob.living_entity.base
4717 }
4718 #[doc = "Returns the mutable `BaseEntityData` layer."]
4719 pub fn base_mut(&mut self) -> &mut BaseEntityData {
4720 &mut self.mob.living_entity.base
4721 }
4722 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
4723 #[doc = r" Returns `None` if no values are dirty."]
4724 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4725 let mut values = Vec::new();
4726 self.pack_dirty_into(&mut values);
4727 if values.is_empty() {
4728 None
4729 } else {
4730 Some(values)
4731 }
4732 }
4733 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
4734 self.mob.pack_dirty_into(values);
4735 if self.swell_dir.is_dirty() {
4736 values.push(DataValue {
4737 index: 16u8,
4738 serializer_id: 1i32,
4739 value: EntityData::Int(*self.swell_dir.get()),
4740 });
4741 self.swell_dir.clear_dirty();
4742 }
4743 if self.is_powered.is_dirty() {
4744 values.push(DataValue {
4745 index: 17u8,
4746 serializer_id: 8i32,
4747 value: EntityData::Boolean(*self.is_powered.get()),
4748 });
4749 self.is_powered.clear_dirty();
4750 }
4751 if self.is_ignited.is_dirty() {
4752 values.push(DataValue {
4753 index: 18u8,
4754 serializer_id: 8i32,
4755 value: EntityData::Boolean(*self.is_ignited.get()),
4756 });
4757 self.is_ignited.clear_dirty();
4758 }
4759 }
4760 #[doc = r" Pack all non-default values (for initial entity spawn)."]
4761 pub fn pack_all(&self) -> Vec<DataValue> {
4762 let mut values = Vec::new();
4763 self.pack_all_into(&mut values);
4764 values
4765 }
4766 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
4767 self.mob.pack_all_into(values);
4768 if !self.swell_dir.is_default() {
4769 values.push(DataValue {
4770 index: 16u8,
4771 serializer_id: 1i32,
4772 value: EntityData::Int(*self.swell_dir.get()),
4773 });
4774 }
4775 if !self.is_powered.is_default() {
4776 values.push(DataValue {
4777 index: 17u8,
4778 serializer_id: 8i32,
4779 value: EntityData::Boolean(*self.is_powered.get()),
4780 });
4781 }
4782 if !self.is_ignited.is_default() {
4783 values.push(DataValue {
4784 index: 18u8,
4785 serializer_id: 8i32,
4786 value: EntityData::Boolean(*self.is_ignited.get()),
4787 });
4788 }
4789 }
4790 #[doc = r" Returns `true` if any field has been modified."]
4791 pub fn is_dirty(&self) -> bool {
4792 self.mob.is_dirty()
4793 || self.swell_dir.is_dirty()
4794 || self.is_powered.is_dirty()
4795 || self.is_ignited.is_dirty()
4796 }
4797}
4798impl Default for CreeperEntityData {
4799 fn default() -> Self {
4800 Self::new()
4801 }
4802}
4803impl VanillaEntityData for CreeperEntityData {
4804 fn base(&self) -> &BaseEntityData {
4805 CreeperEntityData::base(self)
4806 }
4807 fn base_mut(&mut self) -> &mut BaseEntityData {
4808 CreeperEntityData::base_mut(self)
4809 }
4810 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4811 CreeperEntityData::pack_dirty(self)
4812 }
4813 fn pack_all(&self) -> Vec<DataValue> {
4814 CreeperEntityData::pack_all(self)
4815 }
4816 fn is_dirty(&self) -> bool {
4817 CreeperEntityData::is_dirty(self)
4818 }
4819}
4820impl VanillaLivingEntityData for CreeperEntityData {
4821 fn living_entity(&self) -> &LivingEntityData {
4822 CreeperEntityData::living_entity(self)
4823 }
4824 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4825 CreeperEntityData::living_entity_mut(self)
4826 }
4827}
4828#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
4829#[derive(Debug, Clone)]
4830pub struct DolphinEntityData {
4831 pub ageable_mob: AgeableMobEntityData,
4832 pub got_fish: SyncedValue<bool>,
4833 pub moistness_level: SyncedValue<i32>,
4834}
4835impl DolphinEntityData {
4836 #[doc = r" Create new entity data with default values."]
4837 pub fn new() -> Self {
4838 let mut data = Self {
4839 ageable_mob: AgeableMobEntityData::new(),
4840 got_fish: SyncedValue::new(false),
4841 moistness_level: SyncedValue::new(2400i32),
4842 };
4843 data.ageable_mob.mob.living_entity.base.air_supply = SyncedValue::new(4800i32);
4844 data
4845 }
4846 #[doc = "Returns the `DolphinEntityData` layer."]
4847 pub fn dolphin(&self) -> &DolphinEntityData {
4848 self
4849 }
4850 #[doc = "Returns the mutable `DolphinEntityData` layer."]
4851 pub fn dolphin_mut(&mut self) -> &mut DolphinEntityData {
4852 self
4853 }
4854 #[doc = "Returns the `AgeableMobEntityData` layer."]
4855 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
4856 &self.ageable_mob
4857 }
4858 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
4859 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
4860 &mut self.ageable_mob
4861 }
4862 #[doc = "Returns the `MobEntityData` layer."]
4863 pub fn mob(&self) -> &MobEntityData {
4864 &self.ageable_mob.mob
4865 }
4866 #[doc = "Returns the mutable `MobEntityData` layer."]
4867 pub fn mob_mut(&mut self) -> &mut MobEntityData {
4868 &mut self.ageable_mob.mob
4869 }
4870 #[doc = "Returns the `LivingEntityData` layer."]
4871 pub fn living_entity(&self) -> &LivingEntityData {
4872 &self.ageable_mob.mob.living_entity
4873 }
4874 #[doc = "Returns the mutable `LivingEntityData` layer."]
4875 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4876 &mut self.ageable_mob.mob.living_entity
4877 }
4878 #[doc = "Returns the `BaseEntityData` layer."]
4879 pub fn base(&self) -> &BaseEntityData {
4880 &self.ageable_mob.mob.living_entity.base
4881 }
4882 #[doc = "Returns the mutable `BaseEntityData` layer."]
4883 pub fn base_mut(&mut self) -> &mut BaseEntityData {
4884 &mut self.ageable_mob.mob.living_entity.base
4885 }
4886 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
4887 #[doc = r" Returns `None` if no values are dirty."]
4888 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4889 let mut values = Vec::new();
4890 self.pack_dirty_into(&mut values);
4891 if values.is_empty() {
4892 None
4893 } else {
4894 Some(values)
4895 }
4896 }
4897 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
4898 self.ageable_mob.pack_dirty_into(values);
4899 if self.got_fish.is_dirty() {
4900 values.push(DataValue {
4901 index: 18u8,
4902 serializer_id: 8i32,
4903 value: EntityData::Boolean(*self.got_fish.get()),
4904 });
4905 self.got_fish.clear_dirty();
4906 }
4907 if self.moistness_level.is_dirty() {
4908 values.push(DataValue {
4909 index: 19u8,
4910 serializer_id: 1i32,
4911 value: EntityData::Int(*self.moistness_level.get()),
4912 });
4913 self.moistness_level.clear_dirty();
4914 }
4915 }
4916 #[doc = r" Pack all non-default values (for initial entity spawn)."]
4917 pub fn pack_all(&self) -> Vec<DataValue> {
4918 let mut values = Vec::new();
4919 self.pack_all_into(&mut values);
4920 values
4921 }
4922 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
4923 self.ageable_mob.pack_all_into(values);
4924 if !self.got_fish.is_default() {
4925 values.push(DataValue {
4926 index: 18u8,
4927 serializer_id: 8i32,
4928 value: EntityData::Boolean(*self.got_fish.get()),
4929 });
4930 }
4931 if !self.moistness_level.is_default() {
4932 values.push(DataValue {
4933 index: 19u8,
4934 serializer_id: 1i32,
4935 value: EntityData::Int(*self.moistness_level.get()),
4936 });
4937 }
4938 }
4939 #[doc = r" Returns `true` if any field has been modified."]
4940 pub fn is_dirty(&self) -> bool {
4941 self.ageable_mob.is_dirty() || self.got_fish.is_dirty() || self.moistness_level.is_dirty()
4942 }
4943}
4944impl Default for DolphinEntityData {
4945 fn default() -> Self {
4946 Self::new()
4947 }
4948}
4949impl VanillaEntityData for DolphinEntityData {
4950 fn base(&self) -> &BaseEntityData {
4951 DolphinEntityData::base(self)
4952 }
4953 fn base_mut(&mut self) -> &mut BaseEntityData {
4954 DolphinEntityData::base_mut(self)
4955 }
4956 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
4957 DolphinEntityData::pack_dirty(self)
4958 }
4959 fn pack_all(&self) -> Vec<DataValue> {
4960 DolphinEntityData::pack_all(self)
4961 }
4962 fn is_dirty(&self) -> bool {
4963 DolphinEntityData::is_dirty(self)
4964 }
4965}
4966impl VanillaLivingEntityData for DolphinEntityData {
4967 fn living_entity(&self) -> &LivingEntityData {
4968 DolphinEntityData::living_entity(self)
4969 }
4970 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
4971 DolphinEntityData::living_entity_mut(self)
4972 }
4973}
4974#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
4975#[derive(Debug, Clone)]
4976pub struct AbstractChestedHorseEntityData {
4977 pub abstract_horse: AbstractHorseEntityData,
4978 pub id_chest: SyncedValue<bool>,
4979}
4980impl AbstractChestedHorseEntityData {
4981 #[doc = r" Create new entity data with default values."]
4982 pub fn new() -> Self {
4983 Self {
4984 abstract_horse: AbstractHorseEntityData::new(),
4985 id_chest: SyncedValue::new(false),
4986 }
4987 }
4988 #[doc = "Returns the `AbstractChestedHorseEntityData` layer."]
4989 pub fn abstract_chested_horse(&self) -> &AbstractChestedHorseEntityData {
4990 self
4991 }
4992 #[doc = "Returns the mutable `AbstractChestedHorseEntityData` layer."]
4993 pub fn abstract_chested_horse_mut(&mut self) -> &mut AbstractChestedHorseEntityData {
4994 self
4995 }
4996 #[doc = "Returns the `AbstractHorseEntityData` layer."]
4997 pub fn abstract_horse(&self) -> &AbstractHorseEntityData {
4998 &self.abstract_horse
4999 }
5000 #[doc = "Returns the mutable `AbstractHorseEntityData` layer."]
5001 pub fn abstract_horse_mut(&mut self) -> &mut AbstractHorseEntityData {
5002 &mut self.abstract_horse
5003 }
5004 #[doc = "Returns the `AgeableMobEntityData` layer."]
5005 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
5006 &self.abstract_horse.ageable_mob
5007 }
5008 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
5009 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
5010 &mut self.abstract_horse.ageable_mob
5011 }
5012 #[doc = "Returns the `MobEntityData` layer."]
5013 pub fn mob(&self) -> &MobEntityData {
5014 &self.abstract_horse.ageable_mob.mob
5015 }
5016 #[doc = "Returns the mutable `MobEntityData` layer."]
5017 pub fn mob_mut(&mut self) -> &mut MobEntityData {
5018 &mut self.abstract_horse.ageable_mob.mob
5019 }
5020 #[doc = "Returns the `LivingEntityData` layer."]
5021 pub fn living_entity(&self) -> &LivingEntityData {
5022 &self.abstract_horse.ageable_mob.mob.living_entity
5023 }
5024 #[doc = "Returns the mutable `LivingEntityData` layer."]
5025 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
5026 &mut self.abstract_horse.ageable_mob.mob.living_entity
5027 }
5028 #[doc = "Returns the `BaseEntityData` layer."]
5029 pub fn base(&self) -> &BaseEntityData {
5030 &self.abstract_horse.ageable_mob.mob.living_entity.base
5031 }
5032 #[doc = "Returns the mutable `BaseEntityData` layer."]
5033 pub fn base_mut(&mut self) -> &mut BaseEntityData {
5034 &mut self.abstract_horse.ageable_mob.mob.living_entity.base
5035 }
5036 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
5037 #[doc = r" Returns `None` if no values are dirty."]
5038 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5039 let mut values = Vec::new();
5040 self.pack_dirty_into(&mut values);
5041 if values.is_empty() {
5042 None
5043 } else {
5044 Some(values)
5045 }
5046 }
5047 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
5048 self.abstract_horse.pack_dirty_into(values);
5049 if self.id_chest.is_dirty() {
5050 values.push(DataValue {
5051 index: 19u8,
5052 serializer_id: 8i32,
5053 value: EntityData::Boolean(*self.id_chest.get()),
5054 });
5055 self.id_chest.clear_dirty();
5056 }
5057 }
5058 #[doc = r" Pack all non-default values (for initial entity spawn)."]
5059 pub fn pack_all(&self) -> Vec<DataValue> {
5060 let mut values = Vec::new();
5061 self.pack_all_into(&mut values);
5062 values
5063 }
5064 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
5065 self.abstract_horse.pack_all_into(values);
5066 if !self.id_chest.is_default() {
5067 values.push(DataValue {
5068 index: 19u8,
5069 serializer_id: 8i32,
5070 value: EntityData::Boolean(*self.id_chest.get()),
5071 });
5072 }
5073 }
5074 #[doc = r" Returns `true` if any field has been modified."]
5075 pub fn is_dirty(&self) -> bool {
5076 self.abstract_horse.is_dirty() || self.id_chest.is_dirty()
5077 }
5078}
5079impl Default for AbstractChestedHorseEntityData {
5080 fn default() -> Self {
5081 Self::new()
5082 }
5083}
5084impl VanillaEntityData for AbstractChestedHorseEntityData {
5085 fn base(&self) -> &BaseEntityData {
5086 AbstractChestedHorseEntityData::base(self)
5087 }
5088 fn base_mut(&mut self) -> &mut BaseEntityData {
5089 AbstractChestedHorseEntityData::base_mut(self)
5090 }
5091 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5092 AbstractChestedHorseEntityData::pack_dirty(self)
5093 }
5094 fn pack_all(&self) -> Vec<DataValue> {
5095 AbstractChestedHorseEntityData::pack_all(self)
5096 }
5097 fn is_dirty(&self) -> bool {
5098 AbstractChestedHorseEntityData::is_dirty(self)
5099 }
5100}
5101impl VanillaLivingEntityData for AbstractChestedHorseEntityData {
5102 fn living_entity(&self) -> &LivingEntityData {
5103 AbstractChestedHorseEntityData::living_entity(self)
5104 }
5105 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
5106 AbstractChestedHorseEntityData::living_entity_mut(self)
5107 }
5108}
5109#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
5110#[derive(Debug, Clone)]
5111pub struct ZombieEntityData {
5112 pub mob: MobEntityData,
5113 pub baby: SyncedValue<bool>,
5114 pub special_type: SyncedValue<i32>,
5115 pub drowned_conversion: SyncedValue<bool>,
5116}
5117impl ZombieEntityData {
5118 #[doc = r" Create new entity data with default values."]
5119 pub fn new() -> Self {
5120 Self {
5121 mob: MobEntityData::new(),
5122 baby: SyncedValue::new(false),
5123 special_type: SyncedValue::new(0i32),
5124 drowned_conversion: SyncedValue::new(false),
5125 }
5126 }
5127 #[doc = "Returns the `ZombieEntityData` layer."]
5128 pub fn zombie(&self) -> &ZombieEntityData {
5129 self
5130 }
5131 #[doc = "Returns the mutable `ZombieEntityData` layer."]
5132 pub fn zombie_mut(&mut self) -> &mut ZombieEntityData {
5133 self
5134 }
5135 #[doc = "Returns the `MobEntityData` layer."]
5136 pub fn mob(&self) -> &MobEntityData {
5137 &self.mob
5138 }
5139 #[doc = "Returns the mutable `MobEntityData` layer."]
5140 pub fn mob_mut(&mut self) -> &mut MobEntityData {
5141 &mut self.mob
5142 }
5143 #[doc = "Returns the `LivingEntityData` layer."]
5144 pub fn living_entity(&self) -> &LivingEntityData {
5145 &self.mob.living_entity
5146 }
5147 #[doc = "Returns the mutable `LivingEntityData` layer."]
5148 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
5149 &mut self.mob.living_entity
5150 }
5151 #[doc = "Returns the `BaseEntityData` layer."]
5152 pub fn base(&self) -> &BaseEntityData {
5153 &self.mob.living_entity.base
5154 }
5155 #[doc = "Returns the mutable `BaseEntityData` layer."]
5156 pub fn base_mut(&mut self) -> &mut BaseEntityData {
5157 &mut self.mob.living_entity.base
5158 }
5159 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
5160 #[doc = r" Returns `None` if no values are dirty."]
5161 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5162 let mut values = Vec::new();
5163 self.pack_dirty_into(&mut values);
5164 if values.is_empty() {
5165 None
5166 } else {
5167 Some(values)
5168 }
5169 }
5170 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
5171 self.mob.pack_dirty_into(values);
5172 if self.baby.is_dirty() {
5173 values.push(DataValue {
5174 index: 16u8,
5175 serializer_id: 8i32,
5176 value: EntityData::Boolean(*self.baby.get()),
5177 });
5178 self.baby.clear_dirty();
5179 }
5180 if self.special_type.is_dirty() {
5181 values.push(DataValue {
5182 index: 17u8,
5183 serializer_id: 1i32,
5184 value: EntityData::Int(*self.special_type.get()),
5185 });
5186 self.special_type.clear_dirty();
5187 }
5188 if self.drowned_conversion.is_dirty() {
5189 values.push(DataValue {
5190 index: 18u8,
5191 serializer_id: 8i32,
5192 value: EntityData::Boolean(*self.drowned_conversion.get()),
5193 });
5194 self.drowned_conversion.clear_dirty();
5195 }
5196 }
5197 #[doc = r" Pack all non-default values (for initial entity spawn)."]
5198 pub fn pack_all(&self) -> Vec<DataValue> {
5199 let mut values = Vec::new();
5200 self.pack_all_into(&mut values);
5201 values
5202 }
5203 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
5204 self.mob.pack_all_into(values);
5205 if !self.baby.is_default() {
5206 values.push(DataValue {
5207 index: 16u8,
5208 serializer_id: 8i32,
5209 value: EntityData::Boolean(*self.baby.get()),
5210 });
5211 }
5212 if !self.special_type.is_default() {
5213 values.push(DataValue {
5214 index: 17u8,
5215 serializer_id: 1i32,
5216 value: EntityData::Int(*self.special_type.get()),
5217 });
5218 }
5219 if !self.drowned_conversion.is_default() {
5220 values.push(DataValue {
5221 index: 18u8,
5222 serializer_id: 8i32,
5223 value: EntityData::Boolean(*self.drowned_conversion.get()),
5224 });
5225 }
5226 }
5227 #[doc = r" Returns `true` if any field has been modified."]
5228 pub fn is_dirty(&self) -> bool {
5229 self.mob.is_dirty()
5230 || self.baby.is_dirty()
5231 || self.special_type.is_dirty()
5232 || self.drowned_conversion.is_dirty()
5233 }
5234}
5235impl Default for ZombieEntityData {
5236 fn default() -> Self {
5237 Self::new()
5238 }
5239}
5240impl VanillaEntityData for ZombieEntityData {
5241 fn base(&self) -> &BaseEntityData {
5242 ZombieEntityData::base(self)
5243 }
5244 fn base_mut(&mut self) -> &mut BaseEntityData {
5245 ZombieEntityData::base_mut(self)
5246 }
5247 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5248 ZombieEntityData::pack_dirty(self)
5249 }
5250 fn pack_all(&self) -> Vec<DataValue> {
5251 ZombieEntityData::pack_all(self)
5252 }
5253 fn is_dirty(&self) -> bool {
5254 ZombieEntityData::is_dirty(self)
5255 }
5256}
5257impl VanillaLivingEntityData for ZombieEntityData {
5258 fn living_entity(&self) -> &LivingEntityData {
5259 ZombieEntityData::living_entity(self)
5260 }
5261 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
5262 ZombieEntityData::living_entity_mut(self)
5263 }
5264}
5265#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
5266#[derive(Debug, Clone)]
5267pub struct ThrowableItemProjectileEntityData {
5268 pub base: BaseEntityData,
5269 pub item_stack: SyncedValue<ItemStack>,
5270}
5271impl ThrowableItemProjectileEntityData {
5272 #[doc = r" Create new entity data with default values."]
5273 pub fn new() -> Self {
5274 Self {
5275 base: BaseEntityData::new(),
5276 item_stack: SyncedValue::new(ItemStack::with_count(
5277 &crate::vanilla_items::ITEMS.egg,
5278 1i32,
5279 )),
5280 }
5281 }
5282 #[doc = "Returns the `ThrowableItemProjectileEntityData` layer."]
5283 pub fn throwable_item_projectile(&self) -> &ThrowableItemProjectileEntityData {
5284 self
5285 }
5286 #[doc = "Returns the mutable `ThrowableItemProjectileEntityData` layer."]
5287 pub fn throwable_item_projectile_mut(&mut self) -> &mut ThrowableItemProjectileEntityData {
5288 self
5289 }
5290 #[doc = "Returns the `BaseEntityData` layer."]
5291 pub fn base(&self) -> &BaseEntityData {
5292 &self.base
5293 }
5294 #[doc = "Returns the mutable `BaseEntityData` layer."]
5295 pub fn base_mut(&mut self) -> &mut BaseEntityData {
5296 &mut self.base
5297 }
5298 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
5299 #[doc = r" Returns `None` if no values are dirty."]
5300 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5301 let mut values = Vec::new();
5302 self.pack_dirty_into(&mut values);
5303 if values.is_empty() {
5304 None
5305 } else {
5306 Some(values)
5307 }
5308 }
5309 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
5310 self.base.pack_dirty_into(values);
5311 if self.item_stack.is_dirty() {
5312 values.push(DataValue {
5313 index: 8u8,
5314 serializer_id: 7i32,
5315 value: EntityData::ItemStack(self.item_stack.get().clone()),
5316 });
5317 self.item_stack.clear_dirty();
5318 }
5319 }
5320 #[doc = r" Pack all non-default values (for initial entity spawn)."]
5321 pub fn pack_all(&self) -> Vec<DataValue> {
5322 let mut values = Vec::new();
5323 self.pack_all_into(&mut values);
5324 values
5325 }
5326 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
5327 self.base.pack_all_into(values);
5328 if !self.item_stack.is_default() {
5329 values.push(DataValue {
5330 index: 8u8,
5331 serializer_id: 7i32,
5332 value: EntityData::ItemStack(self.item_stack.get().clone()),
5333 });
5334 }
5335 }
5336 #[doc = r" Returns `true` if any field has been modified."]
5337 pub fn is_dirty(&self) -> bool {
5338 self.base.is_dirty() || self.item_stack.is_dirty()
5339 }
5340}
5341impl Default for ThrowableItemProjectileEntityData {
5342 fn default() -> Self {
5343 Self::new()
5344 }
5345}
5346impl VanillaEntityData for ThrowableItemProjectileEntityData {
5347 fn base(&self) -> &BaseEntityData {
5348 ThrowableItemProjectileEntityData::base(self)
5349 }
5350 fn base_mut(&mut self) -> &mut BaseEntityData {
5351 ThrowableItemProjectileEntityData::base_mut(self)
5352 }
5353 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5354 ThrowableItemProjectileEntityData::pack_dirty(self)
5355 }
5356 fn pack_all(&self) -> Vec<DataValue> {
5357 ThrowableItemProjectileEntityData::pack_all(self)
5358 }
5359 fn is_dirty(&self) -> bool {
5360 ThrowableItemProjectileEntityData::is_dirty(self)
5361 }
5362}
5363#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
5364#[derive(Debug, Clone)]
5365pub struct GuardianEntityData {
5366 pub mob: MobEntityData,
5367 pub id_moving: SyncedValue<bool>,
5368 pub id_attack_target: SyncedValue<i32>,
5369}
5370impl GuardianEntityData {
5371 #[doc = r" Create new entity data with default values."]
5372 pub fn new() -> Self {
5373 Self {
5374 mob: MobEntityData::new(),
5375 id_moving: SyncedValue::new(false),
5376 id_attack_target: SyncedValue::new(0i32),
5377 }
5378 }
5379 #[doc = "Returns the `GuardianEntityData` layer."]
5380 pub fn guardian(&self) -> &GuardianEntityData {
5381 self
5382 }
5383 #[doc = "Returns the mutable `GuardianEntityData` layer."]
5384 pub fn guardian_mut(&mut self) -> &mut GuardianEntityData {
5385 self
5386 }
5387 #[doc = "Returns the `MobEntityData` layer."]
5388 pub fn mob(&self) -> &MobEntityData {
5389 &self.mob
5390 }
5391 #[doc = "Returns the mutable `MobEntityData` layer."]
5392 pub fn mob_mut(&mut self) -> &mut MobEntityData {
5393 &mut self.mob
5394 }
5395 #[doc = "Returns the `LivingEntityData` layer."]
5396 pub fn living_entity(&self) -> &LivingEntityData {
5397 &self.mob.living_entity
5398 }
5399 #[doc = "Returns the mutable `LivingEntityData` layer."]
5400 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
5401 &mut self.mob.living_entity
5402 }
5403 #[doc = "Returns the `BaseEntityData` layer."]
5404 pub fn base(&self) -> &BaseEntityData {
5405 &self.mob.living_entity.base
5406 }
5407 #[doc = "Returns the mutable `BaseEntityData` layer."]
5408 pub fn base_mut(&mut self) -> &mut BaseEntityData {
5409 &mut self.mob.living_entity.base
5410 }
5411 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
5412 #[doc = r" Returns `None` if no values are dirty."]
5413 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5414 let mut values = Vec::new();
5415 self.pack_dirty_into(&mut values);
5416 if values.is_empty() {
5417 None
5418 } else {
5419 Some(values)
5420 }
5421 }
5422 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
5423 self.mob.pack_dirty_into(values);
5424 if self.id_moving.is_dirty() {
5425 values.push(DataValue {
5426 index: 16u8,
5427 serializer_id: 8i32,
5428 value: EntityData::Boolean(*self.id_moving.get()),
5429 });
5430 self.id_moving.clear_dirty();
5431 }
5432 if self.id_attack_target.is_dirty() {
5433 values.push(DataValue {
5434 index: 17u8,
5435 serializer_id: 1i32,
5436 value: EntityData::Int(*self.id_attack_target.get()),
5437 });
5438 self.id_attack_target.clear_dirty();
5439 }
5440 }
5441 #[doc = r" Pack all non-default values (for initial entity spawn)."]
5442 pub fn pack_all(&self) -> Vec<DataValue> {
5443 let mut values = Vec::new();
5444 self.pack_all_into(&mut values);
5445 values
5446 }
5447 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
5448 self.mob.pack_all_into(values);
5449 if !self.id_moving.is_default() {
5450 values.push(DataValue {
5451 index: 16u8,
5452 serializer_id: 8i32,
5453 value: EntityData::Boolean(*self.id_moving.get()),
5454 });
5455 }
5456 if !self.id_attack_target.is_default() {
5457 values.push(DataValue {
5458 index: 17u8,
5459 serializer_id: 1i32,
5460 value: EntityData::Int(*self.id_attack_target.get()),
5461 });
5462 }
5463 }
5464 #[doc = r" Returns `true` if any field has been modified."]
5465 pub fn is_dirty(&self) -> bool {
5466 self.mob.is_dirty() || self.id_moving.is_dirty() || self.id_attack_target.is_dirty()
5467 }
5468}
5469impl Default for GuardianEntityData {
5470 fn default() -> Self {
5471 Self::new()
5472 }
5473}
5474impl VanillaEntityData for GuardianEntityData {
5475 fn base(&self) -> &BaseEntityData {
5476 GuardianEntityData::base(self)
5477 }
5478 fn base_mut(&mut self) -> &mut BaseEntityData {
5479 GuardianEntityData::base_mut(self)
5480 }
5481 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5482 GuardianEntityData::pack_dirty(self)
5483 }
5484 fn pack_all(&self) -> Vec<DataValue> {
5485 GuardianEntityData::pack_all(self)
5486 }
5487 fn is_dirty(&self) -> bool {
5488 GuardianEntityData::is_dirty(self)
5489 }
5490}
5491impl VanillaLivingEntityData for GuardianEntityData {
5492 fn living_entity(&self) -> &LivingEntityData {
5493 GuardianEntityData::living_entity(self)
5494 }
5495 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
5496 GuardianEntityData::living_entity_mut(self)
5497 }
5498}
5499#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
5500#[derive(Debug, Clone)]
5501pub struct EnderManEntityData {
5502 pub mob: MobEntityData,
5503 pub carry_state: SyncedValue<Option<BlockStateId>>,
5504 pub creepy: SyncedValue<bool>,
5505 pub stared_at: SyncedValue<bool>,
5506}
5507impl EnderManEntityData {
5508 #[doc = r" Create new entity data with default values."]
5509 pub fn new() -> Self {
5510 Self {
5511 mob: MobEntityData::new(),
5512 carry_state: SyncedValue::new(None),
5513 creepy: SyncedValue::new(false),
5514 stared_at: SyncedValue::new(false),
5515 }
5516 }
5517 #[doc = "Returns the `EnderManEntityData` layer."]
5518 pub fn ender_man(&self) -> &EnderManEntityData {
5519 self
5520 }
5521 #[doc = "Returns the mutable `EnderManEntityData` layer."]
5522 pub fn ender_man_mut(&mut self) -> &mut EnderManEntityData {
5523 self
5524 }
5525 #[doc = "Returns the `MobEntityData` layer."]
5526 pub fn mob(&self) -> &MobEntityData {
5527 &self.mob
5528 }
5529 #[doc = "Returns the mutable `MobEntityData` layer."]
5530 pub fn mob_mut(&mut self) -> &mut MobEntityData {
5531 &mut self.mob
5532 }
5533 #[doc = "Returns the `LivingEntityData` layer."]
5534 pub fn living_entity(&self) -> &LivingEntityData {
5535 &self.mob.living_entity
5536 }
5537 #[doc = "Returns the mutable `LivingEntityData` layer."]
5538 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
5539 &mut self.mob.living_entity
5540 }
5541 #[doc = "Returns the `BaseEntityData` layer."]
5542 pub fn base(&self) -> &BaseEntityData {
5543 &self.mob.living_entity.base
5544 }
5545 #[doc = "Returns the mutable `BaseEntityData` layer."]
5546 pub fn base_mut(&mut self) -> &mut BaseEntityData {
5547 &mut self.mob.living_entity.base
5548 }
5549 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
5550 #[doc = r" Returns `None` if no values are dirty."]
5551 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5552 let mut values = Vec::new();
5553 self.pack_dirty_into(&mut values);
5554 if values.is_empty() {
5555 None
5556 } else {
5557 Some(values)
5558 }
5559 }
5560 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
5561 self.mob.pack_dirty_into(values);
5562 if self.carry_state.is_dirty() {
5563 values.push(DataValue {
5564 index: 16u8,
5565 serializer_id: 15i32,
5566 value: EntityData::OptionalBlockState(self.carry_state.get().clone()),
5567 });
5568 self.carry_state.clear_dirty();
5569 }
5570 if self.creepy.is_dirty() {
5571 values.push(DataValue {
5572 index: 17u8,
5573 serializer_id: 8i32,
5574 value: EntityData::Boolean(*self.creepy.get()),
5575 });
5576 self.creepy.clear_dirty();
5577 }
5578 if self.stared_at.is_dirty() {
5579 values.push(DataValue {
5580 index: 18u8,
5581 serializer_id: 8i32,
5582 value: EntityData::Boolean(*self.stared_at.get()),
5583 });
5584 self.stared_at.clear_dirty();
5585 }
5586 }
5587 #[doc = r" Pack all non-default values (for initial entity spawn)."]
5588 pub fn pack_all(&self) -> Vec<DataValue> {
5589 let mut values = Vec::new();
5590 self.pack_all_into(&mut values);
5591 values
5592 }
5593 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
5594 self.mob.pack_all_into(values);
5595 if !self.carry_state.is_default() {
5596 values.push(DataValue {
5597 index: 16u8,
5598 serializer_id: 15i32,
5599 value: EntityData::OptionalBlockState(self.carry_state.get().clone()),
5600 });
5601 }
5602 if !self.creepy.is_default() {
5603 values.push(DataValue {
5604 index: 17u8,
5605 serializer_id: 8i32,
5606 value: EntityData::Boolean(*self.creepy.get()),
5607 });
5608 }
5609 if !self.stared_at.is_default() {
5610 values.push(DataValue {
5611 index: 18u8,
5612 serializer_id: 8i32,
5613 value: EntityData::Boolean(*self.stared_at.get()),
5614 });
5615 }
5616 }
5617 #[doc = r" Returns `true` if any field has been modified."]
5618 pub fn is_dirty(&self) -> bool {
5619 self.mob.is_dirty()
5620 || self.carry_state.is_dirty()
5621 || self.creepy.is_dirty()
5622 || self.stared_at.is_dirty()
5623 }
5624}
5625impl Default for EnderManEntityData {
5626 fn default() -> Self {
5627 Self::new()
5628 }
5629}
5630impl VanillaEntityData for EnderManEntityData {
5631 fn base(&self) -> &BaseEntityData {
5632 EnderManEntityData::base(self)
5633 }
5634 fn base_mut(&mut self) -> &mut BaseEntityData {
5635 EnderManEntityData::base_mut(self)
5636 }
5637 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5638 EnderManEntityData::pack_dirty(self)
5639 }
5640 fn pack_all(&self) -> Vec<DataValue> {
5641 EnderManEntityData::pack_all(self)
5642 }
5643 fn is_dirty(&self) -> bool {
5644 EnderManEntityData::is_dirty(self)
5645 }
5646}
5647impl VanillaLivingEntityData for EnderManEntityData {
5648 fn living_entity(&self) -> &LivingEntityData {
5649 EnderManEntityData::living_entity(self)
5650 }
5651 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
5652 EnderManEntityData::living_entity_mut(self)
5653 }
5654}
5655#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
5656#[derive(Debug, Clone)]
5657pub struct EnderDragonEntityData {
5658 pub mob: MobEntityData,
5659 pub phase: SyncedValue<i32>,
5660}
5661impl EnderDragonEntityData {
5662 #[doc = r" Create new entity data with default values."]
5663 pub fn new() -> Self {
5664 Self {
5665 mob: MobEntityData::new(),
5666 phase: SyncedValue::new(10i32),
5667 }
5668 }
5669 #[doc = "Returns the `EnderDragonEntityData` layer."]
5670 pub fn ender_dragon(&self) -> &EnderDragonEntityData {
5671 self
5672 }
5673 #[doc = "Returns the mutable `EnderDragonEntityData` layer."]
5674 pub fn ender_dragon_mut(&mut self) -> &mut EnderDragonEntityData {
5675 self
5676 }
5677 #[doc = "Returns the `MobEntityData` layer."]
5678 pub fn mob(&self) -> &MobEntityData {
5679 &self.mob
5680 }
5681 #[doc = "Returns the mutable `MobEntityData` layer."]
5682 pub fn mob_mut(&mut self) -> &mut MobEntityData {
5683 &mut self.mob
5684 }
5685 #[doc = "Returns the `LivingEntityData` layer."]
5686 pub fn living_entity(&self) -> &LivingEntityData {
5687 &self.mob.living_entity
5688 }
5689 #[doc = "Returns the mutable `LivingEntityData` layer."]
5690 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
5691 &mut self.mob.living_entity
5692 }
5693 #[doc = "Returns the `BaseEntityData` layer."]
5694 pub fn base(&self) -> &BaseEntityData {
5695 &self.mob.living_entity.base
5696 }
5697 #[doc = "Returns the mutable `BaseEntityData` layer."]
5698 pub fn base_mut(&mut self) -> &mut BaseEntityData {
5699 &mut self.mob.living_entity.base
5700 }
5701 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
5702 #[doc = r" Returns `None` if no values are dirty."]
5703 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5704 let mut values = Vec::new();
5705 self.pack_dirty_into(&mut values);
5706 if values.is_empty() {
5707 None
5708 } else {
5709 Some(values)
5710 }
5711 }
5712 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
5713 self.mob.pack_dirty_into(values);
5714 if self.phase.is_dirty() {
5715 values.push(DataValue {
5716 index: 16u8,
5717 serializer_id: 1i32,
5718 value: EntityData::Int(*self.phase.get()),
5719 });
5720 self.phase.clear_dirty();
5721 }
5722 }
5723 #[doc = r" Pack all non-default values (for initial entity spawn)."]
5724 pub fn pack_all(&self) -> Vec<DataValue> {
5725 let mut values = Vec::new();
5726 self.pack_all_into(&mut values);
5727 values
5728 }
5729 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
5730 self.mob.pack_all_into(values);
5731 if !self.phase.is_default() {
5732 values.push(DataValue {
5733 index: 16u8,
5734 serializer_id: 1i32,
5735 value: EntityData::Int(*self.phase.get()),
5736 });
5737 }
5738 }
5739 #[doc = r" Returns `true` if any field has been modified."]
5740 pub fn is_dirty(&self) -> bool {
5741 self.mob.is_dirty() || self.phase.is_dirty()
5742 }
5743}
5744impl Default for EnderDragonEntityData {
5745 fn default() -> Self {
5746 Self::new()
5747 }
5748}
5749impl VanillaEntityData for EnderDragonEntityData {
5750 fn base(&self) -> &BaseEntityData {
5751 EnderDragonEntityData::base(self)
5752 }
5753 fn base_mut(&mut self) -> &mut BaseEntityData {
5754 EnderDragonEntityData::base_mut(self)
5755 }
5756 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5757 EnderDragonEntityData::pack_dirty(self)
5758 }
5759 fn pack_all(&self) -> Vec<DataValue> {
5760 EnderDragonEntityData::pack_all(self)
5761 }
5762 fn is_dirty(&self) -> bool {
5763 EnderDragonEntityData::is_dirty(self)
5764 }
5765}
5766impl VanillaLivingEntityData for EnderDragonEntityData {
5767 fn living_entity(&self) -> &LivingEntityData {
5768 EnderDragonEntityData::living_entity(self)
5769 }
5770 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
5771 EnderDragonEntityData::living_entity_mut(self)
5772 }
5773}
5774#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
5775#[derive(Debug, Clone)]
5776pub struct EndCrystalEntityData {
5777 pub base: BaseEntityData,
5778 pub beam_target: SyncedValue<Option<BlockPos>>,
5779 pub show_bottom: SyncedValue<bool>,
5780}
5781impl EndCrystalEntityData {
5782 #[doc = r" Create new entity data with default values."]
5783 pub fn new() -> Self {
5784 Self {
5785 base: BaseEntityData::new(),
5786 beam_target: SyncedValue::new(None),
5787 show_bottom: SyncedValue::new(true),
5788 }
5789 }
5790 #[doc = "Returns the `EndCrystalEntityData` layer."]
5791 pub fn end_crystal(&self) -> &EndCrystalEntityData {
5792 self
5793 }
5794 #[doc = "Returns the mutable `EndCrystalEntityData` layer."]
5795 pub fn end_crystal_mut(&mut self) -> &mut EndCrystalEntityData {
5796 self
5797 }
5798 #[doc = "Returns the `BaseEntityData` layer."]
5799 pub fn base(&self) -> &BaseEntityData {
5800 &self.base
5801 }
5802 #[doc = "Returns the mutable `BaseEntityData` layer."]
5803 pub fn base_mut(&mut self) -> &mut BaseEntityData {
5804 &mut self.base
5805 }
5806 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
5807 #[doc = r" Returns `None` if no values are dirty."]
5808 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5809 let mut values = Vec::new();
5810 self.pack_dirty_into(&mut values);
5811 if values.is_empty() {
5812 None
5813 } else {
5814 Some(values)
5815 }
5816 }
5817 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
5818 self.base.pack_dirty_into(values);
5819 if self.beam_target.is_dirty() {
5820 values.push(DataValue {
5821 index: 8u8,
5822 serializer_id: 11i32,
5823 value: EntityData::OptionalBlockPos(self.beam_target.get().clone()),
5824 });
5825 self.beam_target.clear_dirty();
5826 }
5827 if self.show_bottom.is_dirty() {
5828 values.push(DataValue {
5829 index: 9u8,
5830 serializer_id: 8i32,
5831 value: EntityData::Boolean(*self.show_bottom.get()),
5832 });
5833 self.show_bottom.clear_dirty();
5834 }
5835 }
5836 #[doc = r" Pack all non-default values (for initial entity spawn)."]
5837 pub fn pack_all(&self) -> Vec<DataValue> {
5838 let mut values = Vec::new();
5839 self.pack_all_into(&mut values);
5840 values
5841 }
5842 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
5843 self.base.pack_all_into(values);
5844 if !self.beam_target.is_default() {
5845 values.push(DataValue {
5846 index: 8u8,
5847 serializer_id: 11i32,
5848 value: EntityData::OptionalBlockPos(self.beam_target.get().clone()),
5849 });
5850 }
5851 if !self.show_bottom.is_default() {
5852 values.push(DataValue {
5853 index: 9u8,
5854 serializer_id: 8i32,
5855 value: EntityData::Boolean(*self.show_bottom.get()),
5856 });
5857 }
5858 }
5859 #[doc = r" Returns `true` if any field has been modified."]
5860 pub fn is_dirty(&self) -> bool {
5861 self.base.is_dirty() || self.beam_target.is_dirty() || self.show_bottom.is_dirty()
5862 }
5863}
5864impl Default for EndCrystalEntityData {
5865 fn default() -> Self {
5866 Self::new()
5867 }
5868}
5869impl VanillaEntityData for EndCrystalEntityData {
5870 fn base(&self) -> &BaseEntityData {
5871 EndCrystalEntityData::base(self)
5872 }
5873 fn base_mut(&mut self) -> &mut BaseEntityData {
5874 EndCrystalEntityData::base_mut(self)
5875 }
5876 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5877 EndCrystalEntityData::pack_dirty(self)
5878 }
5879 fn pack_all(&self) -> Vec<DataValue> {
5880 EndCrystalEntityData::pack_all(self)
5881 }
5882 fn is_dirty(&self) -> bool {
5883 EndCrystalEntityData::is_dirty(self)
5884 }
5885}
5886#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
5887#[derive(Debug, Clone)]
5888pub struct RaiderEntityData {
5889 pub mob: MobEntityData,
5890 pub is_celebrating: SyncedValue<bool>,
5891}
5892impl RaiderEntityData {
5893 #[doc = r" Create new entity data with default values."]
5894 pub fn new() -> Self {
5895 Self {
5896 mob: MobEntityData::new(),
5897 is_celebrating: SyncedValue::new(false),
5898 }
5899 }
5900 #[doc = "Returns the `RaiderEntityData` layer."]
5901 pub fn raider(&self) -> &RaiderEntityData {
5902 self
5903 }
5904 #[doc = "Returns the mutable `RaiderEntityData` layer."]
5905 pub fn raider_mut(&mut self) -> &mut RaiderEntityData {
5906 self
5907 }
5908 #[doc = "Returns the `MobEntityData` layer."]
5909 pub fn mob(&self) -> &MobEntityData {
5910 &self.mob
5911 }
5912 #[doc = "Returns the mutable `MobEntityData` layer."]
5913 pub fn mob_mut(&mut self) -> &mut MobEntityData {
5914 &mut self.mob
5915 }
5916 #[doc = "Returns the `LivingEntityData` layer."]
5917 pub fn living_entity(&self) -> &LivingEntityData {
5918 &self.mob.living_entity
5919 }
5920 #[doc = "Returns the mutable `LivingEntityData` layer."]
5921 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
5922 &mut self.mob.living_entity
5923 }
5924 #[doc = "Returns the `BaseEntityData` layer."]
5925 pub fn base(&self) -> &BaseEntityData {
5926 &self.mob.living_entity.base
5927 }
5928 #[doc = "Returns the mutable `BaseEntityData` layer."]
5929 pub fn base_mut(&mut self) -> &mut BaseEntityData {
5930 &mut self.mob.living_entity.base
5931 }
5932 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
5933 #[doc = r" Returns `None` if no values are dirty."]
5934 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5935 let mut values = Vec::new();
5936 self.pack_dirty_into(&mut values);
5937 if values.is_empty() {
5938 None
5939 } else {
5940 Some(values)
5941 }
5942 }
5943 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
5944 self.mob.pack_dirty_into(values);
5945 if self.is_celebrating.is_dirty() {
5946 values.push(DataValue {
5947 index: 16u8,
5948 serializer_id: 8i32,
5949 value: EntityData::Boolean(*self.is_celebrating.get()),
5950 });
5951 self.is_celebrating.clear_dirty();
5952 }
5953 }
5954 #[doc = r" Pack all non-default values (for initial entity spawn)."]
5955 pub fn pack_all(&self) -> Vec<DataValue> {
5956 let mut values = Vec::new();
5957 self.pack_all_into(&mut values);
5958 values
5959 }
5960 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
5961 self.mob.pack_all_into(values);
5962 if !self.is_celebrating.is_default() {
5963 values.push(DataValue {
5964 index: 16u8,
5965 serializer_id: 8i32,
5966 value: EntityData::Boolean(*self.is_celebrating.get()),
5967 });
5968 }
5969 }
5970 #[doc = r" Returns `true` if any field has been modified."]
5971 pub fn is_dirty(&self) -> bool {
5972 self.mob.is_dirty() || self.is_celebrating.is_dirty()
5973 }
5974}
5975impl Default for RaiderEntityData {
5976 fn default() -> Self {
5977 Self::new()
5978 }
5979}
5980impl VanillaEntityData for RaiderEntityData {
5981 fn base(&self) -> &BaseEntityData {
5982 RaiderEntityData::base(self)
5983 }
5984 fn base_mut(&mut self) -> &mut BaseEntityData {
5985 RaiderEntityData::base_mut(self)
5986 }
5987 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
5988 RaiderEntityData::pack_dirty(self)
5989 }
5990 fn pack_all(&self) -> Vec<DataValue> {
5991 RaiderEntityData::pack_all(self)
5992 }
5993 fn is_dirty(&self) -> bool {
5994 RaiderEntityData::is_dirty(self)
5995 }
5996}
5997impl VanillaLivingEntityData for RaiderEntityData {
5998 fn living_entity(&self) -> &LivingEntityData {
5999 RaiderEntityData::living_entity(self)
6000 }
6001 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
6002 RaiderEntityData::living_entity_mut(self)
6003 }
6004}
6005#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
6006#[derive(Debug, Clone)]
6007pub struct SpellcasterIllagerEntityData {
6008 pub raider: RaiderEntityData,
6009 pub spell_casting: SyncedValue<i8>,
6010}
6011impl SpellcasterIllagerEntityData {
6012 #[doc = r" Create new entity data with default values."]
6013 pub fn new() -> Self {
6014 Self {
6015 raider: RaiderEntityData::new(),
6016 spell_casting: SyncedValue::new(0i8),
6017 }
6018 }
6019 #[doc = "Returns the `SpellcasterIllagerEntityData` layer."]
6020 pub fn spellcaster_illager(&self) -> &SpellcasterIllagerEntityData {
6021 self
6022 }
6023 #[doc = "Returns the mutable `SpellcasterIllagerEntityData` layer."]
6024 pub fn spellcaster_illager_mut(&mut self) -> &mut SpellcasterIllagerEntityData {
6025 self
6026 }
6027 #[doc = "Returns the `RaiderEntityData` layer."]
6028 pub fn raider(&self) -> &RaiderEntityData {
6029 &self.raider
6030 }
6031 #[doc = "Returns the mutable `RaiderEntityData` layer."]
6032 pub fn raider_mut(&mut self) -> &mut RaiderEntityData {
6033 &mut self.raider
6034 }
6035 #[doc = "Returns the `MobEntityData` layer."]
6036 pub fn mob(&self) -> &MobEntityData {
6037 &self.raider.mob
6038 }
6039 #[doc = "Returns the mutable `MobEntityData` layer."]
6040 pub fn mob_mut(&mut self) -> &mut MobEntityData {
6041 &mut self.raider.mob
6042 }
6043 #[doc = "Returns the `LivingEntityData` layer."]
6044 pub fn living_entity(&self) -> &LivingEntityData {
6045 &self.raider.mob.living_entity
6046 }
6047 #[doc = "Returns the mutable `LivingEntityData` layer."]
6048 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
6049 &mut self.raider.mob.living_entity
6050 }
6051 #[doc = "Returns the `BaseEntityData` layer."]
6052 pub fn base(&self) -> &BaseEntityData {
6053 &self.raider.mob.living_entity.base
6054 }
6055 #[doc = "Returns the mutable `BaseEntityData` layer."]
6056 pub fn base_mut(&mut self) -> &mut BaseEntityData {
6057 &mut self.raider.mob.living_entity.base
6058 }
6059 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
6060 #[doc = r" Returns `None` if no values are dirty."]
6061 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6062 let mut values = Vec::new();
6063 self.pack_dirty_into(&mut values);
6064 if values.is_empty() {
6065 None
6066 } else {
6067 Some(values)
6068 }
6069 }
6070 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
6071 self.raider.pack_dirty_into(values);
6072 if self.spell_casting.is_dirty() {
6073 values.push(DataValue {
6074 index: 17u8,
6075 serializer_id: 0i32,
6076 value: EntityData::Byte(*self.spell_casting.get()),
6077 });
6078 self.spell_casting.clear_dirty();
6079 }
6080 }
6081 #[doc = r" Pack all non-default values (for initial entity spawn)."]
6082 pub fn pack_all(&self) -> Vec<DataValue> {
6083 let mut values = Vec::new();
6084 self.pack_all_into(&mut values);
6085 values
6086 }
6087 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
6088 self.raider.pack_all_into(values);
6089 if !self.spell_casting.is_default() {
6090 values.push(DataValue {
6091 index: 17u8,
6092 serializer_id: 0i32,
6093 value: EntityData::Byte(*self.spell_casting.get()),
6094 });
6095 }
6096 }
6097 #[doc = r" Returns `true` if any field has been modified."]
6098 pub fn is_dirty(&self) -> bool {
6099 self.raider.is_dirty() || self.spell_casting.is_dirty()
6100 }
6101}
6102impl Default for SpellcasterIllagerEntityData {
6103 fn default() -> Self {
6104 Self::new()
6105 }
6106}
6107impl VanillaEntityData for SpellcasterIllagerEntityData {
6108 fn base(&self) -> &BaseEntityData {
6109 SpellcasterIllagerEntityData::base(self)
6110 }
6111 fn base_mut(&mut self) -> &mut BaseEntityData {
6112 SpellcasterIllagerEntityData::base_mut(self)
6113 }
6114 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6115 SpellcasterIllagerEntityData::pack_dirty(self)
6116 }
6117 fn pack_all(&self) -> Vec<DataValue> {
6118 SpellcasterIllagerEntityData::pack_all(self)
6119 }
6120 fn is_dirty(&self) -> bool {
6121 SpellcasterIllagerEntityData::is_dirty(self)
6122 }
6123}
6124impl VanillaLivingEntityData for SpellcasterIllagerEntityData {
6125 fn living_entity(&self) -> &LivingEntityData {
6126 SpellcasterIllagerEntityData::living_entity(self)
6127 }
6128 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
6129 SpellcasterIllagerEntityData::living_entity_mut(self)
6130 }
6131}
6132#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
6133#[derive(Debug, Clone)]
6134pub struct ExperienceOrbEntityData {
6135 pub base: BaseEntityData,
6136 pub value: SyncedValue<i32>,
6137}
6138impl ExperienceOrbEntityData {
6139 #[doc = r" Create new entity data with default values."]
6140 pub fn new() -> Self {
6141 Self {
6142 base: BaseEntityData::new(),
6143 value: SyncedValue::new(0i32),
6144 }
6145 }
6146 #[doc = "Returns the `ExperienceOrbEntityData` layer."]
6147 pub fn experience_orb(&self) -> &ExperienceOrbEntityData {
6148 self
6149 }
6150 #[doc = "Returns the mutable `ExperienceOrbEntityData` layer."]
6151 pub fn experience_orb_mut(&mut self) -> &mut ExperienceOrbEntityData {
6152 self
6153 }
6154 #[doc = "Returns the `BaseEntityData` layer."]
6155 pub fn base(&self) -> &BaseEntityData {
6156 &self.base
6157 }
6158 #[doc = "Returns the mutable `BaseEntityData` layer."]
6159 pub fn base_mut(&mut self) -> &mut BaseEntityData {
6160 &mut self.base
6161 }
6162 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
6163 #[doc = r" Returns `None` if no values are dirty."]
6164 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6165 let mut values = Vec::new();
6166 self.pack_dirty_into(&mut values);
6167 if values.is_empty() {
6168 None
6169 } else {
6170 Some(values)
6171 }
6172 }
6173 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
6174 self.base.pack_dirty_into(values);
6175 if self.value.is_dirty() {
6176 values.push(DataValue {
6177 index: 8u8,
6178 serializer_id: 1i32,
6179 value: EntityData::Int(*self.value.get()),
6180 });
6181 self.value.clear_dirty();
6182 }
6183 }
6184 #[doc = r" Pack all non-default values (for initial entity spawn)."]
6185 pub fn pack_all(&self) -> Vec<DataValue> {
6186 let mut values = Vec::new();
6187 self.pack_all_into(&mut values);
6188 values
6189 }
6190 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
6191 self.base.pack_all_into(values);
6192 if !self.value.is_default() {
6193 values.push(DataValue {
6194 index: 8u8,
6195 serializer_id: 1i32,
6196 value: EntityData::Int(*self.value.get()),
6197 });
6198 }
6199 }
6200 #[doc = r" Returns `true` if any field has been modified."]
6201 pub fn is_dirty(&self) -> bool {
6202 self.base.is_dirty() || self.value.is_dirty()
6203 }
6204}
6205impl Default for ExperienceOrbEntityData {
6206 fn default() -> Self {
6207 Self::new()
6208 }
6209}
6210impl VanillaEntityData for ExperienceOrbEntityData {
6211 fn base(&self) -> &BaseEntityData {
6212 ExperienceOrbEntityData::base(self)
6213 }
6214 fn base_mut(&mut self) -> &mut BaseEntityData {
6215 ExperienceOrbEntityData::base_mut(self)
6216 }
6217 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6218 ExperienceOrbEntityData::pack_dirty(self)
6219 }
6220 fn pack_all(&self) -> Vec<DataValue> {
6221 ExperienceOrbEntityData::pack_all(self)
6222 }
6223 fn is_dirty(&self) -> bool {
6224 ExperienceOrbEntityData::is_dirty(self)
6225 }
6226}
6227#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
6228#[derive(Debug, Clone)]
6229pub struct EyeOfEnderEntityData {
6230 pub base: BaseEntityData,
6231 pub item_stack: SyncedValue<ItemStack>,
6232}
6233impl EyeOfEnderEntityData {
6234 #[doc = r" Create new entity data with default values."]
6235 pub fn new() -> Self {
6236 Self {
6237 base: BaseEntityData::new(),
6238 item_stack: SyncedValue::new(ItemStack::with_count(
6239 &crate::vanilla_items::ITEMS.ender_eye,
6240 1i32,
6241 )),
6242 }
6243 }
6244 #[doc = "Returns the `EyeOfEnderEntityData` layer."]
6245 pub fn eye_of_ender(&self) -> &EyeOfEnderEntityData {
6246 self
6247 }
6248 #[doc = "Returns the mutable `EyeOfEnderEntityData` layer."]
6249 pub fn eye_of_ender_mut(&mut self) -> &mut EyeOfEnderEntityData {
6250 self
6251 }
6252 #[doc = "Returns the `BaseEntityData` layer."]
6253 pub fn base(&self) -> &BaseEntityData {
6254 &self.base
6255 }
6256 #[doc = "Returns the mutable `BaseEntityData` layer."]
6257 pub fn base_mut(&mut self) -> &mut BaseEntityData {
6258 &mut self.base
6259 }
6260 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
6261 #[doc = r" Returns `None` if no values are dirty."]
6262 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6263 let mut values = Vec::new();
6264 self.pack_dirty_into(&mut values);
6265 if values.is_empty() {
6266 None
6267 } else {
6268 Some(values)
6269 }
6270 }
6271 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
6272 self.base.pack_dirty_into(values);
6273 if self.item_stack.is_dirty() {
6274 values.push(DataValue {
6275 index: 8u8,
6276 serializer_id: 7i32,
6277 value: EntityData::ItemStack(self.item_stack.get().clone()),
6278 });
6279 self.item_stack.clear_dirty();
6280 }
6281 }
6282 #[doc = r" Pack all non-default values (for initial entity spawn)."]
6283 pub fn pack_all(&self) -> Vec<DataValue> {
6284 let mut values = Vec::new();
6285 self.pack_all_into(&mut values);
6286 values
6287 }
6288 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
6289 self.base.pack_all_into(values);
6290 if !self.item_stack.is_default() {
6291 values.push(DataValue {
6292 index: 8u8,
6293 serializer_id: 7i32,
6294 value: EntityData::ItemStack(self.item_stack.get().clone()),
6295 });
6296 }
6297 }
6298 #[doc = r" Returns `true` if any field has been modified."]
6299 pub fn is_dirty(&self) -> bool {
6300 self.base.is_dirty() || self.item_stack.is_dirty()
6301 }
6302}
6303impl Default for EyeOfEnderEntityData {
6304 fn default() -> Self {
6305 Self::new()
6306 }
6307}
6308impl VanillaEntityData for EyeOfEnderEntityData {
6309 fn base(&self) -> &BaseEntityData {
6310 EyeOfEnderEntityData::base(self)
6311 }
6312 fn base_mut(&mut self) -> &mut BaseEntityData {
6313 EyeOfEnderEntityData::base_mut(self)
6314 }
6315 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6316 EyeOfEnderEntityData::pack_dirty(self)
6317 }
6318 fn pack_all(&self) -> Vec<DataValue> {
6319 EyeOfEnderEntityData::pack_all(self)
6320 }
6321 fn is_dirty(&self) -> bool {
6322 EyeOfEnderEntityData::is_dirty(self)
6323 }
6324}
6325#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
6326#[derive(Debug, Clone)]
6327pub struct FallingBlockEntityData {
6328 pub base: BaseEntityData,
6329 pub start_pos: SyncedValue<BlockPos>,
6330}
6331impl FallingBlockEntityData {
6332 #[doc = r" Create new entity data with default values."]
6333 pub fn new() -> Self {
6334 Self {
6335 base: BaseEntityData::new(),
6336 start_pos: SyncedValue::new(BlockPos::new(0i32, 0i32, 0i32)),
6337 }
6338 }
6339 #[doc = "Returns the `FallingBlockEntityData` layer."]
6340 pub fn falling_block_entity(&self) -> &FallingBlockEntityData {
6341 self
6342 }
6343 #[doc = "Returns the mutable `FallingBlockEntityData` layer."]
6344 pub fn falling_block_entity_mut(&mut self) -> &mut FallingBlockEntityData {
6345 self
6346 }
6347 #[doc = "Returns the `BaseEntityData` layer."]
6348 pub fn base(&self) -> &BaseEntityData {
6349 &self.base
6350 }
6351 #[doc = "Returns the mutable `BaseEntityData` layer."]
6352 pub fn base_mut(&mut self) -> &mut BaseEntityData {
6353 &mut self.base
6354 }
6355 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
6356 #[doc = r" Returns `None` if no values are dirty."]
6357 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6358 let mut values = Vec::new();
6359 self.pack_dirty_into(&mut values);
6360 if values.is_empty() {
6361 None
6362 } else {
6363 Some(values)
6364 }
6365 }
6366 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
6367 self.base.pack_dirty_into(values);
6368 if self.start_pos.is_dirty() {
6369 values.push(DataValue {
6370 index: 8u8,
6371 serializer_id: 10i32,
6372 value: EntityData::BlockPos(*self.start_pos.get()),
6373 });
6374 self.start_pos.clear_dirty();
6375 }
6376 }
6377 #[doc = r" Pack all non-default values (for initial entity spawn)."]
6378 pub fn pack_all(&self) -> Vec<DataValue> {
6379 let mut values = Vec::new();
6380 self.pack_all_into(&mut values);
6381 values
6382 }
6383 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
6384 self.base.pack_all_into(values);
6385 if !self.start_pos.is_default() {
6386 values.push(DataValue {
6387 index: 8u8,
6388 serializer_id: 10i32,
6389 value: EntityData::BlockPos(*self.start_pos.get()),
6390 });
6391 }
6392 }
6393 #[doc = r" Returns `true` if any field has been modified."]
6394 pub fn is_dirty(&self) -> bool {
6395 self.base.is_dirty() || self.start_pos.is_dirty()
6396 }
6397}
6398impl Default for FallingBlockEntityData {
6399 fn default() -> Self {
6400 Self::new()
6401 }
6402}
6403impl VanillaEntityData for FallingBlockEntityData {
6404 fn base(&self) -> &BaseEntityData {
6405 FallingBlockEntityData::base(self)
6406 }
6407 fn base_mut(&mut self) -> &mut BaseEntityData {
6408 FallingBlockEntityData::base_mut(self)
6409 }
6410 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6411 FallingBlockEntityData::pack_dirty(self)
6412 }
6413 fn pack_all(&self) -> Vec<DataValue> {
6414 FallingBlockEntityData::pack_all(self)
6415 }
6416 fn is_dirty(&self) -> bool {
6417 FallingBlockEntityData::is_dirty(self)
6418 }
6419}
6420#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
6421#[derive(Debug, Clone)]
6422pub struct FireballEntityData {
6423 pub base: BaseEntityData,
6424 pub item_stack: SyncedValue<ItemStack>,
6425}
6426impl FireballEntityData {
6427 #[doc = r" Create new entity data with default values."]
6428 pub fn new() -> Self {
6429 Self {
6430 base: BaseEntityData::new(),
6431 item_stack: SyncedValue::new(ItemStack::with_count(
6432 &crate::vanilla_items::ITEMS.fire_charge,
6433 1i32,
6434 )),
6435 }
6436 }
6437 #[doc = "Returns the `FireballEntityData` layer."]
6438 pub fn fireball(&self) -> &FireballEntityData {
6439 self
6440 }
6441 #[doc = "Returns the mutable `FireballEntityData` layer."]
6442 pub fn fireball_mut(&mut self) -> &mut FireballEntityData {
6443 self
6444 }
6445 #[doc = "Returns the `BaseEntityData` layer."]
6446 pub fn base(&self) -> &BaseEntityData {
6447 &self.base
6448 }
6449 #[doc = "Returns the mutable `BaseEntityData` layer."]
6450 pub fn base_mut(&mut self) -> &mut BaseEntityData {
6451 &mut self.base
6452 }
6453 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
6454 #[doc = r" Returns `None` if no values are dirty."]
6455 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6456 let mut values = Vec::new();
6457 self.pack_dirty_into(&mut values);
6458 if values.is_empty() {
6459 None
6460 } else {
6461 Some(values)
6462 }
6463 }
6464 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
6465 self.base.pack_dirty_into(values);
6466 if self.item_stack.is_dirty() {
6467 values.push(DataValue {
6468 index: 8u8,
6469 serializer_id: 7i32,
6470 value: EntityData::ItemStack(self.item_stack.get().clone()),
6471 });
6472 self.item_stack.clear_dirty();
6473 }
6474 }
6475 #[doc = r" Pack all non-default values (for initial entity spawn)."]
6476 pub fn pack_all(&self) -> Vec<DataValue> {
6477 let mut values = Vec::new();
6478 self.pack_all_into(&mut values);
6479 values
6480 }
6481 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
6482 self.base.pack_all_into(values);
6483 if !self.item_stack.is_default() {
6484 values.push(DataValue {
6485 index: 8u8,
6486 serializer_id: 7i32,
6487 value: EntityData::ItemStack(self.item_stack.get().clone()),
6488 });
6489 }
6490 }
6491 #[doc = r" Returns `true` if any field has been modified."]
6492 pub fn is_dirty(&self) -> bool {
6493 self.base.is_dirty() || self.item_stack.is_dirty()
6494 }
6495}
6496impl Default for FireballEntityData {
6497 fn default() -> Self {
6498 Self::new()
6499 }
6500}
6501impl VanillaEntityData for FireballEntityData {
6502 fn base(&self) -> &BaseEntityData {
6503 FireballEntityData::base(self)
6504 }
6505 fn base_mut(&mut self) -> &mut BaseEntityData {
6506 FireballEntityData::base_mut(self)
6507 }
6508 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6509 FireballEntityData::pack_dirty(self)
6510 }
6511 fn pack_all(&self) -> Vec<DataValue> {
6512 FireballEntityData::pack_all(self)
6513 }
6514 fn is_dirty(&self) -> bool {
6515 FireballEntityData::is_dirty(self)
6516 }
6517}
6518#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
6519#[derive(Debug, Clone)]
6520pub struct FireworkRocketEntityData {
6521 pub base: BaseEntityData,
6522 pub id_fireworks_item: SyncedValue<ItemStack>,
6523 pub attached_to_target: SyncedValue<Option<u32>>,
6524 pub shot_at_angle: SyncedValue<bool>,
6525}
6526impl FireworkRocketEntityData {
6527 #[doc = r" Create new entity data with default values."]
6528 pub fn new() -> Self {
6529 Self {
6530 base: BaseEntityData::new(),
6531 id_fireworks_item: SyncedValue::new(ItemStack::with_count(
6532 &crate::vanilla_items::ITEMS.firework_rocket,
6533 1i32,
6534 )),
6535 attached_to_target: SyncedValue::new(None),
6536 shot_at_angle: SyncedValue::new(false),
6537 }
6538 }
6539 #[doc = "Returns the `FireworkRocketEntityData` layer."]
6540 pub fn firework_rocket_entity(&self) -> &FireworkRocketEntityData {
6541 self
6542 }
6543 #[doc = "Returns the mutable `FireworkRocketEntityData` layer."]
6544 pub fn firework_rocket_entity_mut(&mut self) -> &mut FireworkRocketEntityData {
6545 self
6546 }
6547 #[doc = "Returns the `BaseEntityData` layer."]
6548 pub fn base(&self) -> &BaseEntityData {
6549 &self.base
6550 }
6551 #[doc = "Returns the mutable `BaseEntityData` layer."]
6552 pub fn base_mut(&mut self) -> &mut BaseEntityData {
6553 &mut self.base
6554 }
6555 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
6556 #[doc = r" Returns `None` if no values are dirty."]
6557 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6558 let mut values = Vec::new();
6559 self.pack_dirty_into(&mut values);
6560 if values.is_empty() {
6561 None
6562 } else {
6563 Some(values)
6564 }
6565 }
6566 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
6567 self.base.pack_dirty_into(values);
6568 if self.id_fireworks_item.is_dirty() {
6569 values.push(DataValue {
6570 index: 8u8,
6571 serializer_id: 7i32,
6572 value: EntityData::ItemStack(self.id_fireworks_item.get().clone()),
6573 });
6574 self.id_fireworks_item.clear_dirty();
6575 }
6576 if self.attached_to_target.is_dirty() {
6577 values.push(DataValue {
6578 index: 9u8,
6579 serializer_id: 19i32,
6580 value: EntityData::OptionalUnsignedInt(self.attached_to_target.get().clone()),
6581 });
6582 self.attached_to_target.clear_dirty();
6583 }
6584 if self.shot_at_angle.is_dirty() {
6585 values.push(DataValue {
6586 index: 10u8,
6587 serializer_id: 8i32,
6588 value: EntityData::Boolean(*self.shot_at_angle.get()),
6589 });
6590 self.shot_at_angle.clear_dirty();
6591 }
6592 }
6593 #[doc = r" Pack all non-default values (for initial entity spawn)."]
6594 pub fn pack_all(&self) -> Vec<DataValue> {
6595 let mut values = Vec::new();
6596 self.pack_all_into(&mut values);
6597 values
6598 }
6599 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
6600 self.base.pack_all_into(values);
6601 if !self.id_fireworks_item.is_default() {
6602 values.push(DataValue {
6603 index: 8u8,
6604 serializer_id: 7i32,
6605 value: EntityData::ItemStack(self.id_fireworks_item.get().clone()),
6606 });
6607 }
6608 if !self.attached_to_target.is_default() {
6609 values.push(DataValue {
6610 index: 9u8,
6611 serializer_id: 19i32,
6612 value: EntityData::OptionalUnsignedInt(self.attached_to_target.get().clone()),
6613 });
6614 }
6615 if !self.shot_at_angle.is_default() {
6616 values.push(DataValue {
6617 index: 10u8,
6618 serializer_id: 8i32,
6619 value: EntityData::Boolean(*self.shot_at_angle.get()),
6620 });
6621 }
6622 }
6623 #[doc = r" Returns `true` if any field has been modified."]
6624 pub fn is_dirty(&self) -> bool {
6625 self.base.is_dirty()
6626 || self.id_fireworks_item.is_dirty()
6627 || self.attached_to_target.is_dirty()
6628 || self.shot_at_angle.is_dirty()
6629 }
6630}
6631impl Default for FireworkRocketEntityData {
6632 fn default() -> Self {
6633 Self::new()
6634 }
6635}
6636impl VanillaEntityData for FireworkRocketEntityData {
6637 fn base(&self) -> &BaseEntityData {
6638 FireworkRocketEntityData::base(self)
6639 }
6640 fn base_mut(&mut self) -> &mut BaseEntityData {
6641 FireworkRocketEntityData::base_mut(self)
6642 }
6643 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6644 FireworkRocketEntityData::pack_dirty(self)
6645 }
6646 fn pack_all(&self) -> Vec<DataValue> {
6647 FireworkRocketEntityData::pack_all(self)
6648 }
6649 fn is_dirty(&self) -> bool {
6650 FireworkRocketEntityData::is_dirty(self)
6651 }
6652}
6653#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
6654#[derive(Debug, Clone)]
6655pub struct FoxEntityData {
6656 pub ageable_mob: AgeableMobEntityData,
6657 pub variant_type: SyncedValue<i32>,
6658 pub flags: SyncedValue<i8>,
6659 pub trusted_id_0: SyncedValue<Option<Uuid>>,
6660 pub trusted_id_1: SyncedValue<Option<Uuid>>,
6661}
6662impl FoxEntityData {
6663 #[doc = r" Create new entity data with default values."]
6664 pub fn new() -> Self {
6665 Self {
6666 ageable_mob: AgeableMobEntityData::new(),
6667 variant_type: SyncedValue::new(0i32),
6668 flags: SyncedValue::new(0i8),
6669 trusted_id_0: SyncedValue::new(None),
6670 trusted_id_1: SyncedValue::new(None),
6671 }
6672 }
6673 #[doc = "Returns the `FoxEntityData` layer."]
6674 pub fn fox(&self) -> &FoxEntityData {
6675 self
6676 }
6677 #[doc = "Returns the mutable `FoxEntityData` layer."]
6678 pub fn fox_mut(&mut self) -> &mut FoxEntityData {
6679 self
6680 }
6681 #[doc = "Returns the `AgeableMobEntityData` layer."]
6682 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
6683 &self.ageable_mob
6684 }
6685 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
6686 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
6687 &mut self.ageable_mob
6688 }
6689 #[doc = "Returns the `MobEntityData` layer."]
6690 pub fn mob(&self) -> &MobEntityData {
6691 &self.ageable_mob.mob
6692 }
6693 #[doc = "Returns the mutable `MobEntityData` layer."]
6694 pub fn mob_mut(&mut self) -> &mut MobEntityData {
6695 &mut self.ageable_mob.mob
6696 }
6697 #[doc = "Returns the `LivingEntityData` layer."]
6698 pub fn living_entity(&self) -> &LivingEntityData {
6699 &self.ageable_mob.mob.living_entity
6700 }
6701 #[doc = "Returns the mutable `LivingEntityData` layer."]
6702 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
6703 &mut self.ageable_mob.mob.living_entity
6704 }
6705 #[doc = "Returns the `BaseEntityData` layer."]
6706 pub fn base(&self) -> &BaseEntityData {
6707 &self.ageable_mob.mob.living_entity.base
6708 }
6709 #[doc = "Returns the mutable `BaseEntityData` layer."]
6710 pub fn base_mut(&mut self) -> &mut BaseEntityData {
6711 &mut self.ageable_mob.mob.living_entity.base
6712 }
6713 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
6714 #[doc = r" Returns `None` if no values are dirty."]
6715 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6716 let mut values = Vec::new();
6717 self.pack_dirty_into(&mut values);
6718 if values.is_empty() {
6719 None
6720 } else {
6721 Some(values)
6722 }
6723 }
6724 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
6725 self.ageable_mob.pack_dirty_into(values);
6726 if self.variant_type.is_dirty() {
6727 values.push(DataValue {
6728 index: 18u8,
6729 serializer_id: 1i32,
6730 value: EntityData::Int(*self.variant_type.get()),
6731 });
6732 self.variant_type.clear_dirty();
6733 }
6734 if self.flags.is_dirty() {
6735 values.push(DataValue {
6736 index: 19u8,
6737 serializer_id: 0i32,
6738 value: EntityData::Byte(*self.flags.get()),
6739 });
6740 self.flags.clear_dirty();
6741 }
6742 if self.trusted_id_0.is_dirty() {
6743 values.push(DataValue {
6744 index: 20u8,
6745 serializer_id: 13i32,
6746 value: EntityData::OptionalLivingEntityRef(self.trusted_id_0.get().clone()),
6747 });
6748 self.trusted_id_0.clear_dirty();
6749 }
6750 if self.trusted_id_1.is_dirty() {
6751 values.push(DataValue {
6752 index: 21u8,
6753 serializer_id: 13i32,
6754 value: EntityData::OptionalLivingEntityRef(self.trusted_id_1.get().clone()),
6755 });
6756 self.trusted_id_1.clear_dirty();
6757 }
6758 }
6759 #[doc = r" Pack all non-default values (for initial entity spawn)."]
6760 pub fn pack_all(&self) -> Vec<DataValue> {
6761 let mut values = Vec::new();
6762 self.pack_all_into(&mut values);
6763 values
6764 }
6765 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
6766 self.ageable_mob.pack_all_into(values);
6767 if !self.variant_type.is_default() {
6768 values.push(DataValue {
6769 index: 18u8,
6770 serializer_id: 1i32,
6771 value: EntityData::Int(*self.variant_type.get()),
6772 });
6773 }
6774 if !self.flags.is_default() {
6775 values.push(DataValue {
6776 index: 19u8,
6777 serializer_id: 0i32,
6778 value: EntityData::Byte(*self.flags.get()),
6779 });
6780 }
6781 if !self.trusted_id_0.is_default() {
6782 values.push(DataValue {
6783 index: 20u8,
6784 serializer_id: 13i32,
6785 value: EntityData::OptionalLivingEntityRef(self.trusted_id_0.get().clone()),
6786 });
6787 }
6788 if !self.trusted_id_1.is_default() {
6789 values.push(DataValue {
6790 index: 21u8,
6791 serializer_id: 13i32,
6792 value: EntityData::OptionalLivingEntityRef(self.trusted_id_1.get().clone()),
6793 });
6794 }
6795 }
6796 #[doc = r" Returns `true` if any field has been modified."]
6797 pub fn is_dirty(&self) -> bool {
6798 self.ageable_mob.is_dirty()
6799 || self.variant_type.is_dirty()
6800 || self.flags.is_dirty()
6801 || self.trusted_id_0.is_dirty()
6802 || self.trusted_id_1.is_dirty()
6803 }
6804}
6805impl Default for FoxEntityData {
6806 fn default() -> Self {
6807 Self::new()
6808 }
6809}
6810impl VanillaEntityData for FoxEntityData {
6811 fn base(&self) -> &BaseEntityData {
6812 FoxEntityData::base(self)
6813 }
6814 fn base_mut(&mut self) -> &mut BaseEntityData {
6815 FoxEntityData::base_mut(self)
6816 }
6817 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6818 FoxEntityData::pack_dirty(self)
6819 }
6820 fn pack_all(&self) -> Vec<DataValue> {
6821 FoxEntityData::pack_all(self)
6822 }
6823 fn is_dirty(&self) -> bool {
6824 FoxEntityData::is_dirty(self)
6825 }
6826}
6827impl VanillaLivingEntityData for FoxEntityData {
6828 fn living_entity(&self) -> &LivingEntityData {
6829 FoxEntityData::living_entity(self)
6830 }
6831 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
6832 FoxEntityData::living_entity_mut(self)
6833 }
6834}
6835#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
6836#[derive(Debug, Clone)]
6837pub struct FrogEntityData {
6838 pub ageable_mob: AgeableMobEntityData,
6839 pub variant: SyncedValue<i32>,
6840 pub tongue_target: SyncedValue<Option<u32>>,
6841}
6842impl FrogEntityData {
6843 #[doc = r" Create new entity data with default values."]
6844 pub fn new() -> Self {
6845 Self {
6846 ageable_mob: AgeableMobEntityData::new(),
6847 variant: SyncedValue::new(0),
6848 tongue_target: SyncedValue::new(None),
6849 }
6850 }
6851 #[doc = "Returns the `FrogEntityData` layer."]
6852 pub fn frog(&self) -> &FrogEntityData {
6853 self
6854 }
6855 #[doc = "Returns the mutable `FrogEntityData` layer."]
6856 pub fn frog_mut(&mut self) -> &mut FrogEntityData {
6857 self
6858 }
6859 #[doc = "Returns the `AgeableMobEntityData` layer."]
6860 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
6861 &self.ageable_mob
6862 }
6863 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
6864 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
6865 &mut self.ageable_mob
6866 }
6867 #[doc = "Returns the `MobEntityData` layer."]
6868 pub fn mob(&self) -> &MobEntityData {
6869 &self.ageable_mob.mob
6870 }
6871 #[doc = "Returns the mutable `MobEntityData` layer."]
6872 pub fn mob_mut(&mut self) -> &mut MobEntityData {
6873 &mut self.ageable_mob.mob
6874 }
6875 #[doc = "Returns the `LivingEntityData` layer."]
6876 pub fn living_entity(&self) -> &LivingEntityData {
6877 &self.ageable_mob.mob.living_entity
6878 }
6879 #[doc = "Returns the mutable `LivingEntityData` layer."]
6880 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
6881 &mut self.ageable_mob.mob.living_entity
6882 }
6883 #[doc = "Returns the `BaseEntityData` layer."]
6884 pub fn base(&self) -> &BaseEntityData {
6885 &self.ageable_mob.mob.living_entity.base
6886 }
6887 #[doc = "Returns the mutable `BaseEntityData` layer."]
6888 pub fn base_mut(&mut self) -> &mut BaseEntityData {
6889 &mut self.ageable_mob.mob.living_entity.base
6890 }
6891 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
6892 #[doc = r" Returns `None` if no values are dirty."]
6893 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6894 let mut values = Vec::new();
6895 self.pack_dirty_into(&mut values);
6896 if values.is_empty() {
6897 None
6898 } else {
6899 Some(values)
6900 }
6901 }
6902 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
6903 self.ageable_mob.pack_dirty_into(values);
6904 if self.variant.is_dirty() {
6905 values.push(DataValue {
6906 index: 18u8,
6907 serializer_id: 27i32,
6908 value: EntityData::FrogVariant(*self.variant.get()),
6909 });
6910 self.variant.clear_dirty();
6911 }
6912 if self.tongue_target.is_dirty() {
6913 values.push(DataValue {
6914 index: 19u8,
6915 serializer_id: 19i32,
6916 value: EntityData::OptionalUnsignedInt(self.tongue_target.get().clone()),
6917 });
6918 self.tongue_target.clear_dirty();
6919 }
6920 }
6921 #[doc = r" Pack all non-default values (for initial entity spawn)."]
6922 pub fn pack_all(&self) -> Vec<DataValue> {
6923 let mut values = Vec::new();
6924 self.pack_all_into(&mut values);
6925 values
6926 }
6927 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
6928 self.ageable_mob.pack_all_into(values);
6929 if !self.variant.is_default() {
6930 values.push(DataValue {
6931 index: 18u8,
6932 serializer_id: 27i32,
6933 value: EntityData::FrogVariant(*self.variant.get()),
6934 });
6935 }
6936 if !self.tongue_target.is_default() {
6937 values.push(DataValue {
6938 index: 19u8,
6939 serializer_id: 19i32,
6940 value: EntityData::OptionalUnsignedInt(self.tongue_target.get().clone()),
6941 });
6942 }
6943 }
6944 #[doc = r" Returns `true` if any field has been modified."]
6945 pub fn is_dirty(&self) -> bool {
6946 self.ageable_mob.is_dirty() || self.variant.is_dirty() || self.tongue_target.is_dirty()
6947 }
6948}
6949impl Default for FrogEntityData {
6950 fn default() -> Self {
6951 Self::new()
6952 }
6953}
6954impl VanillaEntityData for FrogEntityData {
6955 fn base(&self) -> &BaseEntityData {
6956 FrogEntityData::base(self)
6957 }
6958 fn base_mut(&mut self) -> &mut BaseEntityData {
6959 FrogEntityData::base_mut(self)
6960 }
6961 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
6962 FrogEntityData::pack_dirty(self)
6963 }
6964 fn pack_all(&self) -> Vec<DataValue> {
6965 FrogEntityData::pack_all(self)
6966 }
6967 fn is_dirty(&self) -> bool {
6968 FrogEntityData::is_dirty(self)
6969 }
6970}
6971impl VanillaLivingEntityData for FrogEntityData {
6972 fn living_entity(&self) -> &LivingEntityData {
6973 FrogEntityData::living_entity(self)
6974 }
6975 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
6976 FrogEntityData::living_entity_mut(self)
6977 }
6978}
6979#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
6980#[derive(Debug, Clone)]
6981pub struct MinecartFurnaceEntityData {
6982 pub abstract_minecart: AbstractMinecartEntityData,
6983 pub id_fuel: SyncedValue<bool>,
6984}
6985impl MinecartFurnaceEntityData {
6986 #[doc = r" Create new entity data with default values."]
6987 pub fn new() -> Self {
6988 Self {
6989 abstract_minecart: AbstractMinecartEntityData::new(),
6990 id_fuel: SyncedValue::new(false),
6991 }
6992 }
6993 #[doc = "Returns the `MinecartFurnaceEntityData` layer."]
6994 pub fn minecart_furnace(&self) -> &MinecartFurnaceEntityData {
6995 self
6996 }
6997 #[doc = "Returns the mutable `MinecartFurnaceEntityData` layer."]
6998 pub fn minecart_furnace_mut(&mut self) -> &mut MinecartFurnaceEntityData {
6999 self
7000 }
7001 #[doc = "Returns the `AbstractMinecartEntityData` layer."]
7002 pub fn abstract_minecart(&self) -> &AbstractMinecartEntityData {
7003 &self.abstract_minecart
7004 }
7005 #[doc = "Returns the mutable `AbstractMinecartEntityData` layer."]
7006 pub fn abstract_minecart_mut(&mut self) -> &mut AbstractMinecartEntityData {
7007 &mut self.abstract_minecart
7008 }
7009 #[doc = "Returns the `VehicleEntityData` layer."]
7010 pub fn vehicle_entity(&self) -> &VehicleEntityData {
7011 &self.abstract_minecart.vehicle_entity
7012 }
7013 #[doc = "Returns the mutable `VehicleEntityData` layer."]
7014 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
7015 &mut self.abstract_minecart.vehicle_entity
7016 }
7017 #[doc = "Returns the `BaseEntityData` layer."]
7018 pub fn base(&self) -> &BaseEntityData {
7019 &self.abstract_minecart.vehicle_entity.base
7020 }
7021 #[doc = "Returns the mutable `BaseEntityData` layer."]
7022 pub fn base_mut(&mut self) -> &mut BaseEntityData {
7023 &mut self.abstract_minecart.vehicle_entity.base
7024 }
7025 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
7026 #[doc = r" Returns `None` if no values are dirty."]
7027 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7028 let mut values = Vec::new();
7029 self.pack_dirty_into(&mut values);
7030 if values.is_empty() {
7031 None
7032 } else {
7033 Some(values)
7034 }
7035 }
7036 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
7037 self.abstract_minecart.pack_dirty_into(values);
7038 if self.id_fuel.is_dirty() {
7039 values.push(DataValue {
7040 index: 13u8,
7041 serializer_id: 8i32,
7042 value: EntityData::Boolean(*self.id_fuel.get()),
7043 });
7044 self.id_fuel.clear_dirty();
7045 }
7046 }
7047 #[doc = r" Pack all non-default values (for initial entity spawn)."]
7048 pub fn pack_all(&self) -> Vec<DataValue> {
7049 let mut values = Vec::new();
7050 self.pack_all_into(&mut values);
7051 values
7052 }
7053 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
7054 self.abstract_minecart.pack_all_into(values);
7055 if !self.id_fuel.is_default() {
7056 values.push(DataValue {
7057 index: 13u8,
7058 serializer_id: 8i32,
7059 value: EntityData::Boolean(*self.id_fuel.get()),
7060 });
7061 }
7062 }
7063 #[doc = r" Returns `true` if any field has been modified."]
7064 pub fn is_dirty(&self) -> bool {
7065 self.abstract_minecart.is_dirty() || self.id_fuel.is_dirty()
7066 }
7067}
7068impl Default for MinecartFurnaceEntityData {
7069 fn default() -> Self {
7070 Self::new()
7071 }
7072}
7073impl VanillaEntityData for MinecartFurnaceEntityData {
7074 fn base(&self) -> &BaseEntityData {
7075 MinecartFurnaceEntityData::base(self)
7076 }
7077 fn base_mut(&mut self) -> &mut BaseEntityData {
7078 MinecartFurnaceEntityData::base_mut(self)
7079 }
7080 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7081 MinecartFurnaceEntityData::pack_dirty(self)
7082 }
7083 fn pack_all(&self) -> Vec<DataValue> {
7084 MinecartFurnaceEntityData::pack_all(self)
7085 }
7086 fn is_dirty(&self) -> bool {
7087 MinecartFurnaceEntityData::is_dirty(self)
7088 }
7089}
7090#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
7091#[derive(Debug, Clone)]
7092pub struct GhastEntityData {
7093 pub mob: MobEntityData,
7094 pub is_charging: SyncedValue<bool>,
7095}
7096impl GhastEntityData {
7097 #[doc = r" Create new entity data with default values."]
7098 pub fn new() -> Self {
7099 Self {
7100 mob: MobEntityData::new(),
7101 is_charging: SyncedValue::new(false),
7102 }
7103 }
7104 #[doc = "Returns the `GhastEntityData` layer."]
7105 pub fn ghast(&self) -> &GhastEntityData {
7106 self
7107 }
7108 #[doc = "Returns the mutable `GhastEntityData` layer."]
7109 pub fn ghast_mut(&mut self) -> &mut GhastEntityData {
7110 self
7111 }
7112 #[doc = "Returns the `MobEntityData` layer."]
7113 pub fn mob(&self) -> &MobEntityData {
7114 &self.mob
7115 }
7116 #[doc = "Returns the mutable `MobEntityData` layer."]
7117 pub fn mob_mut(&mut self) -> &mut MobEntityData {
7118 &mut self.mob
7119 }
7120 #[doc = "Returns the `LivingEntityData` layer."]
7121 pub fn living_entity(&self) -> &LivingEntityData {
7122 &self.mob.living_entity
7123 }
7124 #[doc = "Returns the mutable `LivingEntityData` layer."]
7125 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
7126 &mut self.mob.living_entity
7127 }
7128 #[doc = "Returns the `BaseEntityData` layer."]
7129 pub fn base(&self) -> &BaseEntityData {
7130 &self.mob.living_entity.base
7131 }
7132 #[doc = "Returns the mutable `BaseEntityData` layer."]
7133 pub fn base_mut(&mut self) -> &mut BaseEntityData {
7134 &mut self.mob.living_entity.base
7135 }
7136 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
7137 #[doc = r" Returns `None` if no values are dirty."]
7138 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7139 let mut values = Vec::new();
7140 self.pack_dirty_into(&mut values);
7141 if values.is_empty() {
7142 None
7143 } else {
7144 Some(values)
7145 }
7146 }
7147 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
7148 self.mob.pack_dirty_into(values);
7149 if self.is_charging.is_dirty() {
7150 values.push(DataValue {
7151 index: 16u8,
7152 serializer_id: 8i32,
7153 value: EntityData::Boolean(*self.is_charging.get()),
7154 });
7155 self.is_charging.clear_dirty();
7156 }
7157 }
7158 #[doc = r" Pack all non-default values (for initial entity spawn)."]
7159 pub fn pack_all(&self) -> Vec<DataValue> {
7160 let mut values = Vec::new();
7161 self.pack_all_into(&mut values);
7162 values
7163 }
7164 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
7165 self.mob.pack_all_into(values);
7166 if !self.is_charging.is_default() {
7167 values.push(DataValue {
7168 index: 16u8,
7169 serializer_id: 8i32,
7170 value: EntityData::Boolean(*self.is_charging.get()),
7171 });
7172 }
7173 }
7174 #[doc = r" Returns `true` if any field has been modified."]
7175 pub fn is_dirty(&self) -> bool {
7176 self.mob.is_dirty() || self.is_charging.is_dirty()
7177 }
7178}
7179impl Default for GhastEntityData {
7180 fn default() -> Self {
7181 Self::new()
7182 }
7183}
7184impl VanillaEntityData for GhastEntityData {
7185 fn base(&self) -> &BaseEntityData {
7186 GhastEntityData::base(self)
7187 }
7188 fn base_mut(&mut self) -> &mut BaseEntityData {
7189 GhastEntityData::base_mut(self)
7190 }
7191 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7192 GhastEntityData::pack_dirty(self)
7193 }
7194 fn pack_all(&self) -> Vec<DataValue> {
7195 GhastEntityData::pack_all(self)
7196 }
7197 fn is_dirty(&self) -> bool {
7198 GhastEntityData::is_dirty(self)
7199 }
7200}
7201impl VanillaLivingEntityData for GhastEntityData {
7202 fn living_entity(&self) -> &LivingEntityData {
7203 GhastEntityData::living_entity(self)
7204 }
7205 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
7206 GhastEntityData::living_entity_mut(self)
7207 }
7208}
7209#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
7210#[derive(Debug, Clone)]
7211pub struct HappyGhastEntityData {
7212 pub ageable_mob: AgeableMobEntityData,
7213 pub is_leash_holder: SyncedValue<bool>,
7214 pub stays_still: SyncedValue<bool>,
7215}
7216impl HappyGhastEntityData {
7217 #[doc = r" Create new entity data with default values."]
7218 pub fn new() -> Self {
7219 Self {
7220 ageable_mob: AgeableMobEntityData::new(),
7221 is_leash_holder: SyncedValue::new(false),
7222 stays_still: SyncedValue::new(false),
7223 }
7224 }
7225 #[doc = "Returns the `HappyGhastEntityData` layer."]
7226 pub fn happy_ghast(&self) -> &HappyGhastEntityData {
7227 self
7228 }
7229 #[doc = "Returns the mutable `HappyGhastEntityData` layer."]
7230 pub fn happy_ghast_mut(&mut self) -> &mut HappyGhastEntityData {
7231 self
7232 }
7233 #[doc = "Returns the `AgeableMobEntityData` layer."]
7234 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
7235 &self.ageable_mob
7236 }
7237 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
7238 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
7239 &mut self.ageable_mob
7240 }
7241 #[doc = "Returns the `MobEntityData` layer."]
7242 pub fn mob(&self) -> &MobEntityData {
7243 &self.ageable_mob.mob
7244 }
7245 #[doc = "Returns the mutable `MobEntityData` layer."]
7246 pub fn mob_mut(&mut self) -> &mut MobEntityData {
7247 &mut self.ageable_mob.mob
7248 }
7249 #[doc = "Returns the `LivingEntityData` layer."]
7250 pub fn living_entity(&self) -> &LivingEntityData {
7251 &self.ageable_mob.mob.living_entity
7252 }
7253 #[doc = "Returns the mutable `LivingEntityData` layer."]
7254 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
7255 &mut self.ageable_mob.mob.living_entity
7256 }
7257 #[doc = "Returns the `BaseEntityData` layer."]
7258 pub fn base(&self) -> &BaseEntityData {
7259 &self.ageable_mob.mob.living_entity.base
7260 }
7261 #[doc = "Returns the mutable `BaseEntityData` layer."]
7262 pub fn base_mut(&mut self) -> &mut BaseEntityData {
7263 &mut self.ageable_mob.mob.living_entity.base
7264 }
7265 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
7266 #[doc = r" Returns `None` if no values are dirty."]
7267 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7268 let mut values = Vec::new();
7269 self.pack_dirty_into(&mut values);
7270 if values.is_empty() {
7271 None
7272 } else {
7273 Some(values)
7274 }
7275 }
7276 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
7277 self.ageable_mob.pack_dirty_into(values);
7278 if self.is_leash_holder.is_dirty() {
7279 values.push(DataValue {
7280 index: 18u8,
7281 serializer_id: 8i32,
7282 value: EntityData::Boolean(*self.is_leash_holder.get()),
7283 });
7284 self.is_leash_holder.clear_dirty();
7285 }
7286 if self.stays_still.is_dirty() {
7287 values.push(DataValue {
7288 index: 19u8,
7289 serializer_id: 8i32,
7290 value: EntityData::Boolean(*self.stays_still.get()),
7291 });
7292 self.stays_still.clear_dirty();
7293 }
7294 }
7295 #[doc = r" Pack all non-default values (for initial entity spawn)."]
7296 pub fn pack_all(&self) -> Vec<DataValue> {
7297 let mut values = Vec::new();
7298 self.pack_all_into(&mut values);
7299 values
7300 }
7301 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
7302 self.ageable_mob.pack_all_into(values);
7303 if !self.is_leash_holder.is_default() {
7304 values.push(DataValue {
7305 index: 18u8,
7306 serializer_id: 8i32,
7307 value: EntityData::Boolean(*self.is_leash_holder.get()),
7308 });
7309 }
7310 if !self.stays_still.is_default() {
7311 values.push(DataValue {
7312 index: 19u8,
7313 serializer_id: 8i32,
7314 value: EntityData::Boolean(*self.stays_still.get()),
7315 });
7316 }
7317 }
7318 #[doc = r" Returns `true` if any field has been modified."]
7319 pub fn is_dirty(&self) -> bool {
7320 self.ageable_mob.is_dirty()
7321 || self.is_leash_holder.is_dirty()
7322 || self.stays_still.is_dirty()
7323 }
7324}
7325impl Default for HappyGhastEntityData {
7326 fn default() -> Self {
7327 Self::new()
7328 }
7329}
7330impl VanillaEntityData for HappyGhastEntityData {
7331 fn base(&self) -> &BaseEntityData {
7332 HappyGhastEntityData::base(self)
7333 }
7334 fn base_mut(&mut self) -> &mut BaseEntityData {
7335 HappyGhastEntityData::base_mut(self)
7336 }
7337 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7338 HappyGhastEntityData::pack_dirty(self)
7339 }
7340 fn pack_all(&self) -> Vec<DataValue> {
7341 HappyGhastEntityData::pack_all(self)
7342 }
7343 fn is_dirty(&self) -> bool {
7344 HappyGhastEntityData::is_dirty(self)
7345 }
7346}
7347impl VanillaLivingEntityData for HappyGhastEntityData {
7348 fn living_entity(&self) -> &LivingEntityData {
7349 HappyGhastEntityData::living_entity(self)
7350 }
7351 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
7352 HappyGhastEntityData::living_entity_mut(self)
7353 }
7354}
7355#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
7356#[derive(Debug, Clone)]
7357pub struct HangingEntityData {
7358 pub base: BaseEntityData,
7359 pub direction: SyncedValue<Direction>,
7360}
7361impl HangingEntityData {
7362 #[doc = r" Create new entity data with default values."]
7363 pub fn new() -> Self {
7364 Self {
7365 base: BaseEntityData::new(),
7366 direction: SyncedValue::new(Direction::South),
7367 }
7368 }
7369 #[doc = "Returns the `HangingEntityData` layer."]
7370 pub fn hanging_entity(&self) -> &HangingEntityData {
7371 self
7372 }
7373 #[doc = "Returns the mutable `HangingEntityData` layer."]
7374 pub fn hanging_entity_mut(&mut self) -> &mut HangingEntityData {
7375 self
7376 }
7377 #[doc = "Returns the `BaseEntityData` layer."]
7378 pub fn base(&self) -> &BaseEntityData {
7379 &self.base
7380 }
7381 #[doc = "Returns the mutable `BaseEntityData` layer."]
7382 pub fn base_mut(&mut self) -> &mut BaseEntityData {
7383 &mut self.base
7384 }
7385 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
7386 #[doc = r" Returns `None` if no values are dirty."]
7387 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7388 let mut values = Vec::new();
7389 self.pack_dirty_into(&mut values);
7390 if values.is_empty() {
7391 None
7392 } else {
7393 Some(values)
7394 }
7395 }
7396 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
7397 self.base.pack_dirty_into(values);
7398 if self.direction.is_dirty() {
7399 values.push(DataValue {
7400 index: 8u8,
7401 serializer_id: 12i32,
7402 value: EntityData::Direction(*self.direction.get()),
7403 });
7404 self.direction.clear_dirty();
7405 }
7406 }
7407 #[doc = r" Pack all non-default values (for initial entity spawn)."]
7408 pub fn pack_all(&self) -> Vec<DataValue> {
7409 let mut values = Vec::new();
7410 self.pack_all_into(&mut values);
7411 values
7412 }
7413 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
7414 self.base.pack_all_into(values);
7415 if !self.direction.is_default() {
7416 values.push(DataValue {
7417 index: 8u8,
7418 serializer_id: 12i32,
7419 value: EntityData::Direction(*self.direction.get()),
7420 });
7421 }
7422 }
7423 #[doc = r" Returns `true` if any field has been modified."]
7424 pub fn is_dirty(&self) -> bool {
7425 self.base.is_dirty() || self.direction.is_dirty()
7426 }
7427}
7428impl Default for HangingEntityData {
7429 fn default() -> Self {
7430 Self::new()
7431 }
7432}
7433impl VanillaEntityData for HangingEntityData {
7434 fn base(&self) -> &BaseEntityData {
7435 HangingEntityData::base(self)
7436 }
7437 fn base_mut(&mut self) -> &mut BaseEntityData {
7438 HangingEntityData::base_mut(self)
7439 }
7440 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7441 HangingEntityData::pack_dirty(self)
7442 }
7443 fn pack_all(&self) -> Vec<DataValue> {
7444 HangingEntityData::pack_all(self)
7445 }
7446 fn is_dirty(&self) -> bool {
7447 HangingEntityData::is_dirty(self)
7448 }
7449}
7450#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
7451#[derive(Debug, Clone)]
7452pub struct ItemFrameEntityData {
7453 pub hanging_entity: HangingEntityData,
7454 pub item: SyncedValue<ItemStack>,
7455 pub rotation: SyncedValue<i32>,
7456}
7457impl ItemFrameEntityData {
7458 #[doc = r" Create new entity data with default values."]
7459 pub fn new() -> Self {
7460 Self {
7461 hanging_entity: HangingEntityData::new(),
7462 item: SyncedValue::new(ItemStack::empty()),
7463 rotation: SyncedValue::new(0i32),
7464 }
7465 }
7466 #[doc = "Returns the `ItemFrameEntityData` layer."]
7467 pub fn item_frame(&self) -> &ItemFrameEntityData {
7468 self
7469 }
7470 #[doc = "Returns the mutable `ItemFrameEntityData` layer."]
7471 pub fn item_frame_mut(&mut self) -> &mut ItemFrameEntityData {
7472 self
7473 }
7474 #[doc = "Returns the `HangingEntityData` layer."]
7475 pub fn hanging_entity(&self) -> &HangingEntityData {
7476 &self.hanging_entity
7477 }
7478 #[doc = "Returns the mutable `HangingEntityData` layer."]
7479 pub fn hanging_entity_mut(&mut self) -> &mut HangingEntityData {
7480 &mut self.hanging_entity
7481 }
7482 #[doc = "Returns the `BaseEntityData` layer."]
7483 pub fn base(&self) -> &BaseEntityData {
7484 &self.hanging_entity.base
7485 }
7486 #[doc = "Returns the mutable `BaseEntityData` layer."]
7487 pub fn base_mut(&mut self) -> &mut BaseEntityData {
7488 &mut self.hanging_entity.base
7489 }
7490 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
7491 #[doc = r" Returns `None` if no values are dirty."]
7492 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7493 let mut values = Vec::new();
7494 self.pack_dirty_into(&mut values);
7495 if values.is_empty() {
7496 None
7497 } else {
7498 Some(values)
7499 }
7500 }
7501 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
7502 self.hanging_entity.pack_dirty_into(values);
7503 if self.item.is_dirty() {
7504 values.push(DataValue {
7505 index: 9u8,
7506 serializer_id: 7i32,
7507 value: EntityData::ItemStack(self.item.get().clone()),
7508 });
7509 self.item.clear_dirty();
7510 }
7511 if self.rotation.is_dirty() {
7512 values.push(DataValue {
7513 index: 10u8,
7514 serializer_id: 1i32,
7515 value: EntityData::Int(*self.rotation.get()),
7516 });
7517 self.rotation.clear_dirty();
7518 }
7519 }
7520 #[doc = r" Pack all non-default values (for initial entity spawn)."]
7521 pub fn pack_all(&self) -> Vec<DataValue> {
7522 let mut values = Vec::new();
7523 self.pack_all_into(&mut values);
7524 values
7525 }
7526 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
7527 self.hanging_entity.pack_all_into(values);
7528 if !self.item.is_default() {
7529 values.push(DataValue {
7530 index: 9u8,
7531 serializer_id: 7i32,
7532 value: EntityData::ItemStack(self.item.get().clone()),
7533 });
7534 }
7535 if !self.rotation.is_default() {
7536 values.push(DataValue {
7537 index: 10u8,
7538 serializer_id: 1i32,
7539 value: EntityData::Int(*self.rotation.get()),
7540 });
7541 }
7542 }
7543 #[doc = r" Returns `true` if any field has been modified."]
7544 pub fn is_dirty(&self) -> bool {
7545 self.hanging_entity.is_dirty() || self.item.is_dirty() || self.rotation.is_dirty()
7546 }
7547}
7548impl Default for ItemFrameEntityData {
7549 fn default() -> Self {
7550 Self::new()
7551 }
7552}
7553impl VanillaEntityData for ItemFrameEntityData {
7554 fn base(&self) -> &BaseEntityData {
7555 ItemFrameEntityData::base(self)
7556 }
7557 fn base_mut(&mut self) -> &mut BaseEntityData {
7558 ItemFrameEntityData::base_mut(self)
7559 }
7560 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7561 ItemFrameEntityData::pack_dirty(self)
7562 }
7563 fn pack_all(&self) -> Vec<DataValue> {
7564 ItemFrameEntityData::pack_all(self)
7565 }
7566 fn is_dirty(&self) -> bool {
7567 ItemFrameEntityData::is_dirty(self)
7568 }
7569}
7570#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
7571#[derive(Debug, Clone)]
7572pub struct GlowSquidEntityData {
7573 pub ageable_mob: AgeableMobEntityData,
7574 pub dark_ticks_remaining: SyncedValue<i32>,
7575}
7576impl GlowSquidEntityData {
7577 #[doc = r" Create new entity data with default values."]
7578 pub fn new() -> Self {
7579 Self {
7580 ageable_mob: AgeableMobEntityData::new(),
7581 dark_ticks_remaining: SyncedValue::new(0i32),
7582 }
7583 }
7584 #[doc = "Returns the `GlowSquidEntityData` layer."]
7585 pub fn glow_squid(&self) -> &GlowSquidEntityData {
7586 self
7587 }
7588 #[doc = "Returns the mutable `GlowSquidEntityData` layer."]
7589 pub fn glow_squid_mut(&mut self) -> &mut GlowSquidEntityData {
7590 self
7591 }
7592 #[doc = "Returns the `AgeableMobEntityData` layer."]
7593 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
7594 &self.ageable_mob
7595 }
7596 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
7597 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
7598 &mut self.ageable_mob
7599 }
7600 #[doc = "Returns the `MobEntityData` layer."]
7601 pub fn mob(&self) -> &MobEntityData {
7602 &self.ageable_mob.mob
7603 }
7604 #[doc = "Returns the mutable `MobEntityData` layer."]
7605 pub fn mob_mut(&mut self) -> &mut MobEntityData {
7606 &mut self.ageable_mob.mob
7607 }
7608 #[doc = "Returns the `LivingEntityData` layer."]
7609 pub fn living_entity(&self) -> &LivingEntityData {
7610 &self.ageable_mob.mob.living_entity
7611 }
7612 #[doc = "Returns the mutable `LivingEntityData` layer."]
7613 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
7614 &mut self.ageable_mob.mob.living_entity
7615 }
7616 #[doc = "Returns the `BaseEntityData` layer."]
7617 pub fn base(&self) -> &BaseEntityData {
7618 &self.ageable_mob.mob.living_entity.base
7619 }
7620 #[doc = "Returns the mutable `BaseEntityData` layer."]
7621 pub fn base_mut(&mut self) -> &mut BaseEntityData {
7622 &mut self.ageable_mob.mob.living_entity.base
7623 }
7624 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
7625 #[doc = r" Returns `None` if no values are dirty."]
7626 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7627 let mut values = Vec::new();
7628 self.pack_dirty_into(&mut values);
7629 if values.is_empty() {
7630 None
7631 } else {
7632 Some(values)
7633 }
7634 }
7635 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
7636 self.ageable_mob.pack_dirty_into(values);
7637 if self.dark_ticks_remaining.is_dirty() {
7638 values.push(DataValue {
7639 index: 18u8,
7640 serializer_id: 1i32,
7641 value: EntityData::Int(*self.dark_ticks_remaining.get()),
7642 });
7643 self.dark_ticks_remaining.clear_dirty();
7644 }
7645 }
7646 #[doc = r" Pack all non-default values (for initial entity spawn)."]
7647 pub fn pack_all(&self) -> Vec<DataValue> {
7648 let mut values = Vec::new();
7649 self.pack_all_into(&mut values);
7650 values
7651 }
7652 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
7653 self.ageable_mob.pack_all_into(values);
7654 if !self.dark_ticks_remaining.is_default() {
7655 values.push(DataValue {
7656 index: 18u8,
7657 serializer_id: 1i32,
7658 value: EntityData::Int(*self.dark_ticks_remaining.get()),
7659 });
7660 }
7661 }
7662 #[doc = r" Returns `true` if any field has been modified."]
7663 pub fn is_dirty(&self) -> bool {
7664 self.ageable_mob.is_dirty() || self.dark_ticks_remaining.is_dirty()
7665 }
7666}
7667impl Default for GlowSquidEntityData {
7668 fn default() -> Self {
7669 Self::new()
7670 }
7671}
7672impl VanillaEntityData for GlowSquidEntityData {
7673 fn base(&self) -> &BaseEntityData {
7674 GlowSquidEntityData::base(self)
7675 }
7676 fn base_mut(&mut self) -> &mut BaseEntityData {
7677 GlowSquidEntityData::base_mut(self)
7678 }
7679 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7680 GlowSquidEntityData::pack_dirty(self)
7681 }
7682 fn pack_all(&self) -> Vec<DataValue> {
7683 GlowSquidEntityData::pack_all(self)
7684 }
7685 fn is_dirty(&self) -> bool {
7686 GlowSquidEntityData::is_dirty(self)
7687 }
7688}
7689impl VanillaLivingEntityData for GlowSquidEntityData {
7690 fn living_entity(&self) -> &LivingEntityData {
7691 GlowSquidEntityData::living_entity(self)
7692 }
7693 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
7694 GlowSquidEntityData::living_entity_mut(self)
7695 }
7696}
7697#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
7698#[derive(Debug, Clone)]
7699pub struct GoatEntityData {
7700 pub ageable_mob: AgeableMobEntityData,
7701 pub is_screaming_goat: SyncedValue<bool>,
7702 pub has_left_horn: SyncedValue<bool>,
7703 pub has_right_horn: SyncedValue<bool>,
7704}
7705impl GoatEntityData {
7706 #[doc = r" Create new entity data with default values."]
7707 pub fn new() -> Self {
7708 Self {
7709 ageable_mob: AgeableMobEntityData::new(),
7710 is_screaming_goat: SyncedValue::new(false),
7711 has_left_horn: SyncedValue::new(true),
7712 has_right_horn: SyncedValue::new(true),
7713 }
7714 }
7715 #[doc = "Returns the `GoatEntityData` layer."]
7716 pub fn goat(&self) -> &GoatEntityData {
7717 self
7718 }
7719 #[doc = "Returns the mutable `GoatEntityData` layer."]
7720 pub fn goat_mut(&mut self) -> &mut GoatEntityData {
7721 self
7722 }
7723 #[doc = "Returns the `AgeableMobEntityData` layer."]
7724 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
7725 &self.ageable_mob
7726 }
7727 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
7728 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
7729 &mut self.ageable_mob
7730 }
7731 #[doc = "Returns the `MobEntityData` layer."]
7732 pub fn mob(&self) -> &MobEntityData {
7733 &self.ageable_mob.mob
7734 }
7735 #[doc = "Returns the mutable `MobEntityData` layer."]
7736 pub fn mob_mut(&mut self) -> &mut MobEntityData {
7737 &mut self.ageable_mob.mob
7738 }
7739 #[doc = "Returns the `LivingEntityData` layer."]
7740 pub fn living_entity(&self) -> &LivingEntityData {
7741 &self.ageable_mob.mob.living_entity
7742 }
7743 #[doc = "Returns the mutable `LivingEntityData` layer."]
7744 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
7745 &mut self.ageable_mob.mob.living_entity
7746 }
7747 #[doc = "Returns the `BaseEntityData` layer."]
7748 pub fn base(&self) -> &BaseEntityData {
7749 &self.ageable_mob.mob.living_entity.base
7750 }
7751 #[doc = "Returns the mutable `BaseEntityData` layer."]
7752 pub fn base_mut(&mut self) -> &mut BaseEntityData {
7753 &mut self.ageable_mob.mob.living_entity.base
7754 }
7755 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
7756 #[doc = r" Returns `None` if no values are dirty."]
7757 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7758 let mut values = Vec::new();
7759 self.pack_dirty_into(&mut values);
7760 if values.is_empty() {
7761 None
7762 } else {
7763 Some(values)
7764 }
7765 }
7766 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
7767 self.ageable_mob.pack_dirty_into(values);
7768 if self.is_screaming_goat.is_dirty() {
7769 values.push(DataValue {
7770 index: 18u8,
7771 serializer_id: 8i32,
7772 value: EntityData::Boolean(*self.is_screaming_goat.get()),
7773 });
7774 self.is_screaming_goat.clear_dirty();
7775 }
7776 if self.has_left_horn.is_dirty() {
7777 values.push(DataValue {
7778 index: 19u8,
7779 serializer_id: 8i32,
7780 value: EntityData::Boolean(*self.has_left_horn.get()),
7781 });
7782 self.has_left_horn.clear_dirty();
7783 }
7784 if self.has_right_horn.is_dirty() {
7785 values.push(DataValue {
7786 index: 20u8,
7787 serializer_id: 8i32,
7788 value: EntityData::Boolean(*self.has_right_horn.get()),
7789 });
7790 self.has_right_horn.clear_dirty();
7791 }
7792 }
7793 #[doc = r" Pack all non-default values (for initial entity spawn)."]
7794 pub fn pack_all(&self) -> Vec<DataValue> {
7795 let mut values = Vec::new();
7796 self.pack_all_into(&mut values);
7797 values
7798 }
7799 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
7800 self.ageable_mob.pack_all_into(values);
7801 if !self.is_screaming_goat.is_default() {
7802 values.push(DataValue {
7803 index: 18u8,
7804 serializer_id: 8i32,
7805 value: EntityData::Boolean(*self.is_screaming_goat.get()),
7806 });
7807 }
7808 if !self.has_left_horn.is_default() {
7809 values.push(DataValue {
7810 index: 19u8,
7811 serializer_id: 8i32,
7812 value: EntityData::Boolean(*self.has_left_horn.get()),
7813 });
7814 }
7815 if !self.has_right_horn.is_default() {
7816 values.push(DataValue {
7817 index: 20u8,
7818 serializer_id: 8i32,
7819 value: EntityData::Boolean(*self.has_right_horn.get()),
7820 });
7821 }
7822 }
7823 #[doc = r" Returns `true` if any field has been modified."]
7824 pub fn is_dirty(&self) -> bool {
7825 self.ageable_mob.is_dirty()
7826 || self.is_screaming_goat.is_dirty()
7827 || self.has_left_horn.is_dirty()
7828 || self.has_right_horn.is_dirty()
7829 }
7830}
7831impl Default for GoatEntityData {
7832 fn default() -> Self {
7833 Self::new()
7834 }
7835}
7836impl VanillaEntityData for GoatEntityData {
7837 fn base(&self) -> &BaseEntityData {
7838 GoatEntityData::base(self)
7839 }
7840 fn base_mut(&mut self) -> &mut BaseEntityData {
7841 GoatEntityData::base_mut(self)
7842 }
7843 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7844 GoatEntityData::pack_dirty(self)
7845 }
7846 fn pack_all(&self) -> Vec<DataValue> {
7847 GoatEntityData::pack_all(self)
7848 }
7849 fn is_dirty(&self) -> bool {
7850 GoatEntityData::is_dirty(self)
7851 }
7852}
7853impl VanillaLivingEntityData for GoatEntityData {
7854 fn living_entity(&self) -> &LivingEntityData {
7855 GoatEntityData::living_entity(self)
7856 }
7857 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
7858 GoatEntityData::living_entity_mut(self)
7859 }
7860}
7861#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
7862#[derive(Debug, Clone)]
7863pub struct HoglinEntityData {
7864 pub ageable_mob: AgeableMobEntityData,
7865 pub immune_to_zombification: SyncedValue<bool>,
7866}
7867impl HoglinEntityData {
7868 #[doc = r" Create new entity data with default values."]
7869 pub fn new() -> Self {
7870 Self {
7871 ageable_mob: AgeableMobEntityData::new(),
7872 immune_to_zombification: SyncedValue::new(false),
7873 }
7874 }
7875 #[doc = "Returns the `HoglinEntityData` layer."]
7876 pub fn hoglin(&self) -> &HoglinEntityData {
7877 self
7878 }
7879 #[doc = "Returns the mutable `HoglinEntityData` layer."]
7880 pub fn hoglin_mut(&mut self) -> &mut HoglinEntityData {
7881 self
7882 }
7883 #[doc = "Returns the `AgeableMobEntityData` layer."]
7884 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
7885 &self.ageable_mob
7886 }
7887 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
7888 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
7889 &mut self.ageable_mob
7890 }
7891 #[doc = "Returns the `MobEntityData` layer."]
7892 pub fn mob(&self) -> &MobEntityData {
7893 &self.ageable_mob.mob
7894 }
7895 #[doc = "Returns the mutable `MobEntityData` layer."]
7896 pub fn mob_mut(&mut self) -> &mut MobEntityData {
7897 &mut self.ageable_mob.mob
7898 }
7899 #[doc = "Returns the `LivingEntityData` layer."]
7900 pub fn living_entity(&self) -> &LivingEntityData {
7901 &self.ageable_mob.mob.living_entity
7902 }
7903 #[doc = "Returns the mutable `LivingEntityData` layer."]
7904 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
7905 &mut self.ageable_mob.mob.living_entity
7906 }
7907 #[doc = "Returns the `BaseEntityData` layer."]
7908 pub fn base(&self) -> &BaseEntityData {
7909 &self.ageable_mob.mob.living_entity.base
7910 }
7911 #[doc = "Returns the mutable `BaseEntityData` layer."]
7912 pub fn base_mut(&mut self) -> &mut BaseEntityData {
7913 &mut self.ageable_mob.mob.living_entity.base
7914 }
7915 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
7916 #[doc = r" Returns `None` if no values are dirty."]
7917 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7918 let mut values = Vec::new();
7919 self.pack_dirty_into(&mut values);
7920 if values.is_empty() {
7921 None
7922 } else {
7923 Some(values)
7924 }
7925 }
7926 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
7927 self.ageable_mob.pack_dirty_into(values);
7928 if self.immune_to_zombification.is_dirty() {
7929 values.push(DataValue {
7930 index: 18u8,
7931 serializer_id: 8i32,
7932 value: EntityData::Boolean(*self.immune_to_zombification.get()),
7933 });
7934 self.immune_to_zombification.clear_dirty();
7935 }
7936 }
7937 #[doc = r" Pack all non-default values (for initial entity spawn)."]
7938 pub fn pack_all(&self) -> Vec<DataValue> {
7939 let mut values = Vec::new();
7940 self.pack_all_into(&mut values);
7941 values
7942 }
7943 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
7944 self.ageable_mob.pack_all_into(values);
7945 if !self.immune_to_zombification.is_default() {
7946 values.push(DataValue {
7947 index: 18u8,
7948 serializer_id: 8i32,
7949 value: EntityData::Boolean(*self.immune_to_zombification.get()),
7950 });
7951 }
7952 }
7953 #[doc = r" Returns `true` if any field has been modified."]
7954 pub fn is_dirty(&self) -> bool {
7955 self.ageable_mob.is_dirty() || self.immune_to_zombification.is_dirty()
7956 }
7957}
7958impl Default for HoglinEntityData {
7959 fn default() -> Self {
7960 Self::new()
7961 }
7962}
7963impl VanillaEntityData for HoglinEntityData {
7964 fn base(&self) -> &BaseEntityData {
7965 HoglinEntityData::base(self)
7966 }
7967 fn base_mut(&mut self) -> &mut BaseEntityData {
7968 HoglinEntityData::base_mut(self)
7969 }
7970 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
7971 HoglinEntityData::pack_dirty(self)
7972 }
7973 fn pack_all(&self) -> Vec<DataValue> {
7974 HoglinEntityData::pack_all(self)
7975 }
7976 fn is_dirty(&self) -> bool {
7977 HoglinEntityData::is_dirty(self)
7978 }
7979}
7980impl VanillaLivingEntityData for HoglinEntityData {
7981 fn living_entity(&self) -> &LivingEntityData {
7982 HoglinEntityData::living_entity(self)
7983 }
7984 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
7985 HoglinEntityData::living_entity_mut(self)
7986 }
7987}
7988#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
7989#[derive(Debug, Clone)]
7990pub struct HorseEntityData {
7991 pub abstract_horse: AbstractHorseEntityData,
7992 pub id_type_variant: SyncedValue<i32>,
7993}
7994impl HorseEntityData {
7995 #[doc = r" Create new entity data with default values."]
7996 pub fn new() -> Self {
7997 Self {
7998 abstract_horse: AbstractHorseEntityData::new(),
7999 id_type_variant: SyncedValue::new(0i32),
8000 }
8001 }
8002 #[doc = "Returns the `HorseEntityData` layer."]
8003 pub fn horse(&self) -> &HorseEntityData {
8004 self
8005 }
8006 #[doc = "Returns the mutable `HorseEntityData` layer."]
8007 pub fn horse_mut(&mut self) -> &mut HorseEntityData {
8008 self
8009 }
8010 #[doc = "Returns the `AbstractHorseEntityData` layer."]
8011 pub fn abstract_horse(&self) -> &AbstractHorseEntityData {
8012 &self.abstract_horse
8013 }
8014 #[doc = "Returns the mutable `AbstractHorseEntityData` layer."]
8015 pub fn abstract_horse_mut(&mut self) -> &mut AbstractHorseEntityData {
8016 &mut self.abstract_horse
8017 }
8018 #[doc = "Returns the `AgeableMobEntityData` layer."]
8019 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
8020 &self.abstract_horse.ageable_mob
8021 }
8022 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
8023 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
8024 &mut self.abstract_horse.ageable_mob
8025 }
8026 #[doc = "Returns the `MobEntityData` layer."]
8027 pub fn mob(&self) -> &MobEntityData {
8028 &self.abstract_horse.ageable_mob.mob
8029 }
8030 #[doc = "Returns the mutable `MobEntityData` layer."]
8031 pub fn mob_mut(&mut self) -> &mut MobEntityData {
8032 &mut self.abstract_horse.ageable_mob.mob
8033 }
8034 #[doc = "Returns the `LivingEntityData` layer."]
8035 pub fn living_entity(&self) -> &LivingEntityData {
8036 &self.abstract_horse.ageable_mob.mob.living_entity
8037 }
8038 #[doc = "Returns the mutable `LivingEntityData` layer."]
8039 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
8040 &mut self.abstract_horse.ageable_mob.mob.living_entity
8041 }
8042 #[doc = "Returns the `BaseEntityData` layer."]
8043 pub fn base(&self) -> &BaseEntityData {
8044 &self.abstract_horse.ageable_mob.mob.living_entity.base
8045 }
8046 #[doc = "Returns the mutable `BaseEntityData` layer."]
8047 pub fn base_mut(&mut self) -> &mut BaseEntityData {
8048 &mut self.abstract_horse.ageable_mob.mob.living_entity.base
8049 }
8050 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
8051 #[doc = r" Returns `None` if no values are dirty."]
8052 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8053 let mut values = Vec::new();
8054 self.pack_dirty_into(&mut values);
8055 if values.is_empty() {
8056 None
8057 } else {
8058 Some(values)
8059 }
8060 }
8061 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
8062 self.abstract_horse.pack_dirty_into(values);
8063 if self.id_type_variant.is_dirty() {
8064 values.push(DataValue {
8065 index: 19u8,
8066 serializer_id: 1i32,
8067 value: EntityData::Int(*self.id_type_variant.get()),
8068 });
8069 self.id_type_variant.clear_dirty();
8070 }
8071 }
8072 #[doc = r" Pack all non-default values (for initial entity spawn)."]
8073 pub fn pack_all(&self) -> Vec<DataValue> {
8074 let mut values = Vec::new();
8075 self.pack_all_into(&mut values);
8076 values
8077 }
8078 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
8079 self.abstract_horse.pack_all_into(values);
8080 if !self.id_type_variant.is_default() {
8081 values.push(DataValue {
8082 index: 19u8,
8083 serializer_id: 1i32,
8084 value: EntityData::Int(*self.id_type_variant.get()),
8085 });
8086 }
8087 }
8088 #[doc = r" Returns `true` if any field has been modified."]
8089 pub fn is_dirty(&self) -> bool {
8090 self.abstract_horse.is_dirty() || self.id_type_variant.is_dirty()
8091 }
8092}
8093impl Default for HorseEntityData {
8094 fn default() -> Self {
8095 Self::new()
8096 }
8097}
8098impl VanillaEntityData for HorseEntityData {
8099 fn base(&self) -> &BaseEntityData {
8100 HorseEntityData::base(self)
8101 }
8102 fn base_mut(&mut self) -> &mut BaseEntityData {
8103 HorseEntityData::base_mut(self)
8104 }
8105 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8106 HorseEntityData::pack_dirty(self)
8107 }
8108 fn pack_all(&self) -> Vec<DataValue> {
8109 HorseEntityData::pack_all(self)
8110 }
8111 fn is_dirty(&self) -> bool {
8112 HorseEntityData::is_dirty(self)
8113 }
8114}
8115impl VanillaLivingEntityData for HorseEntityData {
8116 fn living_entity(&self) -> &LivingEntityData {
8117 HorseEntityData::living_entity(self)
8118 }
8119 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
8120 HorseEntityData::living_entity_mut(self)
8121 }
8122}
8123#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
8124#[derive(Debug, Clone)]
8125pub struct InteractionEntityData {
8126 pub base: BaseEntityData,
8127 pub width: SyncedValue<f32>,
8128 pub height: SyncedValue<f32>,
8129 pub response: SyncedValue<bool>,
8130}
8131impl InteractionEntityData {
8132 #[doc = r" Create new entity data with default values."]
8133 pub fn new() -> Self {
8134 Self {
8135 base: BaseEntityData::new(),
8136 width: SyncedValue::new(1f32),
8137 height: SyncedValue::new(1f32),
8138 response: SyncedValue::new(false),
8139 }
8140 }
8141 #[doc = "Returns the `InteractionEntityData` layer."]
8142 pub fn interaction(&self) -> &InteractionEntityData {
8143 self
8144 }
8145 #[doc = "Returns the mutable `InteractionEntityData` layer."]
8146 pub fn interaction_mut(&mut self) -> &mut InteractionEntityData {
8147 self
8148 }
8149 #[doc = "Returns the `BaseEntityData` layer."]
8150 pub fn base(&self) -> &BaseEntityData {
8151 &self.base
8152 }
8153 #[doc = "Returns the mutable `BaseEntityData` layer."]
8154 pub fn base_mut(&mut self) -> &mut BaseEntityData {
8155 &mut self.base
8156 }
8157 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
8158 #[doc = r" Returns `None` if no values are dirty."]
8159 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8160 let mut values = Vec::new();
8161 self.pack_dirty_into(&mut values);
8162 if values.is_empty() {
8163 None
8164 } else {
8165 Some(values)
8166 }
8167 }
8168 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
8169 self.base.pack_dirty_into(values);
8170 if self.width.is_dirty() {
8171 values.push(DataValue {
8172 index: 8u8,
8173 serializer_id: 3i32,
8174 value: EntityData::Float(*self.width.get()),
8175 });
8176 self.width.clear_dirty();
8177 }
8178 if self.height.is_dirty() {
8179 values.push(DataValue {
8180 index: 9u8,
8181 serializer_id: 3i32,
8182 value: EntityData::Float(*self.height.get()),
8183 });
8184 self.height.clear_dirty();
8185 }
8186 if self.response.is_dirty() {
8187 values.push(DataValue {
8188 index: 10u8,
8189 serializer_id: 8i32,
8190 value: EntityData::Boolean(*self.response.get()),
8191 });
8192 self.response.clear_dirty();
8193 }
8194 }
8195 #[doc = r" Pack all non-default values (for initial entity spawn)."]
8196 pub fn pack_all(&self) -> Vec<DataValue> {
8197 let mut values = Vec::new();
8198 self.pack_all_into(&mut values);
8199 values
8200 }
8201 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
8202 self.base.pack_all_into(values);
8203 if !self.width.is_default() {
8204 values.push(DataValue {
8205 index: 8u8,
8206 serializer_id: 3i32,
8207 value: EntityData::Float(*self.width.get()),
8208 });
8209 }
8210 if !self.height.is_default() {
8211 values.push(DataValue {
8212 index: 9u8,
8213 serializer_id: 3i32,
8214 value: EntityData::Float(*self.height.get()),
8215 });
8216 }
8217 if !self.response.is_default() {
8218 values.push(DataValue {
8219 index: 10u8,
8220 serializer_id: 8i32,
8221 value: EntityData::Boolean(*self.response.get()),
8222 });
8223 }
8224 }
8225 #[doc = r" Returns `true` if any field has been modified."]
8226 pub fn is_dirty(&self) -> bool {
8227 self.base.is_dirty()
8228 || self.width.is_dirty()
8229 || self.height.is_dirty()
8230 || self.response.is_dirty()
8231 }
8232}
8233impl Default for InteractionEntityData {
8234 fn default() -> Self {
8235 Self::new()
8236 }
8237}
8238impl VanillaEntityData for InteractionEntityData {
8239 fn base(&self) -> &BaseEntityData {
8240 InteractionEntityData::base(self)
8241 }
8242 fn base_mut(&mut self) -> &mut BaseEntityData {
8243 InteractionEntityData::base_mut(self)
8244 }
8245 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8246 InteractionEntityData::pack_dirty(self)
8247 }
8248 fn pack_all(&self) -> Vec<DataValue> {
8249 InteractionEntityData::pack_all(self)
8250 }
8251 fn is_dirty(&self) -> bool {
8252 InteractionEntityData::is_dirty(self)
8253 }
8254}
8255#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
8256#[derive(Debug, Clone)]
8257pub struct IronGolemEntityData {
8258 pub mob: MobEntityData,
8259 pub flags: SyncedValue<i8>,
8260}
8261impl IronGolemEntityData {
8262 #[doc = r" Create new entity data with default values."]
8263 pub fn new() -> Self {
8264 Self {
8265 mob: MobEntityData::new(),
8266 flags: SyncedValue::new(0i8),
8267 }
8268 }
8269 #[doc = "Returns the `IronGolemEntityData` layer."]
8270 pub fn iron_golem(&self) -> &IronGolemEntityData {
8271 self
8272 }
8273 #[doc = "Returns the mutable `IronGolemEntityData` layer."]
8274 pub fn iron_golem_mut(&mut self) -> &mut IronGolemEntityData {
8275 self
8276 }
8277 #[doc = "Returns the `MobEntityData` layer."]
8278 pub fn mob(&self) -> &MobEntityData {
8279 &self.mob
8280 }
8281 #[doc = "Returns the mutable `MobEntityData` layer."]
8282 pub fn mob_mut(&mut self) -> &mut MobEntityData {
8283 &mut self.mob
8284 }
8285 #[doc = "Returns the `LivingEntityData` layer."]
8286 pub fn living_entity(&self) -> &LivingEntityData {
8287 &self.mob.living_entity
8288 }
8289 #[doc = "Returns the mutable `LivingEntityData` layer."]
8290 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
8291 &mut self.mob.living_entity
8292 }
8293 #[doc = "Returns the `BaseEntityData` layer."]
8294 pub fn base(&self) -> &BaseEntityData {
8295 &self.mob.living_entity.base
8296 }
8297 #[doc = "Returns the mutable `BaseEntityData` layer."]
8298 pub fn base_mut(&mut self) -> &mut BaseEntityData {
8299 &mut self.mob.living_entity.base
8300 }
8301 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
8302 #[doc = r" Returns `None` if no values are dirty."]
8303 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8304 let mut values = Vec::new();
8305 self.pack_dirty_into(&mut values);
8306 if values.is_empty() {
8307 None
8308 } else {
8309 Some(values)
8310 }
8311 }
8312 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
8313 self.mob.pack_dirty_into(values);
8314 if self.flags.is_dirty() {
8315 values.push(DataValue {
8316 index: 16u8,
8317 serializer_id: 0i32,
8318 value: EntityData::Byte(*self.flags.get()),
8319 });
8320 self.flags.clear_dirty();
8321 }
8322 }
8323 #[doc = r" Pack all non-default values (for initial entity spawn)."]
8324 pub fn pack_all(&self) -> Vec<DataValue> {
8325 let mut values = Vec::new();
8326 self.pack_all_into(&mut values);
8327 values
8328 }
8329 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
8330 self.mob.pack_all_into(values);
8331 if !self.flags.is_default() {
8332 values.push(DataValue {
8333 index: 16u8,
8334 serializer_id: 0i32,
8335 value: EntityData::Byte(*self.flags.get()),
8336 });
8337 }
8338 }
8339 #[doc = r" Returns `true` if any field has been modified."]
8340 pub fn is_dirty(&self) -> bool {
8341 self.mob.is_dirty() || self.flags.is_dirty()
8342 }
8343}
8344impl Default for IronGolemEntityData {
8345 fn default() -> Self {
8346 Self::new()
8347 }
8348}
8349impl VanillaEntityData for IronGolemEntityData {
8350 fn base(&self) -> &BaseEntityData {
8351 IronGolemEntityData::base(self)
8352 }
8353 fn base_mut(&mut self) -> &mut BaseEntityData {
8354 IronGolemEntityData::base_mut(self)
8355 }
8356 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8357 IronGolemEntityData::pack_dirty(self)
8358 }
8359 fn pack_all(&self) -> Vec<DataValue> {
8360 IronGolemEntityData::pack_all(self)
8361 }
8362 fn is_dirty(&self) -> bool {
8363 IronGolemEntityData::is_dirty(self)
8364 }
8365}
8366impl VanillaLivingEntityData for IronGolemEntityData {
8367 fn living_entity(&self) -> &LivingEntityData {
8368 IronGolemEntityData::living_entity(self)
8369 }
8370 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
8371 IronGolemEntityData::living_entity_mut(self)
8372 }
8373}
8374#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
8375#[derive(Debug, Clone)]
8376pub struct ItemEntityData {
8377 pub base: BaseEntityData,
8378 pub item: SyncedValue<ItemStack>,
8379}
8380impl ItemEntityData {
8381 #[doc = r" Create new entity data with default values."]
8382 pub fn new() -> Self {
8383 Self {
8384 base: BaseEntityData::new(),
8385 item: SyncedValue::new(ItemStack::empty()),
8386 }
8387 }
8388 #[doc = "Returns the `ItemEntityData` layer."]
8389 pub fn item_entity(&self) -> &ItemEntityData {
8390 self
8391 }
8392 #[doc = "Returns the mutable `ItemEntityData` layer."]
8393 pub fn item_entity_mut(&mut self) -> &mut ItemEntityData {
8394 self
8395 }
8396 #[doc = "Returns the `BaseEntityData` layer."]
8397 pub fn base(&self) -> &BaseEntityData {
8398 &self.base
8399 }
8400 #[doc = "Returns the mutable `BaseEntityData` layer."]
8401 pub fn base_mut(&mut self) -> &mut BaseEntityData {
8402 &mut self.base
8403 }
8404 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
8405 #[doc = r" Returns `None` if no values are dirty."]
8406 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8407 let mut values = Vec::new();
8408 self.pack_dirty_into(&mut values);
8409 if values.is_empty() {
8410 None
8411 } else {
8412 Some(values)
8413 }
8414 }
8415 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
8416 self.base.pack_dirty_into(values);
8417 if self.item.is_dirty() {
8418 values.push(DataValue {
8419 index: 8u8,
8420 serializer_id: 7i32,
8421 value: EntityData::ItemStack(self.item.get().clone()),
8422 });
8423 self.item.clear_dirty();
8424 }
8425 }
8426 #[doc = r" Pack all non-default values (for initial entity spawn)."]
8427 pub fn pack_all(&self) -> Vec<DataValue> {
8428 let mut values = Vec::new();
8429 self.pack_all_into(&mut values);
8430 values
8431 }
8432 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
8433 self.base.pack_all_into(values);
8434 if !self.item.is_default() {
8435 values.push(DataValue {
8436 index: 8u8,
8437 serializer_id: 7i32,
8438 value: EntityData::ItemStack(self.item.get().clone()),
8439 });
8440 }
8441 }
8442 #[doc = r" Returns `true` if any field has been modified."]
8443 pub fn is_dirty(&self) -> bool {
8444 self.base.is_dirty() || self.item.is_dirty()
8445 }
8446}
8447impl Default for ItemEntityData {
8448 fn default() -> Self {
8449 Self::new()
8450 }
8451}
8452impl VanillaEntityData for ItemEntityData {
8453 fn base(&self) -> &BaseEntityData {
8454 ItemEntityData::base(self)
8455 }
8456 fn base_mut(&mut self) -> &mut BaseEntityData {
8457 ItemEntityData::base_mut(self)
8458 }
8459 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8460 ItemEntityData::pack_dirty(self)
8461 }
8462 fn pack_all(&self) -> Vec<DataValue> {
8463 ItemEntityData::pack_all(self)
8464 }
8465 fn is_dirty(&self) -> bool {
8466 ItemEntityData::is_dirty(self)
8467 }
8468}
8469#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
8470#[derive(Debug, Clone)]
8471pub struct ItemDisplayEntityData {
8472 pub display: DisplayEntityData,
8473 pub item_stack: SyncedValue<ItemStack>,
8474 pub item_display: SyncedValue<i8>,
8475}
8476impl ItemDisplayEntityData {
8477 #[doc = r" Create new entity data with default values."]
8478 pub fn new() -> Self {
8479 Self {
8480 display: DisplayEntityData::new(),
8481 item_stack: SyncedValue::new(ItemStack::empty()),
8482 item_display: SyncedValue::new(0i8),
8483 }
8484 }
8485 #[doc = "Returns the `ItemDisplayEntityData` layer."]
8486 pub fn item_display(&self) -> &ItemDisplayEntityData {
8487 self
8488 }
8489 #[doc = "Returns the mutable `ItemDisplayEntityData` layer."]
8490 pub fn item_display_mut(&mut self) -> &mut ItemDisplayEntityData {
8491 self
8492 }
8493 #[doc = "Returns the `DisplayEntityData` layer."]
8494 pub fn display(&self) -> &DisplayEntityData {
8495 &self.display
8496 }
8497 #[doc = "Returns the mutable `DisplayEntityData` layer."]
8498 pub fn display_mut(&mut self) -> &mut DisplayEntityData {
8499 &mut self.display
8500 }
8501 #[doc = "Returns the `BaseEntityData` layer."]
8502 pub fn base(&self) -> &BaseEntityData {
8503 &self.display.base
8504 }
8505 #[doc = "Returns the mutable `BaseEntityData` layer."]
8506 pub fn base_mut(&mut self) -> &mut BaseEntityData {
8507 &mut self.display.base
8508 }
8509 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
8510 #[doc = r" Returns `None` if no values are dirty."]
8511 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8512 let mut values = Vec::new();
8513 self.pack_dirty_into(&mut values);
8514 if values.is_empty() {
8515 None
8516 } else {
8517 Some(values)
8518 }
8519 }
8520 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
8521 self.display.pack_dirty_into(values);
8522 if self.item_stack.is_dirty() {
8523 values.push(DataValue {
8524 index: 23u8,
8525 serializer_id: 7i32,
8526 value: EntityData::ItemStack(self.item_stack.get().clone()),
8527 });
8528 self.item_stack.clear_dirty();
8529 }
8530 if self.item_display.is_dirty() {
8531 values.push(DataValue {
8532 index: 24u8,
8533 serializer_id: 0i32,
8534 value: EntityData::Byte(*self.item_display.get()),
8535 });
8536 self.item_display.clear_dirty();
8537 }
8538 }
8539 #[doc = r" Pack all non-default values (for initial entity spawn)."]
8540 pub fn pack_all(&self) -> Vec<DataValue> {
8541 let mut values = Vec::new();
8542 self.pack_all_into(&mut values);
8543 values
8544 }
8545 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
8546 self.display.pack_all_into(values);
8547 if !self.item_stack.is_default() {
8548 values.push(DataValue {
8549 index: 23u8,
8550 serializer_id: 7i32,
8551 value: EntityData::ItemStack(self.item_stack.get().clone()),
8552 });
8553 }
8554 if !self.item_display.is_default() {
8555 values.push(DataValue {
8556 index: 24u8,
8557 serializer_id: 0i32,
8558 value: EntityData::Byte(*self.item_display.get()),
8559 });
8560 }
8561 }
8562 #[doc = r" Returns `true` if any field has been modified."]
8563 pub fn is_dirty(&self) -> bool {
8564 self.display.is_dirty() || self.item_stack.is_dirty() || self.item_display.is_dirty()
8565 }
8566}
8567impl Default for ItemDisplayEntityData {
8568 fn default() -> Self {
8569 Self::new()
8570 }
8571}
8572impl VanillaEntityData for ItemDisplayEntityData {
8573 fn base(&self) -> &BaseEntityData {
8574 ItemDisplayEntityData::base(self)
8575 }
8576 fn base_mut(&mut self) -> &mut BaseEntityData {
8577 ItemDisplayEntityData::base_mut(self)
8578 }
8579 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8580 ItemDisplayEntityData::pack_dirty(self)
8581 }
8582 fn pack_all(&self) -> Vec<DataValue> {
8583 ItemDisplayEntityData::pack_all(self)
8584 }
8585 fn is_dirty(&self) -> bool {
8586 ItemDisplayEntityData::is_dirty(self)
8587 }
8588}
8589#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
8590#[derive(Debug, Clone)]
8591pub struct LlamaEntityData {
8592 pub abstract_chested_horse: AbstractChestedHorseEntityData,
8593 pub strength: SyncedValue<i32>,
8594 pub variant: SyncedValue<i32>,
8595}
8596impl LlamaEntityData {
8597 #[doc = r" Create new entity data with default values."]
8598 pub fn new() -> Self {
8599 Self {
8600 abstract_chested_horse: AbstractChestedHorseEntityData::new(),
8601 strength: SyncedValue::new(0i32),
8602 variant: SyncedValue::new(0i32),
8603 }
8604 }
8605 #[doc = "Returns the `LlamaEntityData` layer."]
8606 pub fn llama(&self) -> &LlamaEntityData {
8607 self
8608 }
8609 #[doc = "Returns the mutable `LlamaEntityData` layer."]
8610 pub fn llama_mut(&mut self) -> &mut LlamaEntityData {
8611 self
8612 }
8613 #[doc = "Returns the `AbstractChestedHorseEntityData` layer."]
8614 pub fn abstract_chested_horse(&self) -> &AbstractChestedHorseEntityData {
8615 &self.abstract_chested_horse
8616 }
8617 #[doc = "Returns the mutable `AbstractChestedHorseEntityData` layer."]
8618 pub fn abstract_chested_horse_mut(&mut self) -> &mut AbstractChestedHorseEntityData {
8619 &mut self.abstract_chested_horse
8620 }
8621 #[doc = "Returns the `AbstractHorseEntityData` layer."]
8622 pub fn abstract_horse(&self) -> &AbstractHorseEntityData {
8623 &self.abstract_chested_horse.abstract_horse
8624 }
8625 #[doc = "Returns the mutable `AbstractHorseEntityData` layer."]
8626 pub fn abstract_horse_mut(&mut self) -> &mut AbstractHorseEntityData {
8627 &mut self.abstract_chested_horse.abstract_horse
8628 }
8629 #[doc = "Returns the `AgeableMobEntityData` layer."]
8630 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
8631 &self.abstract_chested_horse.abstract_horse.ageable_mob
8632 }
8633 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
8634 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
8635 &mut self.abstract_chested_horse.abstract_horse.ageable_mob
8636 }
8637 #[doc = "Returns the `MobEntityData` layer."]
8638 pub fn mob(&self) -> &MobEntityData {
8639 &self.abstract_chested_horse.abstract_horse.ageable_mob.mob
8640 }
8641 #[doc = "Returns the mutable `MobEntityData` layer."]
8642 pub fn mob_mut(&mut self) -> &mut MobEntityData {
8643 &mut self.abstract_chested_horse.abstract_horse.ageable_mob.mob
8644 }
8645 #[doc = "Returns the `LivingEntityData` layer."]
8646 pub fn living_entity(&self) -> &LivingEntityData {
8647 &self
8648 .abstract_chested_horse
8649 .abstract_horse
8650 .ageable_mob
8651 .mob
8652 .living_entity
8653 }
8654 #[doc = "Returns the mutable `LivingEntityData` layer."]
8655 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
8656 &mut self
8657 .abstract_chested_horse
8658 .abstract_horse
8659 .ageable_mob
8660 .mob
8661 .living_entity
8662 }
8663 #[doc = "Returns the `BaseEntityData` layer."]
8664 pub fn base(&self) -> &BaseEntityData {
8665 &self
8666 .abstract_chested_horse
8667 .abstract_horse
8668 .ageable_mob
8669 .mob
8670 .living_entity
8671 .base
8672 }
8673 #[doc = "Returns the mutable `BaseEntityData` layer."]
8674 pub fn base_mut(&mut self) -> &mut BaseEntityData {
8675 &mut self
8676 .abstract_chested_horse
8677 .abstract_horse
8678 .ageable_mob
8679 .mob
8680 .living_entity
8681 .base
8682 }
8683 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
8684 #[doc = r" Returns `None` if no values are dirty."]
8685 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8686 let mut values = Vec::new();
8687 self.pack_dirty_into(&mut values);
8688 if values.is_empty() {
8689 None
8690 } else {
8691 Some(values)
8692 }
8693 }
8694 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
8695 self.abstract_chested_horse.pack_dirty_into(values);
8696 if self.strength.is_dirty() {
8697 values.push(DataValue {
8698 index: 20u8,
8699 serializer_id: 1i32,
8700 value: EntityData::Int(*self.strength.get()),
8701 });
8702 self.strength.clear_dirty();
8703 }
8704 if self.variant.is_dirty() {
8705 values.push(DataValue {
8706 index: 21u8,
8707 serializer_id: 1i32,
8708 value: EntityData::Int(*self.variant.get()),
8709 });
8710 self.variant.clear_dirty();
8711 }
8712 }
8713 #[doc = r" Pack all non-default values (for initial entity spawn)."]
8714 pub fn pack_all(&self) -> Vec<DataValue> {
8715 let mut values = Vec::new();
8716 self.pack_all_into(&mut values);
8717 values
8718 }
8719 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
8720 self.abstract_chested_horse.pack_all_into(values);
8721 if !self.strength.is_default() {
8722 values.push(DataValue {
8723 index: 20u8,
8724 serializer_id: 1i32,
8725 value: EntityData::Int(*self.strength.get()),
8726 });
8727 }
8728 if !self.variant.is_default() {
8729 values.push(DataValue {
8730 index: 21u8,
8731 serializer_id: 1i32,
8732 value: EntityData::Int(*self.variant.get()),
8733 });
8734 }
8735 }
8736 #[doc = r" Returns `true` if any field has been modified."]
8737 pub fn is_dirty(&self) -> bool {
8738 self.abstract_chested_horse.is_dirty()
8739 || self.strength.is_dirty()
8740 || self.variant.is_dirty()
8741 }
8742}
8743impl Default for LlamaEntityData {
8744 fn default() -> Self {
8745 Self::new()
8746 }
8747}
8748impl VanillaEntityData for LlamaEntityData {
8749 fn base(&self) -> &BaseEntityData {
8750 LlamaEntityData::base(self)
8751 }
8752 fn base_mut(&mut self) -> &mut BaseEntityData {
8753 LlamaEntityData::base_mut(self)
8754 }
8755 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8756 LlamaEntityData::pack_dirty(self)
8757 }
8758 fn pack_all(&self) -> Vec<DataValue> {
8759 LlamaEntityData::pack_all(self)
8760 }
8761 fn is_dirty(&self) -> bool {
8762 LlamaEntityData::is_dirty(self)
8763 }
8764}
8765impl VanillaLivingEntityData for LlamaEntityData {
8766 fn living_entity(&self) -> &LivingEntityData {
8767 LlamaEntityData::living_entity(self)
8768 }
8769 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
8770 LlamaEntityData::living_entity_mut(self)
8771 }
8772}
8773#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
8774#[derive(Debug, Clone)]
8775pub struct SlimeEntityData {
8776 pub mob: MobEntityData,
8777 pub id_size: SyncedValue<i32>,
8778}
8779impl SlimeEntityData {
8780 #[doc = r" Create new entity data with default values."]
8781 pub fn new() -> Self {
8782 Self {
8783 mob: MobEntityData::new(),
8784 id_size: SyncedValue::new(1i32),
8785 }
8786 }
8787 #[doc = "Returns the `SlimeEntityData` layer."]
8788 pub fn slime(&self) -> &SlimeEntityData {
8789 self
8790 }
8791 #[doc = "Returns the mutable `SlimeEntityData` layer."]
8792 pub fn slime_mut(&mut self) -> &mut SlimeEntityData {
8793 self
8794 }
8795 #[doc = "Returns the `MobEntityData` layer."]
8796 pub fn mob(&self) -> &MobEntityData {
8797 &self.mob
8798 }
8799 #[doc = "Returns the mutable `MobEntityData` layer."]
8800 pub fn mob_mut(&mut self) -> &mut MobEntityData {
8801 &mut self.mob
8802 }
8803 #[doc = "Returns the `LivingEntityData` layer."]
8804 pub fn living_entity(&self) -> &LivingEntityData {
8805 &self.mob.living_entity
8806 }
8807 #[doc = "Returns the mutable `LivingEntityData` layer."]
8808 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
8809 &mut self.mob.living_entity
8810 }
8811 #[doc = "Returns the `BaseEntityData` layer."]
8812 pub fn base(&self) -> &BaseEntityData {
8813 &self.mob.living_entity.base
8814 }
8815 #[doc = "Returns the mutable `BaseEntityData` layer."]
8816 pub fn base_mut(&mut self) -> &mut BaseEntityData {
8817 &mut self.mob.living_entity.base
8818 }
8819 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
8820 #[doc = r" Returns `None` if no values are dirty."]
8821 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8822 let mut values = Vec::new();
8823 self.pack_dirty_into(&mut values);
8824 if values.is_empty() {
8825 None
8826 } else {
8827 Some(values)
8828 }
8829 }
8830 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
8831 self.mob.pack_dirty_into(values);
8832 if self.id_size.is_dirty() {
8833 values.push(DataValue {
8834 index: 16u8,
8835 serializer_id: 1i32,
8836 value: EntityData::Int(*self.id_size.get()),
8837 });
8838 self.id_size.clear_dirty();
8839 }
8840 }
8841 #[doc = r" Pack all non-default values (for initial entity spawn)."]
8842 pub fn pack_all(&self) -> Vec<DataValue> {
8843 let mut values = Vec::new();
8844 self.pack_all_into(&mut values);
8845 values
8846 }
8847 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
8848 self.mob.pack_all_into(values);
8849 if !self.id_size.is_default() {
8850 values.push(DataValue {
8851 index: 16u8,
8852 serializer_id: 1i32,
8853 value: EntityData::Int(*self.id_size.get()),
8854 });
8855 }
8856 }
8857 #[doc = r" Returns `true` if any field has been modified."]
8858 pub fn is_dirty(&self) -> bool {
8859 self.mob.is_dirty() || self.id_size.is_dirty()
8860 }
8861}
8862impl Default for SlimeEntityData {
8863 fn default() -> Self {
8864 Self::new()
8865 }
8866}
8867impl VanillaEntityData for SlimeEntityData {
8868 fn base(&self) -> &BaseEntityData {
8869 SlimeEntityData::base(self)
8870 }
8871 fn base_mut(&mut self) -> &mut BaseEntityData {
8872 SlimeEntityData::base_mut(self)
8873 }
8874 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8875 SlimeEntityData::pack_dirty(self)
8876 }
8877 fn pack_all(&self) -> Vec<DataValue> {
8878 SlimeEntityData::pack_all(self)
8879 }
8880 fn is_dirty(&self) -> bool {
8881 SlimeEntityData::is_dirty(self)
8882 }
8883}
8884impl VanillaLivingEntityData for SlimeEntityData {
8885 fn living_entity(&self) -> &LivingEntityData {
8886 SlimeEntityData::living_entity(self)
8887 }
8888 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
8889 SlimeEntityData::living_entity_mut(self)
8890 }
8891}
8892#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
8893#[derive(Debug, Clone)]
8894pub struct AvatarEntityData {
8895 pub living_entity: LivingEntityData,
8896 pub player_main_hand: SyncedValue<HumanoidArm>,
8897 pub player_mode_customisation: SyncedValue<i8>,
8898}
8899impl AvatarEntityData {
8900 #[doc = r" Create new entity data with default values."]
8901 pub fn new() -> Self {
8902 Self {
8903 living_entity: LivingEntityData::new(),
8904 player_main_hand: SyncedValue::new(HumanoidArm::Right),
8905 player_mode_customisation: SyncedValue::new(0i8),
8906 }
8907 }
8908 #[doc = "Returns the `AvatarEntityData` layer."]
8909 pub fn avatar(&self) -> &AvatarEntityData {
8910 self
8911 }
8912 #[doc = "Returns the mutable `AvatarEntityData` layer."]
8913 pub fn avatar_mut(&mut self) -> &mut AvatarEntityData {
8914 self
8915 }
8916 #[doc = "Returns the `LivingEntityData` layer."]
8917 pub fn living_entity(&self) -> &LivingEntityData {
8918 &self.living_entity
8919 }
8920 #[doc = "Returns the mutable `LivingEntityData` layer."]
8921 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
8922 &mut self.living_entity
8923 }
8924 #[doc = "Returns the `BaseEntityData` layer."]
8925 pub fn base(&self) -> &BaseEntityData {
8926 &self.living_entity.base
8927 }
8928 #[doc = "Returns the mutable `BaseEntityData` layer."]
8929 pub fn base_mut(&mut self) -> &mut BaseEntityData {
8930 &mut self.living_entity.base
8931 }
8932 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
8933 #[doc = r" Returns `None` if no values are dirty."]
8934 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
8935 let mut values = Vec::new();
8936 self.pack_dirty_into(&mut values);
8937 if values.is_empty() {
8938 None
8939 } else {
8940 Some(values)
8941 }
8942 }
8943 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
8944 self.living_entity.pack_dirty_into(values);
8945 if self.player_main_hand.is_dirty() {
8946 values.push(DataValue {
8947 index: 15u8,
8948 serializer_id: 42i32,
8949 value: EntityData::HumanoidArm(*self.player_main_hand.get()),
8950 });
8951 self.player_main_hand.clear_dirty();
8952 }
8953 if self.player_mode_customisation.is_dirty() {
8954 values.push(DataValue {
8955 index: 16u8,
8956 serializer_id: 0i32,
8957 value: EntityData::Byte(*self.player_mode_customisation.get()),
8958 });
8959 self.player_mode_customisation.clear_dirty();
8960 }
8961 }
8962 #[doc = r" Pack all non-default values (for initial entity spawn)."]
8963 pub fn pack_all(&self) -> Vec<DataValue> {
8964 let mut values = Vec::new();
8965 self.pack_all_into(&mut values);
8966 values
8967 }
8968 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
8969 self.living_entity.pack_all_into(values);
8970 if !self.player_main_hand.is_default() {
8971 values.push(DataValue {
8972 index: 15u8,
8973 serializer_id: 42i32,
8974 value: EntityData::HumanoidArm(*self.player_main_hand.get()),
8975 });
8976 }
8977 if !self.player_mode_customisation.is_default() {
8978 values.push(DataValue {
8979 index: 16u8,
8980 serializer_id: 0i32,
8981 value: EntityData::Byte(*self.player_mode_customisation.get()),
8982 });
8983 }
8984 }
8985 #[doc = r" Returns `true` if any field has been modified."]
8986 pub fn is_dirty(&self) -> bool {
8987 self.living_entity.is_dirty()
8988 || self.player_main_hand.is_dirty()
8989 || self.player_mode_customisation.is_dirty()
8990 }
8991}
8992impl Default for AvatarEntityData {
8993 fn default() -> Self {
8994 Self::new()
8995 }
8996}
8997impl VanillaEntityData for AvatarEntityData {
8998 fn base(&self) -> &BaseEntityData {
8999 AvatarEntityData::base(self)
9000 }
9001 fn base_mut(&mut self) -> &mut BaseEntityData {
9002 AvatarEntityData::base_mut(self)
9003 }
9004 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9005 AvatarEntityData::pack_dirty(self)
9006 }
9007 fn pack_all(&self) -> Vec<DataValue> {
9008 AvatarEntityData::pack_all(self)
9009 }
9010 fn is_dirty(&self) -> bool {
9011 AvatarEntityData::is_dirty(self)
9012 }
9013}
9014impl VanillaLivingEntityData for AvatarEntityData {
9015 fn living_entity(&self) -> &LivingEntityData {
9016 AvatarEntityData::living_entity(self)
9017 }
9018 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
9019 AvatarEntityData::living_entity_mut(self)
9020 }
9021}
9022#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
9023#[derive(Debug, Clone)]
9024pub struct MannequinEntityData {
9025 pub avatar: AvatarEntityData,
9026 pub profile: SyncedValue<ResolvableProfile>,
9027 pub immovable: SyncedValue<bool>,
9028 pub description: SyncedValue<Option<Box<TextComponent>>>,
9029}
9030impl MannequinEntityData {
9031 #[doc = r" Create new entity data with default values."]
9032 pub fn new() -> Self {
9033 Self {
9034 avatar: AvatarEntityData::new(),
9035 profile: SyncedValue::new(ResolvableProfile::default()),
9036 immovable: SyncedValue::new(false),
9037 description: SyncedValue::new(Some(Box::new(TextComponent::plain("NPC")))),
9038 }
9039 }
9040 #[doc = "Returns the `MannequinEntityData` layer."]
9041 pub fn mannequin(&self) -> &MannequinEntityData {
9042 self
9043 }
9044 #[doc = "Returns the mutable `MannequinEntityData` layer."]
9045 pub fn mannequin_mut(&mut self) -> &mut MannequinEntityData {
9046 self
9047 }
9048 #[doc = "Returns the `AvatarEntityData` layer."]
9049 pub fn avatar(&self) -> &AvatarEntityData {
9050 &self.avatar
9051 }
9052 #[doc = "Returns the mutable `AvatarEntityData` layer."]
9053 pub fn avatar_mut(&mut self) -> &mut AvatarEntityData {
9054 &mut self.avatar
9055 }
9056 #[doc = "Returns the `LivingEntityData` layer."]
9057 pub fn living_entity(&self) -> &LivingEntityData {
9058 &self.avatar.living_entity
9059 }
9060 #[doc = "Returns the mutable `LivingEntityData` layer."]
9061 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
9062 &mut self.avatar.living_entity
9063 }
9064 #[doc = "Returns the `BaseEntityData` layer."]
9065 pub fn base(&self) -> &BaseEntityData {
9066 &self.avatar.living_entity.base
9067 }
9068 #[doc = "Returns the mutable `BaseEntityData` layer."]
9069 pub fn base_mut(&mut self) -> &mut BaseEntityData {
9070 &mut self.avatar.living_entity.base
9071 }
9072 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
9073 #[doc = r" Returns `None` if no values are dirty."]
9074 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9075 let mut values = Vec::new();
9076 self.pack_dirty_into(&mut values);
9077 if values.is_empty() {
9078 None
9079 } else {
9080 Some(values)
9081 }
9082 }
9083 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
9084 self.avatar.pack_dirty_into(values);
9085 if self.profile.is_dirty() {
9086 values.push(DataValue {
9087 index: 17u8,
9088 serializer_id: 41i32,
9089 value: EntityData::ResolvableProfile(self.profile.get().clone()),
9090 });
9091 self.profile.clear_dirty();
9092 }
9093 if self.immovable.is_dirty() {
9094 values.push(DataValue {
9095 index: 18u8,
9096 serializer_id: 8i32,
9097 value: EntityData::Boolean(*self.immovable.get()),
9098 });
9099 self.immovable.clear_dirty();
9100 }
9101 if self.description.is_dirty() {
9102 values.push(DataValue {
9103 index: 19u8,
9104 serializer_id: 6i32,
9105 value: EntityData::OptionalComponent(self.description.get().clone()),
9106 });
9107 self.description.clear_dirty();
9108 }
9109 }
9110 #[doc = r" Pack all non-default values (for initial entity spawn)."]
9111 pub fn pack_all(&self) -> Vec<DataValue> {
9112 let mut values = Vec::new();
9113 self.pack_all_into(&mut values);
9114 values
9115 }
9116 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
9117 self.avatar.pack_all_into(values);
9118 if !self.profile.is_default() {
9119 values.push(DataValue {
9120 index: 17u8,
9121 serializer_id: 41i32,
9122 value: EntityData::ResolvableProfile(self.profile.get().clone()),
9123 });
9124 }
9125 if !self.immovable.is_default() {
9126 values.push(DataValue {
9127 index: 18u8,
9128 serializer_id: 8i32,
9129 value: EntityData::Boolean(*self.immovable.get()),
9130 });
9131 }
9132 if !self.description.is_default() {
9133 values.push(DataValue {
9134 index: 19u8,
9135 serializer_id: 6i32,
9136 value: EntityData::OptionalComponent(self.description.get().clone()),
9137 });
9138 }
9139 }
9140 #[doc = r" Returns `true` if any field has been modified."]
9141 pub fn is_dirty(&self) -> bool {
9142 self.avatar.is_dirty()
9143 || self.profile.is_dirty()
9144 || self.immovable.is_dirty()
9145 || self.description.is_dirty()
9146 }
9147}
9148impl Default for MannequinEntityData {
9149 fn default() -> Self {
9150 Self::new()
9151 }
9152}
9153impl VanillaEntityData for MannequinEntityData {
9154 fn base(&self) -> &BaseEntityData {
9155 MannequinEntityData::base(self)
9156 }
9157 fn base_mut(&mut self) -> &mut BaseEntityData {
9158 MannequinEntityData::base_mut(self)
9159 }
9160 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9161 MannequinEntityData::pack_dirty(self)
9162 }
9163 fn pack_all(&self) -> Vec<DataValue> {
9164 MannequinEntityData::pack_all(self)
9165 }
9166 fn is_dirty(&self) -> bool {
9167 MannequinEntityData::is_dirty(self)
9168 }
9169}
9170impl VanillaLivingEntityData for MannequinEntityData {
9171 fn living_entity(&self) -> &LivingEntityData {
9172 MannequinEntityData::living_entity(self)
9173 }
9174 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
9175 MannequinEntityData::living_entity_mut(self)
9176 }
9177}
9178#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
9179#[derive(Debug, Clone)]
9180pub struct MushroomCowEntityData {
9181 pub ageable_mob: AgeableMobEntityData,
9182 pub variant_type: SyncedValue<i32>,
9183}
9184impl MushroomCowEntityData {
9185 #[doc = r" Create new entity data with default values."]
9186 pub fn new() -> Self {
9187 Self {
9188 ageable_mob: AgeableMobEntityData::new(),
9189 variant_type: SyncedValue::new(0i32),
9190 }
9191 }
9192 #[doc = "Returns the `MushroomCowEntityData` layer."]
9193 pub fn mushroom_cow(&self) -> &MushroomCowEntityData {
9194 self
9195 }
9196 #[doc = "Returns the mutable `MushroomCowEntityData` layer."]
9197 pub fn mushroom_cow_mut(&mut self) -> &mut MushroomCowEntityData {
9198 self
9199 }
9200 #[doc = "Returns the `AgeableMobEntityData` layer."]
9201 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
9202 &self.ageable_mob
9203 }
9204 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
9205 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
9206 &mut self.ageable_mob
9207 }
9208 #[doc = "Returns the `MobEntityData` layer."]
9209 pub fn mob(&self) -> &MobEntityData {
9210 &self.ageable_mob.mob
9211 }
9212 #[doc = "Returns the mutable `MobEntityData` layer."]
9213 pub fn mob_mut(&mut self) -> &mut MobEntityData {
9214 &mut self.ageable_mob.mob
9215 }
9216 #[doc = "Returns the `LivingEntityData` layer."]
9217 pub fn living_entity(&self) -> &LivingEntityData {
9218 &self.ageable_mob.mob.living_entity
9219 }
9220 #[doc = "Returns the mutable `LivingEntityData` layer."]
9221 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
9222 &mut self.ageable_mob.mob.living_entity
9223 }
9224 #[doc = "Returns the `BaseEntityData` layer."]
9225 pub fn base(&self) -> &BaseEntityData {
9226 &self.ageable_mob.mob.living_entity.base
9227 }
9228 #[doc = "Returns the mutable `BaseEntityData` layer."]
9229 pub fn base_mut(&mut self) -> &mut BaseEntityData {
9230 &mut self.ageable_mob.mob.living_entity.base
9231 }
9232 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
9233 #[doc = r" Returns `None` if no values are dirty."]
9234 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9235 let mut values = Vec::new();
9236 self.pack_dirty_into(&mut values);
9237 if values.is_empty() {
9238 None
9239 } else {
9240 Some(values)
9241 }
9242 }
9243 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
9244 self.ageable_mob.pack_dirty_into(values);
9245 if self.variant_type.is_dirty() {
9246 values.push(DataValue {
9247 index: 18u8,
9248 serializer_id: 1i32,
9249 value: EntityData::Int(*self.variant_type.get()),
9250 });
9251 self.variant_type.clear_dirty();
9252 }
9253 }
9254 #[doc = r" Pack all non-default values (for initial entity spawn)."]
9255 pub fn pack_all(&self) -> Vec<DataValue> {
9256 let mut values = Vec::new();
9257 self.pack_all_into(&mut values);
9258 values
9259 }
9260 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
9261 self.ageable_mob.pack_all_into(values);
9262 if !self.variant_type.is_default() {
9263 values.push(DataValue {
9264 index: 18u8,
9265 serializer_id: 1i32,
9266 value: EntityData::Int(*self.variant_type.get()),
9267 });
9268 }
9269 }
9270 #[doc = r" Returns `true` if any field has been modified."]
9271 pub fn is_dirty(&self) -> bool {
9272 self.ageable_mob.is_dirty() || self.variant_type.is_dirty()
9273 }
9274}
9275impl Default for MushroomCowEntityData {
9276 fn default() -> Self {
9277 Self::new()
9278 }
9279}
9280impl VanillaEntityData for MushroomCowEntityData {
9281 fn base(&self) -> &BaseEntityData {
9282 MushroomCowEntityData::base(self)
9283 }
9284 fn base_mut(&mut self) -> &mut BaseEntityData {
9285 MushroomCowEntityData::base_mut(self)
9286 }
9287 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9288 MushroomCowEntityData::pack_dirty(self)
9289 }
9290 fn pack_all(&self) -> Vec<DataValue> {
9291 MushroomCowEntityData::pack_all(self)
9292 }
9293 fn is_dirty(&self) -> bool {
9294 MushroomCowEntityData::is_dirty(self)
9295 }
9296}
9297impl VanillaLivingEntityData for MushroomCowEntityData {
9298 fn living_entity(&self) -> &LivingEntityData {
9299 MushroomCowEntityData::living_entity(self)
9300 }
9301 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
9302 MushroomCowEntityData::living_entity_mut(self)
9303 }
9304}
9305#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
9306#[derive(Debug, Clone)]
9307pub struct AbstractNautilusEntityData {
9308 pub tamable_animal: TamableAnimalEntityData,
9309 pub dash: SyncedValue<bool>,
9310}
9311impl AbstractNautilusEntityData {
9312 #[doc = r" Create new entity data with default values."]
9313 pub fn new() -> Self {
9314 Self {
9315 tamable_animal: TamableAnimalEntityData::new(),
9316 dash: SyncedValue::new(false),
9317 }
9318 }
9319 #[doc = "Returns the `AbstractNautilusEntityData` layer."]
9320 pub fn abstract_nautilus(&self) -> &AbstractNautilusEntityData {
9321 self
9322 }
9323 #[doc = "Returns the mutable `AbstractNautilusEntityData` layer."]
9324 pub fn abstract_nautilus_mut(&mut self) -> &mut AbstractNautilusEntityData {
9325 self
9326 }
9327 #[doc = "Returns the `TamableAnimalEntityData` layer."]
9328 pub fn tamable_animal(&self) -> &TamableAnimalEntityData {
9329 &self.tamable_animal
9330 }
9331 #[doc = "Returns the mutable `TamableAnimalEntityData` layer."]
9332 pub fn tamable_animal_mut(&mut self) -> &mut TamableAnimalEntityData {
9333 &mut self.tamable_animal
9334 }
9335 #[doc = "Returns the `AgeableMobEntityData` layer."]
9336 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
9337 &self.tamable_animal.ageable_mob
9338 }
9339 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
9340 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
9341 &mut self.tamable_animal.ageable_mob
9342 }
9343 #[doc = "Returns the `MobEntityData` layer."]
9344 pub fn mob(&self) -> &MobEntityData {
9345 &self.tamable_animal.ageable_mob.mob
9346 }
9347 #[doc = "Returns the mutable `MobEntityData` layer."]
9348 pub fn mob_mut(&mut self) -> &mut MobEntityData {
9349 &mut self.tamable_animal.ageable_mob.mob
9350 }
9351 #[doc = "Returns the `LivingEntityData` layer."]
9352 pub fn living_entity(&self) -> &LivingEntityData {
9353 &self.tamable_animal.ageable_mob.mob.living_entity
9354 }
9355 #[doc = "Returns the mutable `LivingEntityData` layer."]
9356 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
9357 &mut self.tamable_animal.ageable_mob.mob.living_entity
9358 }
9359 #[doc = "Returns the `BaseEntityData` layer."]
9360 pub fn base(&self) -> &BaseEntityData {
9361 &self.tamable_animal.ageable_mob.mob.living_entity.base
9362 }
9363 #[doc = "Returns the mutable `BaseEntityData` layer."]
9364 pub fn base_mut(&mut self) -> &mut BaseEntityData {
9365 &mut self.tamable_animal.ageable_mob.mob.living_entity.base
9366 }
9367 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
9368 #[doc = r" Returns `None` if no values are dirty."]
9369 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9370 let mut values = Vec::new();
9371 self.pack_dirty_into(&mut values);
9372 if values.is_empty() {
9373 None
9374 } else {
9375 Some(values)
9376 }
9377 }
9378 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
9379 self.tamable_animal.pack_dirty_into(values);
9380 if self.dash.is_dirty() {
9381 values.push(DataValue {
9382 index: 20u8,
9383 serializer_id: 8i32,
9384 value: EntityData::Boolean(*self.dash.get()),
9385 });
9386 self.dash.clear_dirty();
9387 }
9388 }
9389 #[doc = r" Pack all non-default values (for initial entity spawn)."]
9390 pub fn pack_all(&self) -> Vec<DataValue> {
9391 let mut values = Vec::new();
9392 self.pack_all_into(&mut values);
9393 values
9394 }
9395 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
9396 self.tamable_animal.pack_all_into(values);
9397 if !self.dash.is_default() {
9398 values.push(DataValue {
9399 index: 20u8,
9400 serializer_id: 8i32,
9401 value: EntityData::Boolean(*self.dash.get()),
9402 });
9403 }
9404 }
9405 #[doc = r" Returns `true` if any field has been modified."]
9406 pub fn is_dirty(&self) -> bool {
9407 self.tamable_animal.is_dirty() || self.dash.is_dirty()
9408 }
9409}
9410impl Default for AbstractNautilusEntityData {
9411 fn default() -> Self {
9412 Self::new()
9413 }
9414}
9415impl VanillaEntityData for AbstractNautilusEntityData {
9416 fn base(&self) -> &BaseEntityData {
9417 AbstractNautilusEntityData::base(self)
9418 }
9419 fn base_mut(&mut self) -> &mut BaseEntityData {
9420 AbstractNautilusEntityData::base_mut(self)
9421 }
9422 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9423 AbstractNautilusEntityData::pack_dirty(self)
9424 }
9425 fn pack_all(&self) -> Vec<DataValue> {
9426 AbstractNautilusEntityData::pack_all(self)
9427 }
9428 fn is_dirty(&self) -> bool {
9429 AbstractNautilusEntityData::is_dirty(self)
9430 }
9431}
9432impl VanillaLivingEntityData for AbstractNautilusEntityData {
9433 fn living_entity(&self) -> &LivingEntityData {
9434 AbstractNautilusEntityData::living_entity(self)
9435 }
9436 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
9437 AbstractNautilusEntityData::living_entity_mut(self)
9438 }
9439}
9440#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
9441#[derive(Debug, Clone)]
9442pub struct OcelotEntityData {
9443 pub ageable_mob: AgeableMobEntityData,
9444 pub trusting: SyncedValue<bool>,
9445}
9446impl OcelotEntityData {
9447 #[doc = r" Create new entity data with default values."]
9448 pub fn new() -> Self {
9449 Self {
9450 ageable_mob: AgeableMobEntityData::new(),
9451 trusting: SyncedValue::new(false),
9452 }
9453 }
9454 #[doc = "Returns the `OcelotEntityData` layer."]
9455 pub fn ocelot(&self) -> &OcelotEntityData {
9456 self
9457 }
9458 #[doc = "Returns the mutable `OcelotEntityData` layer."]
9459 pub fn ocelot_mut(&mut self) -> &mut OcelotEntityData {
9460 self
9461 }
9462 #[doc = "Returns the `AgeableMobEntityData` layer."]
9463 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
9464 &self.ageable_mob
9465 }
9466 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
9467 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
9468 &mut self.ageable_mob
9469 }
9470 #[doc = "Returns the `MobEntityData` layer."]
9471 pub fn mob(&self) -> &MobEntityData {
9472 &self.ageable_mob.mob
9473 }
9474 #[doc = "Returns the mutable `MobEntityData` layer."]
9475 pub fn mob_mut(&mut self) -> &mut MobEntityData {
9476 &mut self.ageable_mob.mob
9477 }
9478 #[doc = "Returns the `LivingEntityData` layer."]
9479 pub fn living_entity(&self) -> &LivingEntityData {
9480 &self.ageable_mob.mob.living_entity
9481 }
9482 #[doc = "Returns the mutable `LivingEntityData` layer."]
9483 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
9484 &mut self.ageable_mob.mob.living_entity
9485 }
9486 #[doc = "Returns the `BaseEntityData` layer."]
9487 pub fn base(&self) -> &BaseEntityData {
9488 &self.ageable_mob.mob.living_entity.base
9489 }
9490 #[doc = "Returns the mutable `BaseEntityData` layer."]
9491 pub fn base_mut(&mut self) -> &mut BaseEntityData {
9492 &mut self.ageable_mob.mob.living_entity.base
9493 }
9494 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
9495 #[doc = r" Returns `None` if no values are dirty."]
9496 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9497 let mut values = Vec::new();
9498 self.pack_dirty_into(&mut values);
9499 if values.is_empty() {
9500 None
9501 } else {
9502 Some(values)
9503 }
9504 }
9505 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
9506 self.ageable_mob.pack_dirty_into(values);
9507 if self.trusting.is_dirty() {
9508 values.push(DataValue {
9509 index: 18u8,
9510 serializer_id: 8i32,
9511 value: EntityData::Boolean(*self.trusting.get()),
9512 });
9513 self.trusting.clear_dirty();
9514 }
9515 }
9516 #[doc = r" Pack all non-default values (for initial entity spawn)."]
9517 pub fn pack_all(&self) -> Vec<DataValue> {
9518 let mut values = Vec::new();
9519 self.pack_all_into(&mut values);
9520 values
9521 }
9522 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
9523 self.ageable_mob.pack_all_into(values);
9524 if !self.trusting.is_default() {
9525 values.push(DataValue {
9526 index: 18u8,
9527 serializer_id: 8i32,
9528 value: EntityData::Boolean(*self.trusting.get()),
9529 });
9530 }
9531 }
9532 #[doc = r" Returns `true` if any field has been modified."]
9533 pub fn is_dirty(&self) -> bool {
9534 self.ageable_mob.is_dirty() || self.trusting.is_dirty()
9535 }
9536}
9537impl Default for OcelotEntityData {
9538 fn default() -> Self {
9539 Self::new()
9540 }
9541}
9542impl VanillaEntityData for OcelotEntityData {
9543 fn base(&self) -> &BaseEntityData {
9544 OcelotEntityData::base(self)
9545 }
9546 fn base_mut(&mut self) -> &mut BaseEntityData {
9547 OcelotEntityData::base_mut(self)
9548 }
9549 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9550 OcelotEntityData::pack_dirty(self)
9551 }
9552 fn pack_all(&self) -> Vec<DataValue> {
9553 OcelotEntityData::pack_all(self)
9554 }
9555 fn is_dirty(&self) -> bool {
9556 OcelotEntityData::is_dirty(self)
9557 }
9558}
9559impl VanillaLivingEntityData for OcelotEntityData {
9560 fn living_entity(&self) -> &LivingEntityData {
9561 OcelotEntityData::living_entity(self)
9562 }
9563 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
9564 OcelotEntityData::living_entity_mut(self)
9565 }
9566}
9567#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
9568#[derive(Debug, Clone)]
9569pub struct OminousItemSpawnerEntityData {
9570 pub base: BaseEntityData,
9571 pub item: SyncedValue<ItemStack>,
9572}
9573impl OminousItemSpawnerEntityData {
9574 #[doc = r" Create new entity data with default values."]
9575 pub fn new() -> Self {
9576 Self {
9577 base: BaseEntityData::new(),
9578 item: SyncedValue::new(ItemStack::empty()),
9579 }
9580 }
9581 #[doc = "Returns the `OminousItemSpawnerEntityData` layer."]
9582 pub fn ominous_item_spawner(&self) -> &OminousItemSpawnerEntityData {
9583 self
9584 }
9585 #[doc = "Returns the mutable `OminousItemSpawnerEntityData` layer."]
9586 pub fn ominous_item_spawner_mut(&mut self) -> &mut OminousItemSpawnerEntityData {
9587 self
9588 }
9589 #[doc = "Returns the `BaseEntityData` layer."]
9590 pub fn base(&self) -> &BaseEntityData {
9591 &self.base
9592 }
9593 #[doc = "Returns the mutable `BaseEntityData` layer."]
9594 pub fn base_mut(&mut self) -> &mut BaseEntityData {
9595 &mut self.base
9596 }
9597 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
9598 #[doc = r" Returns `None` if no values are dirty."]
9599 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9600 let mut values = Vec::new();
9601 self.pack_dirty_into(&mut values);
9602 if values.is_empty() {
9603 None
9604 } else {
9605 Some(values)
9606 }
9607 }
9608 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
9609 self.base.pack_dirty_into(values);
9610 if self.item.is_dirty() {
9611 values.push(DataValue {
9612 index: 8u8,
9613 serializer_id: 7i32,
9614 value: EntityData::ItemStack(self.item.get().clone()),
9615 });
9616 self.item.clear_dirty();
9617 }
9618 }
9619 #[doc = r" Pack all non-default values (for initial entity spawn)."]
9620 pub fn pack_all(&self) -> Vec<DataValue> {
9621 let mut values = Vec::new();
9622 self.pack_all_into(&mut values);
9623 values
9624 }
9625 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
9626 self.base.pack_all_into(values);
9627 if !self.item.is_default() {
9628 values.push(DataValue {
9629 index: 8u8,
9630 serializer_id: 7i32,
9631 value: EntityData::ItemStack(self.item.get().clone()),
9632 });
9633 }
9634 }
9635 #[doc = r" Returns `true` if any field has been modified."]
9636 pub fn is_dirty(&self) -> bool {
9637 self.base.is_dirty() || self.item.is_dirty()
9638 }
9639}
9640impl Default for OminousItemSpawnerEntityData {
9641 fn default() -> Self {
9642 Self::new()
9643 }
9644}
9645impl VanillaEntityData for OminousItemSpawnerEntityData {
9646 fn base(&self) -> &BaseEntityData {
9647 OminousItemSpawnerEntityData::base(self)
9648 }
9649 fn base_mut(&mut self) -> &mut BaseEntityData {
9650 OminousItemSpawnerEntityData::base_mut(self)
9651 }
9652 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9653 OminousItemSpawnerEntityData::pack_dirty(self)
9654 }
9655 fn pack_all(&self) -> Vec<DataValue> {
9656 OminousItemSpawnerEntityData::pack_all(self)
9657 }
9658 fn is_dirty(&self) -> bool {
9659 OminousItemSpawnerEntityData::is_dirty(self)
9660 }
9661}
9662#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
9663#[derive(Debug, Clone)]
9664pub struct PaintingEntityData {
9665 pub hanging_entity: HangingEntityData,
9666 pub painting_variant: SyncedValue<i32>,
9667}
9668impl PaintingEntityData {
9669 #[doc = r" Create new entity data with default values."]
9670 pub fn new() -> Self {
9671 Self {
9672 hanging_entity: HangingEntityData::new(),
9673 painting_variant: SyncedValue::new(2),
9674 }
9675 }
9676 #[doc = "Returns the `PaintingEntityData` layer."]
9677 pub fn painting(&self) -> &PaintingEntityData {
9678 self
9679 }
9680 #[doc = "Returns the mutable `PaintingEntityData` layer."]
9681 pub fn painting_mut(&mut self) -> &mut PaintingEntityData {
9682 self
9683 }
9684 #[doc = "Returns the `HangingEntityData` layer."]
9685 pub fn hanging_entity(&self) -> &HangingEntityData {
9686 &self.hanging_entity
9687 }
9688 #[doc = "Returns the mutable `HangingEntityData` layer."]
9689 pub fn hanging_entity_mut(&mut self) -> &mut HangingEntityData {
9690 &mut self.hanging_entity
9691 }
9692 #[doc = "Returns the `BaseEntityData` layer."]
9693 pub fn base(&self) -> &BaseEntityData {
9694 &self.hanging_entity.base
9695 }
9696 #[doc = "Returns the mutable `BaseEntityData` layer."]
9697 pub fn base_mut(&mut self) -> &mut BaseEntityData {
9698 &mut self.hanging_entity.base
9699 }
9700 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
9701 #[doc = r" Returns `None` if no values are dirty."]
9702 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9703 let mut values = Vec::new();
9704 self.pack_dirty_into(&mut values);
9705 if values.is_empty() {
9706 None
9707 } else {
9708 Some(values)
9709 }
9710 }
9711 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
9712 self.hanging_entity.pack_dirty_into(values);
9713 if self.painting_variant.is_dirty() {
9714 values.push(DataValue {
9715 index: 9u8,
9716 serializer_id: 34i32,
9717 value: EntityData::PaintingVariant(*self.painting_variant.get()),
9718 });
9719 self.painting_variant.clear_dirty();
9720 }
9721 }
9722 #[doc = r" Pack all non-default values (for initial entity spawn)."]
9723 pub fn pack_all(&self) -> Vec<DataValue> {
9724 let mut values = Vec::new();
9725 self.pack_all_into(&mut values);
9726 values
9727 }
9728 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
9729 self.hanging_entity.pack_all_into(values);
9730 if !self.painting_variant.is_default() {
9731 values.push(DataValue {
9732 index: 9u8,
9733 serializer_id: 34i32,
9734 value: EntityData::PaintingVariant(*self.painting_variant.get()),
9735 });
9736 }
9737 }
9738 #[doc = r" Returns `true` if any field has been modified."]
9739 pub fn is_dirty(&self) -> bool {
9740 self.hanging_entity.is_dirty() || self.painting_variant.is_dirty()
9741 }
9742}
9743impl Default for PaintingEntityData {
9744 fn default() -> Self {
9745 Self::new()
9746 }
9747}
9748impl VanillaEntityData for PaintingEntityData {
9749 fn base(&self) -> &BaseEntityData {
9750 PaintingEntityData::base(self)
9751 }
9752 fn base_mut(&mut self) -> &mut BaseEntityData {
9753 PaintingEntityData::base_mut(self)
9754 }
9755 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9756 PaintingEntityData::pack_dirty(self)
9757 }
9758 fn pack_all(&self) -> Vec<DataValue> {
9759 PaintingEntityData::pack_all(self)
9760 }
9761 fn is_dirty(&self) -> bool {
9762 PaintingEntityData::is_dirty(self)
9763 }
9764}
9765#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
9766#[derive(Debug, Clone)]
9767pub struct PandaEntityData {
9768 pub ageable_mob: AgeableMobEntityData,
9769 pub unhappy_counter: SyncedValue<i32>,
9770 pub sneeze_counter: SyncedValue<i32>,
9771 pub eat_counter: SyncedValue<i32>,
9772 pub main_gene: SyncedValue<i8>,
9773 pub hidden_gene: SyncedValue<i8>,
9774 pub id_flags: SyncedValue<i8>,
9775}
9776impl PandaEntityData {
9777 #[doc = r" Create new entity data with default values."]
9778 pub fn new() -> Self {
9779 Self {
9780 ageable_mob: AgeableMobEntityData::new(),
9781 unhappy_counter: SyncedValue::new(0i32),
9782 sneeze_counter: SyncedValue::new(0i32),
9783 eat_counter: SyncedValue::new(0i32),
9784 main_gene: SyncedValue::new(0i8),
9785 hidden_gene: SyncedValue::new(0i8),
9786 id_flags: SyncedValue::new(0i8),
9787 }
9788 }
9789 #[doc = "Returns the `PandaEntityData` layer."]
9790 pub fn panda(&self) -> &PandaEntityData {
9791 self
9792 }
9793 #[doc = "Returns the mutable `PandaEntityData` layer."]
9794 pub fn panda_mut(&mut self) -> &mut PandaEntityData {
9795 self
9796 }
9797 #[doc = "Returns the `AgeableMobEntityData` layer."]
9798 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
9799 &self.ageable_mob
9800 }
9801 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
9802 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
9803 &mut self.ageable_mob
9804 }
9805 #[doc = "Returns the `MobEntityData` layer."]
9806 pub fn mob(&self) -> &MobEntityData {
9807 &self.ageable_mob.mob
9808 }
9809 #[doc = "Returns the mutable `MobEntityData` layer."]
9810 pub fn mob_mut(&mut self) -> &mut MobEntityData {
9811 &mut self.ageable_mob.mob
9812 }
9813 #[doc = "Returns the `LivingEntityData` layer."]
9814 pub fn living_entity(&self) -> &LivingEntityData {
9815 &self.ageable_mob.mob.living_entity
9816 }
9817 #[doc = "Returns the mutable `LivingEntityData` layer."]
9818 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
9819 &mut self.ageable_mob.mob.living_entity
9820 }
9821 #[doc = "Returns the `BaseEntityData` layer."]
9822 pub fn base(&self) -> &BaseEntityData {
9823 &self.ageable_mob.mob.living_entity.base
9824 }
9825 #[doc = "Returns the mutable `BaseEntityData` layer."]
9826 pub fn base_mut(&mut self) -> &mut BaseEntityData {
9827 &mut self.ageable_mob.mob.living_entity.base
9828 }
9829 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
9830 #[doc = r" Returns `None` if no values are dirty."]
9831 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9832 let mut values = Vec::new();
9833 self.pack_dirty_into(&mut values);
9834 if values.is_empty() {
9835 None
9836 } else {
9837 Some(values)
9838 }
9839 }
9840 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
9841 self.ageable_mob.pack_dirty_into(values);
9842 if self.unhappy_counter.is_dirty() {
9843 values.push(DataValue {
9844 index: 18u8,
9845 serializer_id: 1i32,
9846 value: EntityData::Int(*self.unhappy_counter.get()),
9847 });
9848 self.unhappy_counter.clear_dirty();
9849 }
9850 if self.sneeze_counter.is_dirty() {
9851 values.push(DataValue {
9852 index: 19u8,
9853 serializer_id: 1i32,
9854 value: EntityData::Int(*self.sneeze_counter.get()),
9855 });
9856 self.sneeze_counter.clear_dirty();
9857 }
9858 if self.eat_counter.is_dirty() {
9859 values.push(DataValue {
9860 index: 20u8,
9861 serializer_id: 1i32,
9862 value: EntityData::Int(*self.eat_counter.get()),
9863 });
9864 self.eat_counter.clear_dirty();
9865 }
9866 if self.main_gene.is_dirty() {
9867 values.push(DataValue {
9868 index: 21u8,
9869 serializer_id: 0i32,
9870 value: EntityData::Byte(*self.main_gene.get()),
9871 });
9872 self.main_gene.clear_dirty();
9873 }
9874 if self.hidden_gene.is_dirty() {
9875 values.push(DataValue {
9876 index: 22u8,
9877 serializer_id: 0i32,
9878 value: EntityData::Byte(*self.hidden_gene.get()),
9879 });
9880 self.hidden_gene.clear_dirty();
9881 }
9882 if self.id_flags.is_dirty() {
9883 values.push(DataValue {
9884 index: 23u8,
9885 serializer_id: 0i32,
9886 value: EntityData::Byte(*self.id_flags.get()),
9887 });
9888 self.id_flags.clear_dirty();
9889 }
9890 }
9891 #[doc = r" Pack all non-default values (for initial entity spawn)."]
9892 pub fn pack_all(&self) -> Vec<DataValue> {
9893 let mut values = Vec::new();
9894 self.pack_all_into(&mut values);
9895 values
9896 }
9897 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
9898 self.ageable_mob.pack_all_into(values);
9899 if !self.unhappy_counter.is_default() {
9900 values.push(DataValue {
9901 index: 18u8,
9902 serializer_id: 1i32,
9903 value: EntityData::Int(*self.unhappy_counter.get()),
9904 });
9905 }
9906 if !self.sneeze_counter.is_default() {
9907 values.push(DataValue {
9908 index: 19u8,
9909 serializer_id: 1i32,
9910 value: EntityData::Int(*self.sneeze_counter.get()),
9911 });
9912 }
9913 if !self.eat_counter.is_default() {
9914 values.push(DataValue {
9915 index: 20u8,
9916 serializer_id: 1i32,
9917 value: EntityData::Int(*self.eat_counter.get()),
9918 });
9919 }
9920 if !self.main_gene.is_default() {
9921 values.push(DataValue {
9922 index: 21u8,
9923 serializer_id: 0i32,
9924 value: EntityData::Byte(*self.main_gene.get()),
9925 });
9926 }
9927 if !self.hidden_gene.is_default() {
9928 values.push(DataValue {
9929 index: 22u8,
9930 serializer_id: 0i32,
9931 value: EntityData::Byte(*self.hidden_gene.get()),
9932 });
9933 }
9934 if !self.id_flags.is_default() {
9935 values.push(DataValue {
9936 index: 23u8,
9937 serializer_id: 0i32,
9938 value: EntityData::Byte(*self.id_flags.get()),
9939 });
9940 }
9941 }
9942 #[doc = r" Returns `true` if any field has been modified."]
9943 pub fn is_dirty(&self) -> bool {
9944 self.ageable_mob.is_dirty()
9945 || self.unhappy_counter.is_dirty()
9946 || self.sneeze_counter.is_dirty()
9947 || self.eat_counter.is_dirty()
9948 || self.main_gene.is_dirty()
9949 || self.hidden_gene.is_dirty()
9950 || self.id_flags.is_dirty()
9951 }
9952}
9953impl Default for PandaEntityData {
9954 fn default() -> Self {
9955 Self::new()
9956 }
9957}
9958impl VanillaEntityData for PandaEntityData {
9959 fn base(&self) -> &BaseEntityData {
9960 PandaEntityData::base(self)
9961 }
9962 fn base_mut(&mut self) -> &mut BaseEntityData {
9963 PandaEntityData::base_mut(self)
9964 }
9965 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
9966 PandaEntityData::pack_dirty(self)
9967 }
9968 fn pack_all(&self) -> Vec<DataValue> {
9969 PandaEntityData::pack_all(self)
9970 }
9971 fn is_dirty(&self) -> bool {
9972 PandaEntityData::is_dirty(self)
9973 }
9974}
9975impl VanillaLivingEntityData for PandaEntityData {
9976 fn living_entity(&self) -> &LivingEntityData {
9977 PandaEntityData::living_entity(self)
9978 }
9979 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
9980 PandaEntityData::living_entity_mut(self)
9981 }
9982}
9983#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
9984#[derive(Debug, Clone)]
9985pub struct ParrotEntityData {
9986 pub tamable_animal: TamableAnimalEntityData,
9987 pub variant: SyncedValue<i32>,
9988}
9989impl ParrotEntityData {
9990 #[doc = r" Create new entity data with default values."]
9991 pub fn new() -> Self {
9992 Self {
9993 tamable_animal: TamableAnimalEntityData::new(),
9994 variant: SyncedValue::new(0i32),
9995 }
9996 }
9997 #[doc = "Returns the `ParrotEntityData` layer."]
9998 pub fn parrot(&self) -> &ParrotEntityData {
9999 self
10000 }
10001 #[doc = "Returns the mutable `ParrotEntityData` layer."]
10002 pub fn parrot_mut(&mut self) -> &mut ParrotEntityData {
10003 self
10004 }
10005 #[doc = "Returns the `TamableAnimalEntityData` layer."]
10006 pub fn tamable_animal(&self) -> &TamableAnimalEntityData {
10007 &self.tamable_animal
10008 }
10009 #[doc = "Returns the mutable `TamableAnimalEntityData` layer."]
10010 pub fn tamable_animal_mut(&mut self) -> &mut TamableAnimalEntityData {
10011 &mut self.tamable_animal
10012 }
10013 #[doc = "Returns the `AgeableMobEntityData` layer."]
10014 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
10015 &self.tamable_animal.ageable_mob
10016 }
10017 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
10018 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
10019 &mut self.tamable_animal.ageable_mob
10020 }
10021 #[doc = "Returns the `MobEntityData` layer."]
10022 pub fn mob(&self) -> &MobEntityData {
10023 &self.tamable_animal.ageable_mob.mob
10024 }
10025 #[doc = "Returns the mutable `MobEntityData` layer."]
10026 pub fn mob_mut(&mut self) -> &mut MobEntityData {
10027 &mut self.tamable_animal.ageable_mob.mob
10028 }
10029 #[doc = "Returns the `LivingEntityData` layer."]
10030 pub fn living_entity(&self) -> &LivingEntityData {
10031 &self.tamable_animal.ageable_mob.mob.living_entity
10032 }
10033 #[doc = "Returns the mutable `LivingEntityData` layer."]
10034 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10035 &mut self.tamable_animal.ageable_mob.mob.living_entity
10036 }
10037 #[doc = "Returns the `BaseEntityData` layer."]
10038 pub fn base(&self) -> &BaseEntityData {
10039 &self.tamable_animal.ageable_mob.mob.living_entity.base
10040 }
10041 #[doc = "Returns the mutable `BaseEntityData` layer."]
10042 pub fn base_mut(&mut self) -> &mut BaseEntityData {
10043 &mut self.tamable_animal.ageable_mob.mob.living_entity.base
10044 }
10045 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
10046 #[doc = r" Returns `None` if no values are dirty."]
10047 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10048 let mut values = Vec::new();
10049 self.pack_dirty_into(&mut values);
10050 if values.is_empty() {
10051 None
10052 } else {
10053 Some(values)
10054 }
10055 }
10056 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
10057 self.tamable_animal.pack_dirty_into(values);
10058 if self.variant.is_dirty() {
10059 values.push(DataValue {
10060 index: 20u8,
10061 serializer_id: 1i32,
10062 value: EntityData::Int(*self.variant.get()),
10063 });
10064 self.variant.clear_dirty();
10065 }
10066 }
10067 #[doc = r" Pack all non-default values (for initial entity spawn)."]
10068 pub fn pack_all(&self) -> Vec<DataValue> {
10069 let mut values = Vec::new();
10070 self.pack_all_into(&mut values);
10071 values
10072 }
10073 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
10074 self.tamable_animal.pack_all_into(values);
10075 if !self.variant.is_default() {
10076 values.push(DataValue {
10077 index: 20u8,
10078 serializer_id: 1i32,
10079 value: EntityData::Int(*self.variant.get()),
10080 });
10081 }
10082 }
10083 #[doc = r" Returns `true` if any field has been modified."]
10084 pub fn is_dirty(&self) -> bool {
10085 self.tamable_animal.is_dirty() || self.variant.is_dirty()
10086 }
10087}
10088impl Default for ParrotEntityData {
10089 fn default() -> Self {
10090 Self::new()
10091 }
10092}
10093impl VanillaEntityData for ParrotEntityData {
10094 fn base(&self) -> &BaseEntityData {
10095 ParrotEntityData::base(self)
10096 }
10097 fn base_mut(&mut self) -> &mut BaseEntityData {
10098 ParrotEntityData::base_mut(self)
10099 }
10100 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10101 ParrotEntityData::pack_dirty(self)
10102 }
10103 fn pack_all(&self) -> Vec<DataValue> {
10104 ParrotEntityData::pack_all(self)
10105 }
10106 fn is_dirty(&self) -> bool {
10107 ParrotEntityData::is_dirty(self)
10108 }
10109}
10110impl VanillaLivingEntityData for ParrotEntityData {
10111 fn living_entity(&self) -> &LivingEntityData {
10112 ParrotEntityData::living_entity(self)
10113 }
10114 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10115 ParrotEntityData::living_entity_mut(self)
10116 }
10117}
10118#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
10119#[derive(Debug, Clone)]
10120pub struct PhantomEntityData {
10121 pub mob: MobEntityData,
10122 pub id_size: SyncedValue<i32>,
10123}
10124impl PhantomEntityData {
10125 #[doc = r" Create new entity data with default values."]
10126 pub fn new() -> Self {
10127 Self {
10128 mob: MobEntityData::new(),
10129 id_size: SyncedValue::new(0i32),
10130 }
10131 }
10132 #[doc = "Returns the `PhantomEntityData` layer."]
10133 pub fn phantom(&self) -> &PhantomEntityData {
10134 self
10135 }
10136 #[doc = "Returns the mutable `PhantomEntityData` layer."]
10137 pub fn phantom_mut(&mut self) -> &mut PhantomEntityData {
10138 self
10139 }
10140 #[doc = "Returns the `MobEntityData` layer."]
10141 pub fn mob(&self) -> &MobEntityData {
10142 &self.mob
10143 }
10144 #[doc = "Returns the mutable `MobEntityData` layer."]
10145 pub fn mob_mut(&mut self) -> &mut MobEntityData {
10146 &mut self.mob
10147 }
10148 #[doc = "Returns the `LivingEntityData` layer."]
10149 pub fn living_entity(&self) -> &LivingEntityData {
10150 &self.mob.living_entity
10151 }
10152 #[doc = "Returns the mutable `LivingEntityData` layer."]
10153 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10154 &mut self.mob.living_entity
10155 }
10156 #[doc = "Returns the `BaseEntityData` layer."]
10157 pub fn base(&self) -> &BaseEntityData {
10158 &self.mob.living_entity.base
10159 }
10160 #[doc = "Returns the mutable `BaseEntityData` layer."]
10161 pub fn base_mut(&mut self) -> &mut BaseEntityData {
10162 &mut self.mob.living_entity.base
10163 }
10164 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
10165 #[doc = r" Returns `None` if no values are dirty."]
10166 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10167 let mut values = Vec::new();
10168 self.pack_dirty_into(&mut values);
10169 if values.is_empty() {
10170 None
10171 } else {
10172 Some(values)
10173 }
10174 }
10175 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
10176 self.mob.pack_dirty_into(values);
10177 if self.id_size.is_dirty() {
10178 values.push(DataValue {
10179 index: 16u8,
10180 serializer_id: 1i32,
10181 value: EntityData::Int(*self.id_size.get()),
10182 });
10183 self.id_size.clear_dirty();
10184 }
10185 }
10186 #[doc = r" Pack all non-default values (for initial entity spawn)."]
10187 pub fn pack_all(&self) -> Vec<DataValue> {
10188 let mut values = Vec::new();
10189 self.pack_all_into(&mut values);
10190 values
10191 }
10192 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
10193 self.mob.pack_all_into(values);
10194 if !self.id_size.is_default() {
10195 values.push(DataValue {
10196 index: 16u8,
10197 serializer_id: 1i32,
10198 value: EntityData::Int(*self.id_size.get()),
10199 });
10200 }
10201 }
10202 #[doc = r" Returns `true` if any field has been modified."]
10203 pub fn is_dirty(&self) -> bool {
10204 self.mob.is_dirty() || self.id_size.is_dirty()
10205 }
10206}
10207impl Default for PhantomEntityData {
10208 fn default() -> Self {
10209 Self::new()
10210 }
10211}
10212impl VanillaEntityData for PhantomEntityData {
10213 fn base(&self) -> &BaseEntityData {
10214 PhantomEntityData::base(self)
10215 }
10216 fn base_mut(&mut self) -> &mut BaseEntityData {
10217 PhantomEntityData::base_mut(self)
10218 }
10219 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10220 PhantomEntityData::pack_dirty(self)
10221 }
10222 fn pack_all(&self) -> Vec<DataValue> {
10223 PhantomEntityData::pack_all(self)
10224 }
10225 fn is_dirty(&self) -> bool {
10226 PhantomEntityData::is_dirty(self)
10227 }
10228}
10229impl VanillaLivingEntityData for PhantomEntityData {
10230 fn living_entity(&self) -> &LivingEntityData {
10231 PhantomEntityData::living_entity(self)
10232 }
10233 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10234 PhantomEntityData::living_entity_mut(self)
10235 }
10236}
10237#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
10238#[derive(Debug, Clone)]
10239pub struct PigEntityData {
10240 pub ageable_mob: AgeableMobEntityData,
10241 pub boost_time: SyncedValue<i32>,
10242 pub variant: SyncedValue<i32>,
10243 pub sound_variant: SyncedValue<i32>,
10244}
10245impl PigEntityData {
10246 #[doc = r" Create new entity data with default values."]
10247 pub fn new() -> Self {
10248 Self {
10249 ageable_mob: AgeableMobEntityData::new(),
10250 boost_time: SyncedValue::new(0i32),
10251 variant: SyncedValue::new(0),
10252 sound_variant: SyncedValue::new(0),
10253 }
10254 }
10255 #[doc = "Returns the `PigEntityData` layer."]
10256 pub fn pig(&self) -> &PigEntityData {
10257 self
10258 }
10259 #[doc = "Returns the mutable `PigEntityData` layer."]
10260 pub fn pig_mut(&mut self) -> &mut PigEntityData {
10261 self
10262 }
10263 #[doc = "Returns the `AgeableMobEntityData` layer."]
10264 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
10265 &self.ageable_mob
10266 }
10267 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
10268 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
10269 &mut self.ageable_mob
10270 }
10271 #[doc = "Returns the `MobEntityData` layer."]
10272 pub fn mob(&self) -> &MobEntityData {
10273 &self.ageable_mob.mob
10274 }
10275 #[doc = "Returns the mutable `MobEntityData` layer."]
10276 pub fn mob_mut(&mut self) -> &mut MobEntityData {
10277 &mut self.ageable_mob.mob
10278 }
10279 #[doc = "Returns the `LivingEntityData` layer."]
10280 pub fn living_entity(&self) -> &LivingEntityData {
10281 &self.ageable_mob.mob.living_entity
10282 }
10283 #[doc = "Returns the mutable `LivingEntityData` layer."]
10284 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10285 &mut self.ageable_mob.mob.living_entity
10286 }
10287 #[doc = "Returns the `BaseEntityData` layer."]
10288 pub fn base(&self) -> &BaseEntityData {
10289 &self.ageable_mob.mob.living_entity.base
10290 }
10291 #[doc = "Returns the mutable `BaseEntityData` layer."]
10292 pub fn base_mut(&mut self) -> &mut BaseEntityData {
10293 &mut self.ageable_mob.mob.living_entity.base
10294 }
10295 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
10296 #[doc = r" Returns `None` if no values are dirty."]
10297 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10298 let mut values = Vec::new();
10299 self.pack_dirty_into(&mut values);
10300 if values.is_empty() {
10301 None
10302 } else {
10303 Some(values)
10304 }
10305 }
10306 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
10307 self.ageable_mob.pack_dirty_into(values);
10308 if self.boost_time.is_dirty() {
10309 values.push(DataValue {
10310 index: 18u8,
10311 serializer_id: 1i32,
10312 value: EntityData::Int(*self.boost_time.get()),
10313 });
10314 self.boost_time.clear_dirty();
10315 }
10316 if self.variant.is_dirty() {
10317 values.push(DataValue {
10318 index: 19u8,
10319 serializer_id: 28i32,
10320 value: EntityData::PigVariant(*self.variant.get()),
10321 });
10322 self.variant.clear_dirty();
10323 }
10324 if self.sound_variant.is_dirty() {
10325 values.push(DataValue {
10326 index: 20u8,
10327 serializer_id: 29i32,
10328 value: EntityData::PigSoundVariant(*self.sound_variant.get()),
10329 });
10330 self.sound_variant.clear_dirty();
10331 }
10332 }
10333 #[doc = r" Pack all non-default values (for initial entity spawn)."]
10334 pub fn pack_all(&self) -> Vec<DataValue> {
10335 let mut values = Vec::new();
10336 self.pack_all_into(&mut values);
10337 values
10338 }
10339 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
10340 self.ageable_mob.pack_all_into(values);
10341 if !self.boost_time.is_default() {
10342 values.push(DataValue {
10343 index: 18u8,
10344 serializer_id: 1i32,
10345 value: EntityData::Int(*self.boost_time.get()),
10346 });
10347 }
10348 if !self.variant.is_default() {
10349 values.push(DataValue {
10350 index: 19u8,
10351 serializer_id: 28i32,
10352 value: EntityData::PigVariant(*self.variant.get()),
10353 });
10354 }
10355 if !self.sound_variant.is_default() {
10356 values.push(DataValue {
10357 index: 20u8,
10358 serializer_id: 29i32,
10359 value: EntityData::PigSoundVariant(*self.sound_variant.get()),
10360 });
10361 }
10362 }
10363 #[doc = r" Returns `true` if any field has been modified."]
10364 pub fn is_dirty(&self) -> bool {
10365 self.ageable_mob.is_dirty()
10366 || self.boost_time.is_dirty()
10367 || self.variant.is_dirty()
10368 || self.sound_variant.is_dirty()
10369 }
10370}
10371impl Default for PigEntityData {
10372 fn default() -> Self {
10373 Self::new()
10374 }
10375}
10376impl VanillaEntityData for PigEntityData {
10377 fn base(&self) -> &BaseEntityData {
10378 PigEntityData::base(self)
10379 }
10380 fn base_mut(&mut self) -> &mut BaseEntityData {
10381 PigEntityData::base_mut(self)
10382 }
10383 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10384 PigEntityData::pack_dirty(self)
10385 }
10386 fn pack_all(&self) -> Vec<DataValue> {
10387 PigEntityData::pack_all(self)
10388 }
10389 fn is_dirty(&self) -> bool {
10390 PigEntityData::is_dirty(self)
10391 }
10392}
10393impl VanillaLivingEntityData for PigEntityData {
10394 fn living_entity(&self) -> &LivingEntityData {
10395 PigEntityData::living_entity(self)
10396 }
10397 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10398 PigEntityData::living_entity_mut(self)
10399 }
10400}
10401#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
10402#[derive(Debug, Clone)]
10403pub struct AbstractPiglinEntityData {
10404 pub mob: MobEntityData,
10405 pub immune_to_zombification: SyncedValue<bool>,
10406}
10407impl AbstractPiglinEntityData {
10408 #[doc = r" Create new entity data with default values."]
10409 pub fn new() -> Self {
10410 Self {
10411 mob: MobEntityData::new(),
10412 immune_to_zombification: SyncedValue::new(false),
10413 }
10414 }
10415 #[doc = "Returns the `AbstractPiglinEntityData` layer."]
10416 pub fn abstract_piglin(&self) -> &AbstractPiglinEntityData {
10417 self
10418 }
10419 #[doc = "Returns the mutable `AbstractPiglinEntityData` layer."]
10420 pub fn abstract_piglin_mut(&mut self) -> &mut AbstractPiglinEntityData {
10421 self
10422 }
10423 #[doc = "Returns the `MobEntityData` layer."]
10424 pub fn mob(&self) -> &MobEntityData {
10425 &self.mob
10426 }
10427 #[doc = "Returns the mutable `MobEntityData` layer."]
10428 pub fn mob_mut(&mut self) -> &mut MobEntityData {
10429 &mut self.mob
10430 }
10431 #[doc = "Returns the `LivingEntityData` layer."]
10432 pub fn living_entity(&self) -> &LivingEntityData {
10433 &self.mob.living_entity
10434 }
10435 #[doc = "Returns the mutable `LivingEntityData` layer."]
10436 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10437 &mut self.mob.living_entity
10438 }
10439 #[doc = "Returns the `BaseEntityData` layer."]
10440 pub fn base(&self) -> &BaseEntityData {
10441 &self.mob.living_entity.base
10442 }
10443 #[doc = "Returns the mutable `BaseEntityData` layer."]
10444 pub fn base_mut(&mut self) -> &mut BaseEntityData {
10445 &mut self.mob.living_entity.base
10446 }
10447 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
10448 #[doc = r" Returns `None` if no values are dirty."]
10449 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10450 let mut values = Vec::new();
10451 self.pack_dirty_into(&mut values);
10452 if values.is_empty() {
10453 None
10454 } else {
10455 Some(values)
10456 }
10457 }
10458 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
10459 self.mob.pack_dirty_into(values);
10460 if self.immune_to_zombification.is_dirty() {
10461 values.push(DataValue {
10462 index: 16u8,
10463 serializer_id: 8i32,
10464 value: EntityData::Boolean(*self.immune_to_zombification.get()),
10465 });
10466 self.immune_to_zombification.clear_dirty();
10467 }
10468 }
10469 #[doc = r" Pack all non-default values (for initial entity spawn)."]
10470 pub fn pack_all(&self) -> Vec<DataValue> {
10471 let mut values = Vec::new();
10472 self.pack_all_into(&mut values);
10473 values
10474 }
10475 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
10476 self.mob.pack_all_into(values);
10477 if !self.immune_to_zombification.is_default() {
10478 values.push(DataValue {
10479 index: 16u8,
10480 serializer_id: 8i32,
10481 value: EntityData::Boolean(*self.immune_to_zombification.get()),
10482 });
10483 }
10484 }
10485 #[doc = r" Returns `true` if any field has been modified."]
10486 pub fn is_dirty(&self) -> bool {
10487 self.mob.is_dirty() || self.immune_to_zombification.is_dirty()
10488 }
10489}
10490impl Default for AbstractPiglinEntityData {
10491 fn default() -> Self {
10492 Self::new()
10493 }
10494}
10495impl VanillaEntityData for AbstractPiglinEntityData {
10496 fn base(&self) -> &BaseEntityData {
10497 AbstractPiglinEntityData::base(self)
10498 }
10499 fn base_mut(&mut self) -> &mut BaseEntityData {
10500 AbstractPiglinEntityData::base_mut(self)
10501 }
10502 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10503 AbstractPiglinEntityData::pack_dirty(self)
10504 }
10505 fn pack_all(&self) -> Vec<DataValue> {
10506 AbstractPiglinEntityData::pack_all(self)
10507 }
10508 fn is_dirty(&self) -> bool {
10509 AbstractPiglinEntityData::is_dirty(self)
10510 }
10511}
10512impl VanillaLivingEntityData for AbstractPiglinEntityData {
10513 fn living_entity(&self) -> &LivingEntityData {
10514 AbstractPiglinEntityData::living_entity(self)
10515 }
10516 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10517 AbstractPiglinEntityData::living_entity_mut(self)
10518 }
10519}
10520#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
10521#[derive(Debug, Clone)]
10522pub struct PiglinEntityData {
10523 pub abstract_piglin: AbstractPiglinEntityData,
10524 pub baby: SyncedValue<bool>,
10525 pub is_charging_crossbow: SyncedValue<bool>,
10526 pub is_dancing: SyncedValue<bool>,
10527}
10528impl PiglinEntityData {
10529 #[doc = r" Create new entity data with default values."]
10530 pub fn new() -> Self {
10531 Self {
10532 abstract_piglin: AbstractPiglinEntityData::new(),
10533 baby: SyncedValue::new(false),
10534 is_charging_crossbow: SyncedValue::new(false),
10535 is_dancing: SyncedValue::new(false),
10536 }
10537 }
10538 #[doc = "Returns the `PiglinEntityData` layer."]
10539 pub fn piglin(&self) -> &PiglinEntityData {
10540 self
10541 }
10542 #[doc = "Returns the mutable `PiglinEntityData` layer."]
10543 pub fn piglin_mut(&mut self) -> &mut PiglinEntityData {
10544 self
10545 }
10546 #[doc = "Returns the `AbstractPiglinEntityData` layer."]
10547 pub fn abstract_piglin(&self) -> &AbstractPiglinEntityData {
10548 &self.abstract_piglin
10549 }
10550 #[doc = "Returns the mutable `AbstractPiglinEntityData` layer."]
10551 pub fn abstract_piglin_mut(&mut self) -> &mut AbstractPiglinEntityData {
10552 &mut self.abstract_piglin
10553 }
10554 #[doc = "Returns the `MobEntityData` layer."]
10555 pub fn mob(&self) -> &MobEntityData {
10556 &self.abstract_piglin.mob
10557 }
10558 #[doc = "Returns the mutable `MobEntityData` layer."]
10559 pub fn mob_mut(&mut self) -> &mut MobEntityData {
10560 &mut self.abstract_piglin.mob
10561 }
10562 #[doc = "Returns the `LivingEntityData` layer."]
10563 pub fn living_entity(&self) -> &LivingEntityData {
10564 &self.abstract_piglin.mob.living_entity
10565 }
10566 #[doc = "Returns the mutable `LivingEntityData` layer."]
10567 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10568 &mut self.abstract_piglin.mob.living_entity
10569 }
10570 #[doc = "Returns the `BaseEntityData` layer."]
10571 pub fn base(&self) -> &BaseEntityData {
10572 &self.abstract_piglin.mob.living_entity.base
10573 }
10574 #[doc = "Returns the mutable `BaseEntityData` layer."]
10575 pub fn base_mut(&mut self) -> &mut BaseEntityData {
10576 &mut self.abstract_piglin.mob.living_entity.base
10577 }
10578 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
10579 #[doc = r" Returns `None` if no values are dirty."]
10580 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10581 let mut values = Vec::new();
10582 self.pack_dirty_into(&mut values);
10583 if values.is_empty() {
10584 None
10585 } else {
10586 Some(values)
10587 }
10588 }
10589 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
10590 self.abstract_piglin.pack_dirty_into(values);
10591 if self.baby.is_dirty() {
10592 values.push(DataValue {
10593 index: 17u8,
10594 serializer_id: 8i32,
10595 value: EntityData::Boolean(*self.baby.get()),
10596 });
10597 self.baby.clear_dirty();
10598 }
10599 if self.is_charging_crossbow.is_dirty() {
10600 values.push(DataValue {
10601 index: 18u8,
10602 serializer_id: 8i32,
10603 value: EntityData::Boolean(*self.is_charging_crossbow.get()),
10604 });
10605 self.is_charging_crossbow.clear_dirty();
10606 }
10607 if self.is_dancing.is_dirty() {
10608 values.push(DataValue {
10609 index: 19u8,
10610 serializer_id: 8i32,
10611 value: EntityData::Boolean(*self.is_dancing.get()),
10612 });
10613 self.is_dancing.clear_dirty();
10614 }
10615 }
10616 #[doc = r" Pack all non-default values (for initial entity spawn)."]
10617 pub fn pack_all(&self) -> Vec<DataValue> {
10618 let mut values = Vec::new();
10619 self.pack_all_into(&mut values);
10620 values
10621 }
10622 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
10623 self.abstract_piglin.pack_all_into(values);
10624 if !self.baby.is_default() {
10625 values.push(DataValue {
10626 index: 17u8,
10627 serializer_id: 8i32,
10628 value: EntityData::Boolean(*self.baby.get()),
10629 });
10630 }
10631 if !self.is_charging_crossbow.is_default() {
10632 values.push(DataValue {
10633 index: 18u8,
10634 serializer_id: 8i32,
10635 value: EntityData::Boolean(*self.is_charging_crossbow.get()),
10636 });
10637 }
10638 if !self.is_dancing.is_default() {
10639 values.push(DataValue {
10640 index: 19u8,
10641 serializer_id: 8i32,
10642 value: EntityData::Boolean(*self.is_dancing.get()),
10643 });
10644 }
10645 }
10646 #[doc = r" Returns `true` if any field has been modified."]
10647 pub fn is_dirty(&self) -> bool {
10648 self.abstract_piglin.is_dirty()
10649 || self.baby.is_dirty()
10650 || self.is_charging_crossbow.is_dirty()
10651 || self.is_dancing.is_dirty()
10652 }
10653}
10654impl Default for PiglinEntityData {
10655 fn default() -> Self {
10656 Self::new()
10657 }
10658}
10659impl VanillaEntityData for PiglinEntityData {
10660 fn base(&self) -> &BaseEntityData {
10661 PiglinEntityData::base(self)
10662 }
10663 fn base_mut(&mut self) -> &mut BaseEntityData {
10664 PiglinEntityData::base_mut(self)
10665 }
10666 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10667 PiglinEntityData::pack_dirty(self)
10668 }
10669 fn pack_all(&self) -> Vec<DataValue> {
10670 PiglinEntityData::pack_all(self)
10671 }
10672 fn is_dirty(&self) -> bool {
10673 PiglinEntityData::is_dirty(self)
10674 }
10675}
10676impl VanillaLivingEntityData for PiglinEntityData {
10677 fn living_entity(&self) -> &LivingEntityData {
10678 PiglinEntityData::living_entity(self)
10679 }
10680 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10681 PiglinEntityData::living_entity_mut(self)
10682 }
10683}
10684#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
10685#[derive(Debug, Clone)]
10686pub struct PillagerEntityData {
10687 pub raider: RaiderEntityData,
10688 pub is_charging_crossbow: SyncedValue<bool>,
10689}
10690impl PillagerEntityData {
10691 #[doc = r" Create new entity data with default values."]
10692 pub fn new() -> Self {
10693 Self {
10694 raider: RaiderEntityData::new(),
10695 is_charging_crossbow: SyncedValue::new(false),
10696 }
10697 }
10698 #[doc = "Returns the `PillagerEntityData` layer."]
10699 pub fn pillager(&self) -> &PillagerEntityData {
10700 self
10701 }
10702 #[doc = "Returns the mutable `PillagerEntityData` layer."]
10703 pub fn pillager_mut(&mut self) -> &mut PillagerEntityData {
10704 self
10705 }
10706 #[doc = "Returns the `RaiderEntityData` layer."]
10707 pub fn raider(&self) -> &RaiderEntityData {
10708 &self.raider
10709 }
10710 #[doc = "Returns the mutable `RaiderEntityData` layer."]
10711 pub fn raider_mut(&mut self) -> &mut RaiderEntityData {
10712 &mut self.raider
10713 }
10714 #[doc = "Returns the `MobEntityData` layer."]
10715 pub fn mob(&self) -> &MobEntityData {
10716 &self.raider.mob
10717 }
10718 #[doc = "Returns the mutable `MobEntityData` layer."]
10719 pub fn mob_mut(&mut self) -> &mut MobEntityData {
10720 &mut self.raider.mob
10721 }
10722 #[doc = "Returns the `LivingEntityData` layer."]
10723 pub fn living_entity(&self) -> &LivingEntityData {
10724 &self.raider.mob.living_entity
10725 }
10726 #[doc = "Returns the mutable `LivingEntityData` layer."]
10727 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10728 &mut self.raider.mob.living_entity
10729 }
10730 #[doc = "Returns the `BaseEntityData` layer."]
10731 pub fn base(&self) -> &BaseEntityData {
10732 &self.raider.mob.living_entity.base
10733 }
10734 #[doc = "Returns the mutable `BaseEntityData` layer."]
10735 pub fn base_mut(&mut self) -> &mut BaseEntityData {
10736 &mut self.raider.mob.living_entity.base
10737 }
10738 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
10739 #[doc = r" Returns `None` if no values are dirty."]
10740 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10741 let mut values = Vec::new();
10742 self.pack_dirty_into(&mut values);
10743 if values.is_empty() {
10744 None
10745 } else {
10746 Some(values)
10747 }
10748 }
10749 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
10750 self.raider.pack_dirty_into(values);
10751 if self.is_charging_crossbow.is_dirty() {
10752 values.push(DataValue {
10753 index: 17u8,
10754 serializer_id: 8i32,
10755 value: EntityData::Boolean(*self.is_charging_crossbow.get()),
10756 });
10757 self.is_charging_crossbow.clear_dirty();
10758 }
10759 }
10760 #[doc = r" Pack all non-default values (for initial entity spawn)."]
10761 pub fn pack_all(&self) -> Vec<DataValue> {
10762 let mut values = Vec::new();
10763 self.pack_all_into(&mut values);
10764 values
10765 }
10766 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
10767 self.raider.pack_all_into(values);
10768 if !self.is_charging_crossbow.is_default() {
10769 values.push(DataValue {
10770 index: 17u8,
10771 serializer_id: 8i32,
10772 value: EntityData::Boolean(*self.is_charging_crossbow.get()),
10773 });
10774 }
10775 }
10776 #[doc = r" Returns `true` if any field has been modified."]
10777 pub fn is_dirty(&self) -> bool {
10778 self.raider.is_dirty() || self.is_charging_crossbow.is_dirty()
10779 }
10780}
10781impl Default for PillagerEntityData {
10782 fn default() -> Self {
10783 Self::new()
10784 }
10785}
10786impl VanillaEntityData for PillagerEntityData {
10787 fn base(&self) -> &BaseEntityData {
10788 PillagerEntityData::base(self)
10789 }
10790 fn base_mut(&mut self) -> &mut BaseEntityData {
10791 PillagerEntityData::base_mut(self)
10792 }
10793 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10794 PillagerEntityData::pack_dirty(self)
10795 }
10796 fn pack_all(&self) -> Vec<DataValue> {
10797 PillagerEntityData::pack_all(self)
10798 }
10799 fn is_dirty(&self) -> bool {
10800 PillagerEntityData::is_dirty(self)
10801 }
10802}
10803impl VanillaLivingEntityData for PillagerEntityData {
10804 fn living_entity(&self) -> &LivingEntityData {
10805 PillagerEntityData::living_entity(self)
10806 }
10807 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10808 PillagerEntityData::living_entity_mut(self)
10809 }
10810}
10811#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
10812#[derive(Debug, Clone)]
10813pub struct PolarBearEntityData {
10814 pub ageable_mob: AgeableMobEntityData,
10815 pub standing: SyncedValue<bool>,
10816}
10817impl PolarBearEntityData {
10818 #[doc = r" Create new entity data with default values."]
10819 pub fn new() -> Self {
10820 Self {
10821 ageable_mob: AgeableMobEntityData::new(),
10822 standing: SyncedValue::new(false),
10823 }
10824 }
10825 #[doc = "Returns the `PolarBearEntityData` layer."]
10826 pub fn polar_bear(&self) -> &PolarBearEntityData {
10827 self
10828 }
10829 #[doc = "Returns the mutable `PolarBearEntityData` layer."]
10830 pub fn polar_bear_mut(&mut self) -> &mut PolarBearEntityData {
10831 self
10832 }
10833 #[doc = "Returns the `AgeableMobEntityData` layer."]
10834 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
10835 &self.ageable_mob
10836 }
10837 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
10838 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
10839 &mut self.ageable_mob
10840 }
10841 #[doc = "Returns the `MobEntityData` layer."]
10842 pub fn mob(&self) -> &MobEntityData {
10843 &self.ageable_mob.mob
10844 }
10845 #[doc = "Returns the mutable `MobEntityData` layer."]
10846 pub fn mob_mut(&mut self) -> &mut MobEntityData {
10847 &mut self.ageable_mob.mob
10848 }
10849 #[doc = "Returns the `LivingEntityData` layer."]
10850 pub fn living_entity(&self) -> &LivingEntityData {
10851 &self.ageable_mob.mob.living_entity
10852 }
10853 #[doc = "Returns the mutable `LivingEntityData` layer."]
10854 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10855 &mut self.ageable_mob.mob.living_entity
10856 }
10857 #[doc = "Returns the `BaseEntityData` layer."]
10858 pub fn base(&self) -> &BaseEntityData {
10859 &self.ageable_mob.mob.living_entity.base
10860 }
10861 #[doc = "Returns the mutable `BaseEntityData` layer."]
10862 pub fn base_mut(&mut self) -> &mut BaseEntityData {
10863 &mut self.ageable_mob.mob.living_entity.base
10864 }
10865 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
10866 #[doc = r" Returns `None` if no values are dirty."]
10867 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10868 let mut values = Vec::new();
10869 self.pack_dirty_into(&mut values);
10870 if values.is_empty() {
10871 None
10872 } else {
10873 Some(values)
10874 }
10875 }
10876 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
10877 self.ageable_mob.pack_dirty_into(values);
10878 if self.standing.is_dirty() {
10879 values.push(DataValue {
10880 index: 18u8,
10881 serializer_id: 8i32,
10882 value: EntityData::Boolean(*self.standing.get()),
10883 });
10884 self.standing.clear_dirty();
10885 }
10886 }
10887 #[doc = r" Pack all non-default values (for initial entity spawn)."]
10888 pub fn pack_all(&self) -> Vec<DataValue> {
10889 let mut values = Vec::new();
10890 self.pack_all_into(&mut values);
10891 values
10892 }
10893 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
10894 self.ageable_mob.pack_all_into(values);
10895 if !self.standing.is_default() {
10896 values.push(DataValue {
10897 index: 18u8,
10898 serializer_id: 8i32,
10899 value: EntityData::Boolean(*self.standing.get()),
10900 });
10901 }
10902 }
10903 #[doc = r" Returns `true` if any field has been modified."]
10904 pub fn is_dirty(&self) -> bool {
10905 self.ageable_mob.is_dirty() || self.standing.is_dirty()
10906 }
10907}
10908impl Default for PolarBearEntityData {
10909 fn default() -> Self {
10910 Self::new()
10911 }
10912}
10913impl VanillaEntityData for PolarBearEntityData {
10914 fn base(&self) -> &BaseEntityData {
10915 PolarBearEntityData::base(self)
10916 }
10917 fn base_mut(&mut self) -> &mut BaseEntityData {
10918 PolarBearEntityData::base_mut(self)
10919 }
10920 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10921 PolarBearEntityData::pack_dirty(self)
10922 }
10923 fn pack_all(&self) -> Vec<DataValue> {
10924 PolarBearEntityData::pack_all(self)
10925 }
10926 fn is_dirty(&self) -> bool {
10927 PolarBearEntityData::is_dirty(self)
10928 }
10929}
10930impl VanillaLivingEntityData for PolarBearEntityData {
10931 fn living_entity(&self) -> &LivingEntityData {
10932 PolarBearEntityData::living_entity(self)
10933 }
10934 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10935 PolarBearEntityData::living_entity_mut(self)
10936 }
10937}
10938#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
10939#[derive(Debug, Clone)]
10940pub struct PufferfishEntityData {
10941 pub abstract_fish: AbstractFishEntityData,
10942 pub puff_state: SyncedValue<i32>,
10943}
10944impl PufferfishEntityData {
10945 #[doc = r" Create new entity data with default values."]
10946 pub fn new() -> Self {
10947 Self {
10948 abstract_fish: AbstractFishEntityData::new(),
10949 puff_state: SyncedValue::new(0i32),
10950 }
10951 }
10952 #[doc = "Returns the `PufferfishEntityData` layer."]
10953 pub fn pufferfish(&self) -> &PufferfishEntityData {
10954 self
10955 }
10956 #[doc = "Returns the mutable `PufferfishEntityData` layer."]
10957 pub fn pufferfish_mut(&mut self) -> &mut PufferfishEntityData {
10958 self
10959 }
10960 #[doc = "Returns the `AbstractFishEntityData` layer."]
10961 pub fn abstract_fish(&self) -> &AbstractFishEntityData {
10962 &self.abstract_fish
10963 }
10964 #[doc = "Returns the mutable `AbstractFishEntityData` layer."]
10965 pub fn abstract_fish_mut(&mut self) -> &mut AbstractFishEntityData {
10966 &mut self.abstract_fish
10967 }
10968 #[doc = "Returns the `MobEntityData` layer."]
10969 pub fn mob(&self) -> &MobEntityData {
10970 &self.abstract_fish.mob
10971 }
10972 #[doc = "Returns the mutable `MobEntityData` layer."]
10973 pub fn mob_mut(&mut self) -> &mut MobEntityData {
10974 &mut self.abstract_fish.mob
10975 }
10976 #[doc = "Returns the `LivingEntityData` layer."]
10977 pub fn living_entity(&self) -> &LivingEntityData {
10978 &self.abstract_fish.mob.living_entity
10979 }
10980 #[doc = "Returns the mutable `LivingEntityData` layer."]
10981 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
10982 &mut self.abstract_fish.mob.living_entity
10983 }
10984 #[doc = "Returns the `BaseEntityData` layer."]
10985 pub fn base(&self) -> &BaseEntityData {
10986 &self.abstract_fish.mob.living_entity.base
10987 }
10988 #[doc = "Returns the mutable `BaseEntityData` layer."]
10989 pub fn base_mut(&mut self) -> &mut BaseEntityData {
10990 &mut self.abstract_fish.mob.living_entity.base
10991 }
10992 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
10993 #[doc = r" Returns `None` if no values are dirty."]
10994 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
10995 let mut values = Vec::new();
10996 self.pack_dirty_into(&mut values);
10997 if values.is_empty() {
10998 None
10999 } else {
11000 Some(values)
11001 }
11002 }
11003 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
11004 self.abstract_fish.pack_dirty_into(values);
11005 if self.puff_state.is_dirty() {
11006 values.push(DataValue {
11007 index: 17u8,
11008 serializer_id: 1i32,
11009 value: EntityData::Int(*self.puff_state.get()),
11010 });
11011 self.puff_state.clear_dirty();
11012 }
11013 }
11014 #[doc = r" Pack all non-default values (for initial entity spawn)."]
11015 pub fn pack_all(&self) -> Vec<DataValue> {
11016 let mut values = Vec::new();
11017 self.pack_all_into(&mut values);
11018 values
11019 }
11020 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
11021 self.abstract_fish.pack_all_into(values);
11022 if !self.puff_state.is_default() {
11023 values.push(DataValue {
11024 index: 17u8,
11025 serializer_id: 1i32,
11026 value: EntityData::Int(*self.puff_state.get()),
11027 });
11028 }
11029 }
11030 #[doc = r" Returns `true` if any field has been modified."]
11031 pub fn is_dirty(&self) -> bool {
11032 self.abstract_fish.is_dirty() || self.puff_state.is_dirty()
11033 }
11034}
11035impl Default for PufferfishEntityData {
11036 fn default() -> Self {
11037 Self::new()
11038 }
11039}
11040impl VanillaEntityData for PufferfishEntityData {
11041 fn base(&self) -> &BaseEntityData {
11042 PufferfishEntityData::base(self)
11043 }
11044 fn base_mut(&mut self) -> &mut BaseEntityData {
11045 PufferfishEntityData::base_mut(self)
11046 }
11047 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11048 PufferfishEntityData::pack_dirty(self)
11049 }
11050 fn pack_all(&self) -> Vec<DataValue> {
11051 PufferfishEntityData::pack_all(self)
11052 }
11053 fn is_dirty(&self) -> bool {
11054 PufferfishEntityData::is_dirty(self)
11055 }
11056}
11057impl VanillaLivingEntityData for PufferfishEntityData {
11058 fn living_entity(&self) -> &LivingEntityData {
11059 PufferfishEntityData::living_entity(self)
11060 }
11061 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11062 PufferfishEntityData::living_entity_mut(self)
11063 }
11064}
11065#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
11066#[derive(Debug, Clone)]
11067pub struct RabbitEntityData {
11068 pub ageable_mob: AgeableMobEntityData,
11069 pub variant_type: SyncedValue<i32>,
11070}
11071impl RabbitEntityData {
11072 #[doc = r" Create new entity data with default values."]
11073 pub fn new() -> Self {
11074 Self {
11075 ageable_mob: AgeableMobEntityData::new(),
11076 variant_type: SyncedValue::new(0i32),
11077 }
11078 }
11079 #[doc = "Returns the `RabbitEntityData` layer."]
11080 pub fn rabbit(&self) -> &RabbitEntityData {
11081 self
11082 }
11083 #[doc = "Returns the mutable `RabbitEntityData` layer."]
11084 pub fn rabbit_mut(&mut self) -> &mut RabbitEntityData {
11085 self
11086 }
11087 #[doc = "Returns the `AgeableMobEntityData` layer."]
11088 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
11089 &self.ageable_mob
11090 }
11091 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
11092 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
11093 &mut self.ageable_mob
11094 }
11095 #[doc = "Returns the `MobEntityData` layer."]
11096 pub fn mob(&self) -> &MobEntityData {
11097 &self.ageable_mob.mob
11098 }
11099 #[doc = "Returns the mutable `MobEntityData` layer."]
11100 pub fn mob_mut(&mut self) -> &mut MobEntityData {
11101 &mut self.ageable_mob.mob
11102 }
11103 #[doc = "Returns the `LivingEntityData` layer."]
11104 pub fn living_entity(&self) -> &LivingEntityData {
11105 &self.ageable_mob.mob.living_entity
11106 }
11107 #[doc = "Returns the mutable `LivingEntityData` layer."]
11108 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11109 &mut self.ageable_mob.mob.living_entity
11110 }
11111 #[doc = "Returns the `BaseEntityData` layer."]
11112 pub fn base(&self) -> &BaseEntityData {
11113 &self.ageable_mob.mob.living_entity.base
11114 }
11115 #[doc = "Returns the mutable `BaseEntityData` layer."]
11116 pub fn base_mut(&mut self) -> &mut BaseEntityData {
11117 &mut self.ageable_mob.mob.living_entity.base
11118 }
11119 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
11120 #[doc = r" Returns `None` if no values are dirty."]
11121 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11122 let mut values = Vec::new();
11123 self.pack_dirty_into(&mut values);
11124 if values.is_empty() {
11125 None
11126 } else {
11127 Some(values)
11128 }
11129 }
11130 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
11131 self.ageable_mob.pack_dirty_into(values);
11132 if self.variant_type.is_dirty() {
11133 values.push(DataValue {
11134 index: 18u8,
11135 serializer_id: 1i32,
11136 value: EntityData::Int(*self.variant_type.get()),
11137 });
11138 self.variant_type.clear_dirty();
11139 }
11140 }
11141 #[doc = r" Pack all non-default values (for initial entity spawn)."]
11142 pub fn pack_all(&self) -> Vec<DataValue> {
11143 let mut values = Vec::new();
11144 self.pack_all_into(&mut values);
11145 values
11146 }
11147 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
11148 self.ageable_mob.pack_all_into(values);
11149 if !self.variant_type.is_default() {
11150 values.push(DataValue {
11151 index: 18u8,
11152 serializer_id: 1i32,
11153 value: EntityData::Int(*self.variant_type.get()),
11154 });
11155 }
11156 }
11157 #[doc = r" Returns `true` if any field has been modified."]
11158 pub fn is_dirty(&self) -> bool {
11159 self.ageable_mob.is_dirty() || self.variant_type.is_dirty()
11160 }
11161}
11162impl Default for RabbitEntityData {
11163 fn default() -> Self {
11164 Self::new()
11165 }
11166}
11167impl VanillaEntityData for RabbitEntityData {
11168 fn base(&self) -> &BaseEntityData {
11169 RabbitEntityData::base(self)
11170 }
11171 fn base_mut(&mut self) -> &mut BaseEntityData {
11172 RabbitEntityData::base_mut(self)
11173 }
11174 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11175 RabbitEntityData::pack_dirty(self)
11176 }
11177 fn pack_all(&self) -> Vec<DataValue> {
11178 RabbitEntityData::pack_all(self)
11179 }
11180 fn is_dirty(&self) -> bool {
11181 RabbitEntityData::is_dirty(self)
11182 }
11183}
11184impl VanillaLivingEntityData for RabbitEntityData {
11185 fn living_entity(&self) -> &LivingEntityData {
11186 RabbitEntityData::living_entity(self)
11187 }
11188 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11189 RabbitEntityData::living_entity_mut(self)
11190 }
11191}
11192#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
11193#[derive(Debug, Clone)]
11194pub struct SalmonEntityData {
11195 pub abstract_fish: AbstractFishEntityData,
11196 pub variant_type: SyncedValue<i32>,
11197}
11198impl SalmonEntityData {
11199 #[doc = r" Create new entity data with default values."]
11200 pub fn new() -> Self {
11201 Self {
11202 abstract_fish: AbstractFishEntityData::new(),
11203 variant_type: SyncedValue::new(1i32),
11204 }
11205 }
11206 #[doc = "Returns the `SalmonEntityData` layer."]
11207 pub fn salmon(&self) -> &SalmonEntityData {
11208 self
11209 }
11210 #[doc = "Returns the mutable `SalmonEntityData` layer."]
11211 pub fn salmon_mut(&mut self) -> &mut SalmonEntityData {
11212 self
11213 }
11214 #[doc = "Returns the `AbstractFishEntityData` layer."]
11215 pub fn abstract_fish(&self) -> &AbstractFishEntityData {
11216 &self.abstract_fish
11217 }
11218 #[doc = "Returns the mutable `AbstractFishEntityData` layer."]
11219 pub fn abstract_fish_mut(&mut self) -> &mut AbstractFishEntityData {
11220 &mut self.abstract_fish
11221 }
11222 #[doc = "Returns the `MobEntityData` layer."]
11223 pub fn mob(&self) -> &MobEntityData {
11224 &self.abstract_fish.mob
11225 }
11226 #[doc = "Returns the mutable `MobEntityData` layer."]
11227 pub fn mob_mut(&mut self) -> &mut MobEntityData {
11228 &mut self.abstract_fish.mob
11229 }
11230 #[doc = "Returns the `LivingEntityData` layer."]
11231 pub fn living_entity(&self) -> &LivingEntityData {
11232 &self.abstract_fish.mob.living_entity
11233 }
11234 #[doc = "Returns the mutable `LivingEntityData` layer."]
11235 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11236 &mut self.abstract_fish.mob.living_entity
11237 }
11238 #[doc = "Returns the `BaseEntityData` layer."]
11239 pub fn base(&self) -> &BaseEntityData {
11240 &self.abstract_fish.mob.living_entity.base
11241 }
11242 #[doc = "Returns the mutable `BaseEntityData` layer."]
11243 pub fn base_mut(&mut self) -> &mut BaseEntityData {
11244 &mut self.abstract_fish.mob.living_entity.base
11245 }
11246 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
11247 #[doc = r" Returns `None` if no values are dirty."]
11248 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11249 let mut values = Vec::new();
11250 self.pack_dirty_into(&mut values);
11251 if values.is_empty() {
11252 None
11253 } else {
11254 Some(values)
11255 }
11256 }
11257 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
11258 self.abstract_fish.pack_dirty_into(values);
11259 if self.variant_type.is_dirty() {
11260 values.push(DataValue {
11261 index: 17u8,
11262 serializer_id: 1i32,
11263 value: EntityData::Int(*self.variant_type.get()),
11264 });
11265 self.variant_type.clear_dirty();
11266 }
11267 }
11268 #[doc = r" Pack all non-default values (for initial entity spawn)."]
11269 pub fn pack_all(&self) -> Vec<DataValue> {
11270 let mut values = Vec::new();
11271 self.pack_all_into(&mut values);
11272 values
11273 }
11274 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
11275 self.abstract_fish.pack_all_into(values);
11276 if !self.variant_type.is_default() {
11277 values.push(DataValue {
11278 index: 17u8,
11279 serializer_id: 1i32,
11280 value: EntityData::Int(*self.variant_type.get()),
11281 });
11282 }
11283 }
11284 #[doc = r" Returns `true` if any field has been modified."]
11285 pub fn is_dirty(&self) -> bool {
11286 self.abstract_fish.is_dirty() || self.variant_type.is_dirty()
11287 }
11288}
11289impl Default for SalmonEntityData {
11290 fn default() -> Self {
11291 Self::new()
11292 }
11293}
11294impl VanillaEntityData for SalmonEntityData {
11295 fn base(&self) -> &BaseEntityData {
11296 SalmonEntityData::base(self)
11297 }
11298 fn base_mut(&mut self) -> &mut BaseEntityData {
11299 SalmonEntityData::base_mut(self)
11300 }
11301 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11302 SalmonEntityData::pack_dirty(self)
11303 }
11304 fn pack_all(&self) -> Vec<DataValue> {
11305 SalmonEntityData::pack_all(self)
11306 }
11307 fn is_dirty(&self) -> bool {
11308 SalmonEntityData::is_dirty(self)
11309 }
11310}
11311impl VanillaLivingEntityData for SalmonEntityData {
11312 fn living_entity(&self) -> &LivingEntityData {
11313 SalmonEntityData::living_entity(self)
11314 }
11315 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11316 SalmonEntityData::living_entity_mut(self)
11317 }
11318}
11319#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
11320#[derive(Debug, Clone)]
11321pub struct SheepEntityData {
11322 pub ageable_mob: AgeableMobEntityData,
11323 pub wool: SyncedValue<i8>,
11324}
11325impl SheepEntityData {
11326 #[doc = r" Create new entity data with default values."]
11327 pub fn new() -> Self {
11328 Self {
11329 ageable_mob: AgeableMobEntityData::new(),
11330 wool: SyncedValue::new(0i8),
11331 }
11332 }
11333 #[doc = "Returns the `SheepEntityData` layer."]
11334 pub fn sheep(&self) -> &SheepEntityData {
11335 self
11336 }
11337 #[doc = "Returns the mutable `SheepEntityData` layer."]
11338 pub fn sheep_mut(&mut self) -> &mut SheepEntityData {
11339 self
11340 }
11341 #[doc = "Returns the `AgeableMobEntityData` layer."]
11342 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
11343 &self.ageable_mob
11344 }
11345 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
11346 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
11347 &mut self.ageable_mob
11348 }
11349 #[doc = "Returns the `MobEntityData` layer."]
11350 pub fn mob(&self) -> &MobEntityData {
11351 &self.ageable_mob.mob
11352 }
11353 #[doc = "Returns the mutable `MobEntityData` layer."]
11354 pub fn mob_mut(&mut self) -> &mut MobEntityData {
11355 &mut self.ageable_mob.mob
11356 }
11357 #[doc = "Returns the `LivingEntityData` layer."]
11358 pub fn living_entity(&self) -> &LivingEntityData {
11359 &self.ageable_mob.mob.living_entity
11360 }
11361 #[doc = "Returns the mutable `LivingEntityData` layer."]
11362 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11363 &mut self.ageable_mob.mob.living_entity
11364 }
11365 #[doc = "Returns the `BaseEntityData` layer."]
11366 pub fn base(&self) -> &BaseEntityData {
11367 &self.ageable_mob.mob.living_entity.base
11368 }
11369 #[doc = "Returns the mutable `BaseEntityData` layer."]
11370 pub fn base_mut(&mut self) -> &mut BaseEntityData {
11371 &mut self.ageable_mob.mob.living_entity.base
11372 }
11373 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
11374 #[doc = r" Returns `None` if no values are dirty."]
11375 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11376 let mut values = Vec::new();
11377 self.pack_dirty_into(&mut values);
11378 if values.is_empty() {
11379 None
11380 } else {
11381 Some(values)
11382 }
11383 }
11384 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
11385 self.ageable_mob.pack_dirty_into(values);
11386 if self.wool.is_dirty() {
11387 values.push(DataValue {
11388 index: 18u8,
11389 serializer_id: 0i32,
11390 value: EntityData::Byte(*self.wool.get()),
11391 });
11392 self.wool.clear_dirty();
11393 }
11394 }
11395 #[doc = r" Pack all non-default values (for initial entity spawn)."]
11396 pub fn pack_all(&self) -> Vec<DataValue> {
11397 let mut values = Vec::new();
11398 self.pack_all_into(&mut values);
11399 values
11400 }
11401 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
11402 self.ageable_mob.pack_all_into(values);
11403 if !self.wool.is_default() {
11404 values.push(DataValue {
11405 index: 18u8,
11406 serializer_id: 0i32,
11407 value: EntityData::Byte(*self.wool.get()),
11408 });
11409 }
11410 }
11411 #[doc = r" Returns `true` if any field has been modified."]
11412 pub fn is_dirty(&self) -> bool {
11413 self.ageable_mob.is_dirty() || self.wool.is_dirty()
11414 }
11415}
11416impl Default for SheepEntityData {
11417 fn default() -> Self {
11418 Self::new()
11419 }
11420}
11421impl VanillaEntityData for SheepEntityData {
11422 fn base(&self) -> &BaseEntityData {
11423 SheepEntityData::base(self)
11424 }
11425 fn base_mut(&mut self) -> &mut BaseEntityData {
11426 SheepEntityData::base_mut(self)
11427 }
11428 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11429 SheepEntityData::pack_dirty(self)
11430 }
11431 fn pack_all(&self) -> Vec<DataValue> {
11432 SheepEntityData::pack_all(self)
11433 }
11434 fn is_dirty(&self) -> bool {
11435 SheepEntityData::is_dirty(self)
11436 }
11437}
11438impl VanillaLivingEntityData for SheepEntityData {
11439 fn living_entity(&self) -> &LivingEntityData {
11440 SheepEntityData::living_entity(self)
11441 }
11442 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11443 SheepEntityData::living_entity_mut(self)
11444 }
11445}
11446#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
11447#[derive(Debug, Clone)]
11448pub struct ShulkerEntityData {
11449 pub mob: MobEntityData,
11450 pub attach_face: SyncedValue<Direction>,
11451 pub peek: SyncedValue<i8>,
11452 pub color: SyncedValue<i8>,
11453}
11454impl ShulkerEntityData {
11455 #[doc = r" Create new entity data with default values."]
11456 pub fn new() -> Self {
11457 Self {
11458 mob: MobEntityData::new(),
11459 attach_face: SyncedValue::new(Direction::Down),
11460 peek: SyncedValue::new(0i8),
11461 color: SyncedValue::new(16i8),
11462 }
11463 }
11464 #[doc = "Returns the `ShulkerEntityData` layer."]
11465 pub fn shulker(&self) -> &ShulkerEntityData {
11466 self
11467 }
11468 #[doc = "Returns the mutable `ShulkerEntityData` layer."]
11469 pub fn shulker_mut(&mut self) -> &mut ShulkerEntityData {
11470 self
11471 }
11472 #[doc = "Returns the `MobEntityData` layer."]
11473 pub fn mob(&self) -> &MobEntityData {
11474 &self.mob
11475 }
11476 #[doc = "Returns the mutable `MobEntityData` layer."]
11477 pub fn mob_mut(&mut self) -> &mut MobEntityData {
11478 &mut self.mob
11479 }
11480 #[doc = "Returns the `LivingEntityData` layer."]
11481 pub fn living_entity(&self) -> &LivingEntityData {
11482 &self.mob.living_entity
11483 }
11484 #[doc = "Returns the mutable `LivingEntityData` layer."]
11485 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11486 &mut self.mob.living_entity
11487 }
11488 #[doc = "Returns the `BaseEntityData` layer."]
11489 pub fn base(&self) -> &BaseEntityData {
11490 &self.mob.living_entity.base
11491 }
11492 #[doc = "Returns the mutable `BaseEntityData` layer."]
11493 pub fn base_mut(&mut self) -> &mut BaseEntityData {
11494 &mut self.mob.living_entity.base
11495 }
11496 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
11497 #[doc = r" Returns `None` if no values are dirty."]
11498 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11499 let mut values = Vec::new();
11500 self.pack_dirty_into(&mut values);
11501 if values.is_empty() {
11502 None
11503 } else {
11504 Some(values)
11505 }
11506 }
11507 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
11508 self.mob.pack_dirty_into(values);
11509 if self.attach_face.is_dirty() {
11510 values.push(DataValue {
11511 index: 16u8,
11512 serializer_id: 12i32,
11513 value: EntityData::Direction(*self.attach_face.get()),
11514 });
11515 self.attach_face.clear_dirty();
11516 }
11517 if self.peek.is_dirty() {
11518 values.push(DataValue {
11519 index: 17u8,
11520 serializer_id: 0i32,
11521 value: EntityData::Byte(*self.peek.get()),
11522 });
11523 self.peek.clear_dirty();
11524 }
11525 if self.color.is_dirty() {
11526 values.push(DataValue {
11527 index: 18u8,
11528 serializer_id: 0i32,
11529 value: EntityData::Byte(*self.color.get()),
11530 });
11531 self.color.clear_dirty();
11532 }
11533 }
11534 #[doc = r" Pack all non-default values (for initial entity spawn)."]
11535 pub fn pack_all(&self) -> Vec<DataValue> {
11536 let mut values = Vec::new();
11537 self.pack_all_into(&mut values);
11538 values
11539 }
11540 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
11541 self.mob.pack_all_into(values);
11542 if !self.attach_face.is_default() {
11543 values.push(DataValue {
11544 index: 16u8,
11545 serializer_id: 12i32,
11546 value: EntityData::Direction(*self.attach_face.get()),
11547 });
11548 }
11549 if !self.peek.is_default() {
11550 values.push(DataValue {
11551 index: 17u8,
11552 serializer_id: 0i32,
11553 value: EntityData::Byte(*self.peek.get()),
11554 });
11555 }
11556 if !self.color.is_default() {
11557 values.push(DataValue {
11558 index: 18u8,
11559 serializer_id: 0i32,
11560 value: EntityData::Byte(*self.color.get()),
11561 });
11562 }
11563 }
11564 #[doc = r" Returns `true` if any field has been modified."]
11565 pub fn is_dirty(&self) -> bool {
11566 self.mob.is_dirty()
11567 || self.attach_face.is_dirty()
11568 || self.peek.is_dirty()
11569 || self.color.is_dirty()
11570 }
11571}
11572impl Default for ShulkerEntityData {
11573 fn default() -> Self {
11574 Self::new()
11575 }
11576}
11577impl VanillaEntityData for ShulkerEntityData {
11578 fn base(&self) -> &BaseEntityData {
11579 ShulkerEntityData::base(self)
11580 }
11581 fn base_mut(&mut self) -> &mut BaseEntityData {
11582 ShulkerEntityData::base_mut(self)
11583 }
11584 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11585 ShulkerEntityData::pack_dirty(self)
11586 }
11587 fn pack_all(&self) -> Vec<DataValue> {
11588 ShulkerEntityData::pack_all(self)
11589 }
11590 fn is_dirty(&self) -> bool {
11591 ShulkerEntityData::is_dirty(self)
11592 }
11593}
11594impl VanillaLivingEntityData for ShulkerEntityData {
11595 fn living_entity(&self) -> &LivingEntityData {
11596 ShulkerEntityData::living_entity(self)
11597 }
11598 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11599 ShulkerEntityData::living_entity_mut(self)
11600 }
11601}
11602#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
11603#[derive(Debug, Clone)]
11604pub struct SkeletonEntityData {
11605 pub mob: MobEntityData,
11606 pub stray_conversion: SyncedValue<bool>,
11607}
11608impl SkeletonEntityData {
11609 #[doc = r" Create new entity data with default values."]
11610 pub fn new() -> Self {
11611 Self {
11612 mob: MobEntityData::new(),
11613 stray_conversion: SyncedValue::new(false),
11614 }
11615 }
11616 #[doc = "Returns the `SkeletonEntityData` layer."]
11617 pub fn skeleton(&self) -> &SkeletonEntityData {
11618 self
11619 }
11620 #[doc = "Returns the mutable `SkeletonEntityData` layer."]
11621 pub fn skeleton_mut(&mut self) -> &mut SkeletonEntityData {
11622 self
11623 }
11624 #[doc = "Returns the `MobEntityData` layer."]
11625 pub fn mob(&self) -> &MobEntityData {
11626 &self.mob
11627 }
11628 #[doc = "Returns the mutable `MobEntityData` layer."]
11629 pub fn mob_mut(&mut self) -> &mut MobEntityData {
11630 &mut self.mob
11631 }
11632 #[doc = "Returns the `LivingEntityData` layer."]
11633 pub fn living_entity(&self) -> &LivingEntityData {
11634 &self.mob.living_entity
11635 }
11636 #[doc = "Returns the mutable `LivingEntityData` layer."]
11637 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11638 &mut self.mob.living_entity
11639 }
11640 #[doc = "Returns the `BaseEntityData` layer."]
11641 pub fn base(&self) -> &BaseEntityData {
11642 &self.mob.living_entity.base
11643 }
11644 #[doc = "Returns the mutable `BaseEntityData` layer."]
11645 pub fn base_mut(&mut self) -> &mut BaseEntityData {
11646 &mut self.mob.living_entity.base
11647 }
11648 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
11649 #[doc = r" Returns `None` if no values are dirty."]
11650 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11651 let mut values = Vec::new();
11652 self.pack_dirty_into(&mut values);
11653 if values.is_empty() {
11654 None
11655 } else {
11656 Some(values)
11657 }
11658 }
11659 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
11660 self.mob.pack_dirty_into(values);
11661 if self.stray_conversion.is_dirty() {
11662 values.push(DataValue {
11663 index: 16u8,
11664 serializer_id: 8i32,
11665 value: EntityData::Boolean(*self.stray_conversion.get()),
11666 });
11667 self.stray_conversion.clear_dirty();
11668 }
11669 }
11670 #[doc = r" Pack all non-default values (for initial entity spawn)."]
11671 pub fn pack_all(&self) -> Vec<DataValue> {
11672 let mut values = Vec::new();
11673 self.pack_all_into(&mut values);
11674 values
11675 }
11676 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
11677 self.mob.pack_all_into(values);
11678 if !self.stray_conversion.is_default() {
11679 values.push(DataValue {
11680 index: 16u8,
11681 serializer_id: 8i32,
11682 value: EntityData::Boolean(*self.stray_conversion.get()),
11683 });
11684 }
11685 }
11686 #[doc = r" Returns `true` if any field has been modified."]
11687 pub fn is_dirty(&self) -> bool {
11688 self.mob.is_dirty() || self.stray_conversion.is_dirty()
11689 }
11690}
11691impl Default for SkeletonEntityData {
11692 fn default() -> Self {
11693 Self::new()
11694 }
11695}
11696impl VanillaEntityData for SkeletonEntityData {
11697 fn base(&self) -> &BaseEntityData {
11698 SkeletonEntityData::base(self)
11699 }
11700 fn base_mut(&mut self) -> &mut BaseEntityData {
11701 SkeletonEntityData::base_mut(self)
11702 }
11703 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11704 SkeletonEntityData::pack_dirty(self)
11705 }
11706 fn pack_all(&self) -> Vec<DataValue> {
11707 SkeletonEntityData::pack_all(self)
11708 }
11709 fn is_dirty(&self) -> bool {
11710 SkeletonEntityData::is_dirty(self)
11711 }
11712}
11713impl VanillaLivingEntityData for SkeletonEntityData {
11714 fn living_entity(&self) -> &LivingEntityData {
11715 SkeletonEntityData::living_entity(self)
11716 }
11717 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11718 SkeletonEntityData::living_entity_mut(self)
11719 }
11720}
11721#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
11722#[derive(Debug, Clone)]
11723pub struct SnifferEntityData {
11724 pub ageable_mob: AgeableMobEntityData,
11725 pub state: SyncedValue<SnifferState>,
11726 pub drop_seed_at_tick: SyncedValue<i32>,
11727}
11728impl SnifferEntityData {
11729 #[doc = r" Create new entity data with default values."]
11730 pub fn new() -> Self {
11731 Self {
11732 ageable_mob: AgeableMobEntityData::new(),
11733 state: SyncedValue::new(SnifferState::Idling),
11734 drop_seed_at_tick: SyncedValue::new(0i32),
11735 }
11736 }
11737 #[doc = "Returns the `SnifferEntityData` layer."]
11738 pub fn sniffer(&self) -> &SnifferEntityData {
11739 self
11740 }
11741 #[doc = "Returns the mutable `SnifferEntityData` layer."]
11742 pub fn sniffer_mut(&mut self) -> &mut SnifferEntityData {
11743 self
11744 }
11745 #[doc = "Returns the `AgeableMobEntityData` layer."]
11746 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
11747 &self.ageable_mob
11748 }
11749 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
11750 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
11751 &mut self.ageable_mob
11752 }
11753 #[doc = "Returns the `MobEntityData` layer."]
11754 pub fn mob(&self) -> &MobEntityData {
11755 &self.ageable_mob.mob
11756 }
11757 #[doc = "Returns the mutable `MobEntityData` layer."]
11758 pub fn mob_mut(&mut self) -> &mut MobEntityData {
11759 &mut self.ageable_mob.mob
11760 }
11761 #[doc = "Returns the `LivingEntityData` layer."]
11762 pub fn living_entity(&self) -> &LivingEntityData {
11763 &self.ageable_mob.mob.living_entity
11764 }
11765 #[doc = "Returns the mutable `LivingEntityData` layer."]
11766 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11767 &mut self.ageable_mob.mob.living_entity
11768 }
11769 #[doc = "Returns the `BaseEntityData` layer."]
11770 pub fn base(&self) -> &BaseEntityData {
11771 &self.ageable_mob.mob.living_entity.base
11772 }
11773 #[doc = "Returns the mutable `BaseEntityData` layer."]
11774 pub fn base_mut(&mut self) -> &mut BaseEntityData {
11775 &mut self.ageable_mob.mob.living_entity.base
11776 }
11777 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
11778 #[doc = r" Returns `None` if no values are dirty."]
11779 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11780 let mut values = Vec::new();
11781 self.pack_dirty_into(&mut values);
11782 if values.is_empty() {
11783 None
11784 } else {
11785 Some(values)
11786 }
11787 }
11788 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
11789 self.ageable_mob.pack_dirty_into(values);
11790 if self.state.is_dirty() {
11791 values.push(DataValue {
11792 index: 18u8,
11793 serializer_id: 35i32,
11794 value: EntityData::SnifferState(*self.state.get()),
11795 });
11796 self.state.clear_dirty();
11797 }
11798 if self.drop_seed_at_tick.is_dirty() {
11799 values.push(DataValue {
11800 index: 19u8,
11801 serializer_id: 1i32,
11802 value: EntityData::Int(*self.drop_seed_at_tick.get()),
11803 });
11804 self.drop_seed_at_tick.clear_dirty();
11805 }
11806 }
11807 #[doc = r" Pack all non-default values (for initial entity spawn)."]
11808 pub fn pack_all(&self) -> Vec<DataValue> {
11809 let mut values = Vec::new();
11810 self.pack_all_into(&mut values);
11811 values
11812 }
11813 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
11814 self.ageable_mob.pack_all_into(values);
11815 if !self.state.is_default() {
11816 values.push(DataValue {
11817 index: 18u8,
11818 serializer_id: 35i32,
11819 value: EntityData::SnifferState(*self.state.get()),
11820 });
11821 }
11822 if !self.drop_seed_at_tick.is_default() {
11823 values.push(DataValue {
11824 index: 19u8,
11825 serializer_id: 1i32,
11826 value: EntityData::Int(*self.drop_seed_at_tick.get()),
11827 });
11828 }
11829 }
11830 #[doc = r" Returns `true` if any field has been modified."]
11831 pub fn is_dirty(&self) -> bool {
11832 self.ageable_mob.is_dirty() || self.state.is_dirty() || self.drop_seed_at_tick.is_dirty()
11833 }
11834}
11835impl Default for SnifferEntityData {
11836 fn default() -> Self {
11837 Self::new()
11838 }
11839}
11840impl VanillaEntityData for SnifferEntityData {
11841 fn base(&self) -> &BaseEntityData {
11842 SnifferEntityData::base(self)
11843 }
11844 fn base_mut(&mut self) -> &mut BaseEntityData {
11845 SnifferEntityData::base_mut(self)
11846 }
11847 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11848 SnifferEntityData::pack_dirty(self)
11849 }
11850 fn pack_all(&self) -> Vec<DataValue> {
11851 SnifferEntityData::pack_all(self)
11852 }
11853 fn is_dirty(&self) -> bool {
11854 SnifferEntityData::is_dirty(self)
11855 }
11856}
11857impl VanillaLivingEntityData for SnifferEntityData {
11858 fn living_entity(&self) -> &LivingEntityData {
11859 SnifferEntityData::living_entity(self)
11860 }
11861 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11862 SnifferEntityData::living_entity_mut(self)
11863 }
11864}
11865#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
11866#[derive(Debug, Clone)]
11867pub struct SnowGolemEntityData {
11868 pub mob: MobEntityData,
11869 pub pumpkin: SyncedValue<i8>,
11870}
11871impl SnowGolemEntityData {
11872 #[doc = r" Create new entity data with default values."]
11873 pub fn new() -> Self {
11874 Self {
11875 mob: MobEntityData::new(),
11876 pumpkin: SyncedValue::new(16i8),
11877 }
11878 }
11879 #[doc = "Returns the `SnowGolemEntityData` layer."]
11880 pub fn snow_golem(&self) -> &SnowGolemEntityData {
11881 self
11882 }
11883 #[doc = "Returns the mutable `SnowGolemEntityData` layer."]
11884 pub fn snow_golem_mut(&mut self) -> &mut SnowGolemEntityData {
11885 self
11886 }
11887 #[doc = "Returns the `MobEntityData` layer."]
11888 pub fn mob(&self) -> &MobEntityData {
11889 &self.mob
11890 }
11891 #[doc = "Returns the mutable `MobEntityData` layer."]
11892 pub fn mob_mut(&mut self) -> &mut MobEntityData {
11893 &mut self.mob
11894 }
11895 #[doc = "Returns the `LivingEntityData` layer."]
11896 pub fn living_entity(&self) -> &LivingEntityData {
11897 &self.mob.living_entity
11898 }
11899 #[doc = "Returns the mutable `LivingEntityData` layer."]
11900 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11901 &mut self.mob.living_entity
11902 }
11903 #[doc = "Returns the `BaseEntityData` layer."]
11904 pub fn base(&self) -> &BaseEntityData {
11905 &self.mob.living_entity.base
11906 }
11907 #[doc = "Returns the mutable `BaseEntityData` layer."]
11908 pub fn base_mut(&mut self) -> &mut BaseEntityData {
11909 &mut self.mob.living_entity.base
11910 }
11911 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
11912 #[doc = r" Returns `None` if no values are dirty."]
11913 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11914 let mut values = Vec::new();
11915 self.pack_dirty_into(&mut values);
11916 if values.is_empty() {
11917 None
11918 } else {
11919 Some(values)
11920 }
11921 }
11922 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
11923 self.mob.pack_dirty_into(values);
11924 if self.pumpkin.is_dirty() {
11925 values.push(DataValue {
11926 index: 16u8,
11927 serializer_id: 0i32,
11928 value: EntityData::Byte(*self.pumpkin.get()),
11929 });
11930 self.pumpkin.clear_dirty();
11931 }
11932 }
11933 #[doc = r" Pack all non-default values (for initial entity spawn)."]
11934 pub fn pack_all(&self) -> Vec<DataValue> {
11935 let mut values = Vec::new();
11936 self.pack_all_into(&mut values);
11937 values
11938 }
11939 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
11940 self.mob.pack_all_into(values);
11941 if !self.pumpkin.is_default() {
11942 values.push(DataValue {
11943 index: 16u8,
11944 serializer_id: 0i32,
11945 value: EntityData::Byte(*self.pumpkin.get()),
11946 });
11947 }
11948 }
11949 #[doc = r" Returns `true` if any field has been modified."]
11950 pub fn is_dirty(&self) -> bool {
11951 self.mob.is_dirty() || self.pumpkin.is_dirty()
11952 }
11953}
11954impl Default for SnowGolemEntityData {
11955 fn default() -> Self {
11956 Self::new()
11957 }
11958}
11959impl VanillaEntityData for SnowGolemEntityData {
11960 fn base(&self) -> &BaseEntityData {
11961 SnowGolemEntityData::base(self)
11962 }
11963 fn base_mut(&mut self) -> &mut BaseEntityData {
11964 SnowGolemEntityData::base_mut(self)
11965 }
11966 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
11967 SnowGolemEntityData::pack_dirty(self)
11968 }
11969 fn pack_all(&self) -> Vec<DataValue> {
11970 SnowGolemEntityData::pack_all(self)
11971 }
11972 fn is_dirty(&self) -> bool {
11973 SnowGolemEntityData::is_dirty(self)
11974 }
11975}
11976impl VanillaLivingEntityData for SnowGolemEntityData {
11977 fn living_entity(&self) -> &LivingEntityData {
11978 SnowGolemEntityData::living_entity(self)
11979 }
11980 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
11981 SnowGolemEntityData::living_entity_mut(self)
11982 }
11983}
11984#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
11985#[derive(Debug, Clone)]
11986pub struct StriderEntityData {
11987 pub ageable_mob: AgeableMobEntityData,
11988 pub boost_time: SyncedValue<i32>,
11989 pub suffocating: SyncedValue<bool>,
11990}
11991impl StriderEntityData {
11992 #[doc = r" Create new entity data with default values."]
11993 pub fn new() -> Self {
11994 Self {
11995 ageable_mob: AgeableMobEntityData::new(),
11996 boost_time: SyncedValue::new(0i32),
11997 suffocating: SyncedValue::new(false),
11998 }
11999 }
12000 #[doc = "Returns the `StriderEntityData` layer."]
12001 pub fn strider(&self) -> &StriderEntityData {
12002 self
12003 }
12004 #[doc = "Returns the mutable `StriderEntityData` layer."]
12005 pub fn strider_mut(&mut self) -> &mut StriderEntityData {
12006 self
12007 }
12008 #[doc = "Returns the `AgeableMobEntityData` layer."]
12009 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
12010 &self.ageable_mob
12011 }
12012 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
12013 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
12014 &mut self.ageable_mob
12015 }
12016 #[doc = "Returns the `MobEntityData` layer."]
12017 pub fn mob(&self) -> &MobEntityData {
12018 &self.ageable_mob.mob
12019 }
12020 #[doc = "Returns the mutable `MobEntityData` layer."]
12021 pub fn mob_mut(&mut self) -> &mut MobEntityData {
12022 &mut self.ageable_mob.mob
12023 }
12024 #[doc = "Returns the `LivingEntityData` layer."]
12025 pub fn living_entity(&self) -> &LivingEntityData {
12026 &self.ageable_mob.mob.living_entity
12027 }
12028 #[doc = "Returns the mutable `LivingEntityData` layer."]
12029 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
12030 &mut self.ageable_mob.mob.living_entity
12031 }
12032 #[doc = "Returns the `BaseEntityData` layer."]
12033 pub fn base(&self) -> &BaseEntityData {
12034 &self.ageable_mob.mob.living_entity.base
12035 }
12036 #[doc = "Returns the mutable `BaseEntityData` layer."]
12037 pub fn base_mut(&mut self) -> &mut BaseEntityData {
12038 &mut self.ageable_mob.mob.living_entity.base
12039 }
12040 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
12041 #[doc = r" Returns `None` if no values are dirty."]
12042 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12043 let mut values = Vec::new();
12044 self.pack_dirty_into(&mut values);
12045 if values.is_empty() {
12046 None
12047 } else {
12048 Some(values)
12049 }
12050 }
12051 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
12052 self.ageable_mob.pack_dirty_into(values);
12053 if self.boost_time.is_dirty() {
12054 values.push(DataValue {
12055 index: 18u8,
12056 serializer_id: 1i32,
12057 value: EntityData::Int(*self.boost_time.get()),
12058 });
12059 self.boost_time.clear_dirty();
12060 }
12061 if self.suffocating.is_dirty() {
12062 values.push(DataValue {
12063 index: 19u8,
12064 serializer_id: 8i32,
12065 value: EntityData::Boolean(*self.suffocating.get()),
12066 });
12067 self.suffocating.clear_dirty();
12068 }
12069 }
12070 #[doc = r" Pack all non-default values (for initial entity spawn)."]
12071 pub fn pack_all(&self) -> Vec<DataValue> {
12072 let mut values = Vec::new();
12073 self.pack_all_into(&mut values);
12074 values
12075 }
12076 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
12077 self.ageable_mob.pack_all_into(values);
12078 if !self.boost_time.is_default() {
12079 values.push(DataValue {
12080 index: 18u8,
12081 serializer_id: 1i32,
12082 value: EntityData::Int(*self.boost_time.get()),
12083 });
12084 }
12085 if !self.suffocating.is_default() {
12086 values.push(DataValue {
12087 index: 19u8,
12088 serializer_id: 8i32,
12089 value: EntityData::Boolean(*self.suffocating.get()),
12090 });
12091 }
12092 }
12093 #[doc = r" Returns `true` if any field has been modified."]
12094 pub fn is_dirty(&self) -> bool {
12095 self.ageable_mob.is_dirty() || self.boost_time.is_dirty() || self.suffocating.is_dirty()
12096 }
12097}
12098impl Default for StriderEntityData {
12099 fn default() -> Self {
12100 Self::new()
12101 }
12102}
12103impl VanillaEntityData for StriderEntityData {
12104 fn base(&self) -> &BaseEntityData {
12105 StriderEntityData::base(self)
12106 }
12107 fn base_mut(&mut self) -> &mut BaseEntityData {
12108 StriderEntityData::base_mut(self)
12109 }
12110 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12111 StriderEntityData::pack_dirty(self)
12112 }
12113 fn pack_all(&self) -> Vec<DataValue> {
12114 StriderEntityData::pack_all(self)
12115 }
12116 fn is_dirty(&self) -> bool {
12117 StriderEntityData::is_dirty(self)
12118 }
12119}
12120impl VanillaLivingEntityData for StriderEntityData {
12121 fn living_entity(&self) -> &LivingEntityData {
12122 StriderEntityData::living_entity(self)
12123 }
12124 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
12125 StriderEntityData::living_entity_mut(self)
12126 }
12127}
12128#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
12129#[derive(Debug, Clone)]
12130pub struct TadpoleEntityData {
12131 pub abstract_fish: AbstractFishEntityData,
12132 pub age_locked: SyncedValue<bool>,
12133}
12134impl TadpoleEntityData {
12135 #[doc = r" Create new entity data with default values."]
12136 pub fn new() -> Self {
12137 Self {
12138 abstract_fish: AbstractFishEntityData::new(),
12139 age_locked: SyncedValue::new(false),
12140 }
12141 }
12142 #[doc = "Returns the `TadpoleEntityData` layer."]
12143 pub fn tadpole(&self) -> &TadpoleEntityData {
12144 self
12145 }
12146 #[doc = "Returns the mutable `TadpoleEntityData` layer."]
12147 pub fn tadpole_mut(&mut self) -> &mut TadpoleEntityData {
12148 self
12149 }
12150 #[doc = "Returns the `AbstractFishEntityData` layer."]
12151 pub fn abstract_fish(&self) -> &AbstractFishEntityData {
12152 &self.abstract_fish
12153 }
12154 #[doc = "Returns the mutable `AbstractFishEntityData` layer."]
12155 pub fn abstract_fish_mut(&mut self) -> &mut AbstractFishEntityData {
12156 &mut self.abstract_fish
12157 }
12158 #[doc = "Returns the `MobEntityData` layer."]
12159 pub fn mob(&self) -> &MobEntityData {
12160 &self.abstract_fish.mob
12161 }
12162 #[doc = "Returns the mutable `MobEntityData` layer."]
12163 pub fn mob_mut(&mut self) -> &mut MobEntityData {
12164 &mut self.abstract_fish.mob
12165 }
12166 #[doc = "Returns the `LivingEntityData` layer."]
12167 pub fn living_entity(&self) -> &LivingEntityData {
12168 &self.abstract_fish.mob.living_entity
12169 }
12170 #[doc = "Returns the mutable `LivingEntityData` layer."]
12171 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
12172 &mut self.abstract_fish.mob.living_entity
12173 }
12174 #[doc = "Returns the `BaseEntityData` layer."]
12175 pub fn base(&self) -> &BaseEntityData {
12176 &self.abstract_fish.mob.living_entity.base
12177 }
12178 #[doc = "Returns the mutable `BaseEntityData` layer."]
12179 pub fn base_mut(&mut self) -> &mut BaseEntityData {
12180 &mut self.abstract_fish.mob.living_entity.base
12181 }
12182 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
12183 #[doc = r" Returns `None` if no values are dirty."]
12184 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12185 let mut values = Vec::new();
12186 self.pack_dirty_into(&mut values);
12187 if values.is_empty() {
12188 None
12189 } else {
12190 Some(values)
12191 }
12192 }
12193 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
12194 self.abstract_fish.pack_dirty_into(values);
12195 if self.age_locked.is_dirty() {
12196 values.push(DataValue {
12197 index: 17u8,
12198 serializer_id: 8i32,
12199 value: EntityData::Boolean(*self.age_locked.get()),
12200 });
12201 self.age_locked.clear_dirty();
12202 }
12203 }
12204 #[doc = r" Pack all non-default values (for initial entity spawn)."]
12205 pub fn pack_all(&self) -> Vec<DataValue> {
12206 let mut values = Vec::new();
12207 self.pack_all_into(&mut values);
12208 values
12209 }
12210 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
12211 self.abstract_fish.pack_all_into(values);
12212 if !self.age_locked.is_default() {
12213 values.push(DataValue {
12214 index: 17u8,
12215 serializer_id: 8i32,
12216 value: EntityData::Boolean(*self.age_locked.get()),
12217 });
12218 }
12219 }
12220 #[doc = r" Returns `true` if any field has been modified."]
12221 pub fn is_dirty(&self) -> bool {
12222 self.abstract_fish.is_dirty() || self.age_locked.is_dirty()
12223 }
12224}
12225impl Default for TadpoleEntityData {
12226 fn default() -> Self {
12227 Self::new()
12228 }
12229}
12230impl VanillaEntityData for TadpoleEntityData {
12231 fn base(&self) -> &BaseEntityData {
12232 TadpoleEntityData::base(self)
12233 }
12234 fn base_mut(&mut self) -> &mut BaseEntityData {
12235 TadpoleEntityData::base_mut(self)
12236 }
12237 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12238 TadpoleEntityData::pack_dirty(self)
12239 }
12240 fn pack_all(&self) -> Vec<DataValue> {
12241 TadpoleEntityData::pack_all(self)
12242 }
12243 fn is_dirty(&self) -> bool {
12244 TadpoleEntityData::is_dirty(self)
12245 }
12246}
12247impl VanillaLivingEntityData for TadpoleEntityData {
12248 fn living_entity(&self) -> &LivingEntityData {
12249 TadpoleEntityData::living_entity(self)
12250 }
12251 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
12252 TadpoleEntityData::living_entity_mut(self)
12253 }
12254}
12255#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
12256#[derive(Debug, Clone)]
12257pub struct TextDisplayEntityData {
12258 pub display: DisplayEntityData,
12259 pub text: SyncedValue<Box<TextComponent>>,
12260 pub line_width: SyncedValue<i32>,
12261 pub background_color: SyncedValue<i32>,
12262 pub text_opacity: SyncedValue<i8>,
12263 pub style_flags: SyncedValue<i8>,
12264}
12265impl TextDisplayEntityData {
12266 #[doc = r" Create new entity data with default values."]
12267 pub fn new() -> Self {
12268 Self {
12269 display: DisplayEntityData::new(),
12270 text: SyncedValue::new(Box::new(TextComponent::default())),
12271 line_width: SyncedValue::new(200i32),
12272 background_color: SyncedValue::new(1073741824i32),
12273 text_opacity: SyncedValue::new(-1i8),
12274 style_flags: SyncedValue::new(0i8),
12275 }
12276 }
12277 #[doc = "Returns the `TextDisplayEntityData` layer."]
12278 pub fn text_display(&self) -> &TextDisplayEntityData {
12279 self
12280 }
12281 #[doc = "Returns the mutable `TextDisplayEntityData` layer."]
12282 pub fn text_display_mut(&mut self) -> &mut TextDisplayEntityData {
12283 self
12284 }
12285 #[doc = "Returns the `DisplayEntityData` layer."]
12286 pub fn display(&self) -> &DisplayEntityData {
12287 &self.display
12288 }
12289 #[doc = "Returns the mutable `DisplayEntityData` layer."]
12290 pub fn display_mut(&mut self) -> &mut DisplayEntityData {
12291 &mut self.display
12292 }
12293 #[doc = "Returns the `BaseEntityData` layer."]
12294 pub fn base(&self) -> &BaseEntityData {
12295 &self.display.base
12296 }
12297 #[doc = "Returns the mutable `BaseEntityData` layer."]
12298 pub fn base_mut(&mut self) -> &mut BaseEntityData {
12299 &mut self.display.base
12300 }
12301 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
12302 #[doc = r" Returns `None` if no values are dirty."]
12303 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12304 let mut values = Vec::new();
12305 self.pack_dirty_into(&mut values);
12306 if values.is_empty() {
12307 None
12308 } else {
12309 Some(values)
12310 }
12311 }
12312 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
12313 self.display.pack_dirty_into(values);
12314 if self.text.is_dirty() {
12315 values.push(DataValue {
12316 index: 23u8,
12317 serializer_id: 5i32,
12318 value: EntityData::Component(self.text.get().clone()),
12319 });
12320 self.text.clear_dirty();
12321 }
12322 if self.line_width.is_dirty() {
12323 values.push(DataValue {
12324 index: 24u8,
12325 serializer_id: 1i32,
12326 value: EntityData::Int(*self.line_width.get()),
12327 });
12328 self.line_width.clear_dirty();
12329 }
12330 if self.background_color.is_dirty() {
12331 values.push(DataValue {
12332 index: 25u8,
12333 serializer_id: 1i32,
12334 value: EntityData::Int(*self.background_color.get()),
12335 });
12336 self.background_color.clear_dirty();
12337 }
12338 if self.text_opacity.is_dirty() {
12339 values.push(DataValue {
12340 index: 26u8,
12341 serializer_id: 0i32,
12342 value: EntityData::Byte(*self.text_opacity.get()),
12343 });
12344 self.text_opacity.clear_dirty();
12345 }
12346 if self.style_flags.is_dirty() {
12347 values.push(DataValue {
12348 index: 27u8,
12349 serializer_id: 0i32,
12350 value: EntityData::Byte(*self.style_flags.get()),
12351 });
12352 self.style_flags.clear_dirty();
12353 }
12354 }
12355 #[doc = r" Pack all non-default values (for initial entity spawn)."]
12356 pub fn pack_all(&self) -> Vec<DataValue> {
12357 let mut values = Vec::new();
12358 self.pack_all_into(&mut values);
12359 values
12360 }
12361 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
12362 self.display.pack_all_into(values);
12363 if !self.text.is_default() {
12364 values.push(DataValue {
12365 index: 23u8,
12366 serializer_id: 5i32,
12367 value: EntityData::Component(self.text.get().clone()),
12368 });
12369 }
12370 if !self.line_width.is_default() {
12371 values.push(DataValue {
12372 index: 24u8,
12373 serializer_id: 1i32,
12374 value: EntityData::Int(*self.line_width.get()),
12375 });
12376 }
12377 if !self.background_color.is_default() {
12378 values.push(DataValue {
12379 index: 25u8,
12380 serializer_id: 1i32,
12381 value: EntityData::Int(*self.background_color.get()),
12382 });
12383 }
12384 if !self.text_opacity.is_default() {
12385 values.push(DataValue {
12386 index: 26u8,
12387 serializer_id: 0i32,
12388 value: EntityData::Byte(*self.text_opacity.get()),
12389 });
12390 }
12391 if !self.style_flags.is_default() {
12392 values.push(DataValue {
12393 index: 27u8,
12394 serializer_id: 0i32,
12395 value: EntityData::Byte(*self.style_flags.get()),
12396 });
12397 }
12398 }
12399 #[doc = r" Returns `true` if any field has been modified."]
12400 pub fn is_dirty(&self) -> bool {
12401 self.display.is_dirty()
12402 || self.text.is_dirty()
12403 || self.line_width.is_dirty()
12404 || self.background_color.is_dirty()
12405 || self.text_opacity.is_dirty()
12406 || self.style_flags.is_dirty()
12407 }
12408}
12409impl Default for TextDisplayEntityData {
12410 fn default() -> Self {
12411 Self::new()
12412 }
12413}
12414impl VanillaEntityData for TextDisplayEntityData {
12415 fn base(&self) -> &BaseEntityData {
12416 TextDisplayEntityData::base(self)
12417 }
12418 fn base_mut(&mut self) -> &mut BaseEntityData {
12419 TextDisplayEntityData::base_mut(self)
12420 }
12421 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12422 TextDisplayEntityData::pack_dirty(self)
12423 }
12424 fn pack_all(&self) -> Vec<DataValue> {
12425 TextDisplayEntityData::pack_all(self)
12426 }
12427 fn is_dirty(&self) -> bool {
12428 TextDisplayEntityData::is_dirty(self)
12429 }
12430}
12431#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
12432#[derive(Debug, Clone)]
12433pub struct PrimedTntEntityData {
12434 pub base: BaseEntityData,
12435 pub fuse: SyncedValue<i32>,
12436 pub block_state: SyncedValue<BlockStateId>,
12437}
12438impl PrimedTntEntityData {
12439 #[doc = r" Create new entity data with default values."]
12440 pub fn new() -> Self {
12441 Self {
12442 base: BaseEntityData::new(),
12443 fuse: SyncedValue::new(80i32),
12444 block_state: SyncedValue::new(crate::vanilla_blocks::TNT.default_state()),
12445 }
12446 }
12447 #[doc = "Returns the `PrimedTntEntityData` layer."]
12448 pub fn primed_tnt(&self) -> &PrimedTntEntityData {
12449 self
12450 }
12451 #[doc = "Returns the mutable `PrimedTntEntityData` layer."]
12452 pub fn primed_tnt_mut(&mut self) -> &mut PrimedTntEntityData {
12453 self
12454 }
12455 #[doc = "Returns the `BaseEntityData` layer."]
12456 pub fn base(&self) -> &BaseEntityData {
12457 &self.base
12458 }
12459 #[doc = "Returns the mutable `BaseEntityData` layer."]
12460 pub fn base_mut(&mut self) -> &mut BaseEntityData {
12461 &mut self.base
12462 }
12463 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
12464 #[doc = r" Returns `None` if no values are dirty."]
12465 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12466 let mut values = Vec::new();
12467 self.pack_dirty_into(&mut values);
12468 if values.is_empty() {
12469 None
12470 } else {
12471 Some(values)
12472 }
12473 }
12474 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
12475 self.base.pack_dirty_into(values);
12476 if self.fuse.is_dirty() {
12477 values.push(DataValue {
12478 index: 8u8,
12479 serializer_id: 1i32,
12480 value: EntityData::Int(*self.fuse.get()),
12481 });
12482 self.fuse.clear_dirty();
12483 }
12484 if self.block_state.is_dirty() {
12485 values.push(DataValue {
12486 index: 9u8,
12487 serializer_id: 14i32,
12488 value: EntityData::BlockState(*self.block_state.get()),
12489 });
12490 self.block_state.clear_dirty();
12491 }
12492 }
12493 #[doc = r" Pack all non-default values (for initial entity spawn)."]
12494 pub fn pack_all(&self) -> Vec<DataValue> {
12495 let mut values = Vec::new();
12496 self.pack_all_into(&mut values);
12497 values
12498 }
12499 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
12500 self.base.pack_all_into(values);
12501 if !self.fuse.is_default() {
12502 values.push(DataValue {
12503 index: 8u8,
12504 serializer_id: 1i32,
12505 value: EntityData::Int(*self.fuse.get()),
12506 });
12507 }
12508 if !self.block_state.is_default() {
12509 values.push(DataValue {
12510 index: 9u8,
12511 serializer_id: 14i32,
12512 value: EntityData::BlockState(*self.block_state.get()),
12513 });
12514 }
12515 }
12516 #[doc = r" Returns `true` if any field has been modified."]
12517 pub fn is_dirty(&self) -> bool {
12518 self.base.is_dirty() || self.fuse.is_dirty() || self.block_state.is_dirty()
12519 }
12520}
12521impl Default for PrimedTntEntityData {
12522 fn default() -> Self {
12523 Self::new()
12524 }
12525}
12526impl VanillaEntityData for PrimedTntEntityData {
12527 fn base(&self) -> &BaseEntityData {
12528 PrimedTntEntityData::base(self)
12529 }
12530 fn base_mut(&mut self) -> &mut BaseEntityData {
12531 PrimedTntEntityData::base_mut(self)
12532 }
12533 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12534 PrimedTntEntityData::pack_dirty(self)
12535 }
12536 fn pack_all(&self) -> Vec<DataValue> {
12537 PrimedTntEntityData::pack_all(self)
12538 }
12539 fn is_dirty(&self) -> bool {
12540 PrimedTntEntityData::is_dirty(self)
12541 }
12542}
12543#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
12544#[derive(Debug, Clone)]
12545pub struct ThrownTridentEntityData {
12546 pub abstract_arrow: AbstractArrowEntityData,
12547 pub id_loyalty: SyncedValue<i8>,
12548 pub id_foil: SyncedValue<bool>,
12549}
12550impl ThrownTridentEntityData {
12551 #[doc = r" Create new entity data with default values."]
12552 pub fn new() -> Self {
12553 Self {
12554 abstract_arrow: AbstractArrowEntityData::new(),
12555 id_loyalty: SyncedValue::new(0i8),
12556 id_foil: SyncedValue::new(false),
12557 }
12558 }
12559 #[doc = "Returns the `ThrownTridentEntityData` layer."]
12560 pub fn thrown_trident(&self) -> &ThrownTridentEntityData {
12561 self
12562 }
12563 #[doc = "Returns the mutable `ThrownTridentEntityData` layer."]
12564 pub fn thrown_trident_mut(&mut self) -> &mut ThrownTridentEntityData {
12565 self
12566 }
12567 #[doc = "Returns the `AbstractArrowEntityData` layer."]
12568 pub fn abstract_arrow(&self) -> &AbstractArrowEntityData {
12569 &self.abstract_arrow
12570 }
12571 #[doc = "Returns the mutable `AbstractArrowEntityData` layer."]
12572 pub fn abstract_arrow_mut(&mut self) -> &mut AbstractArrowEntityData {
12573 &mut self.abstract_arrow
12574 }
12575 #[doc = "Returns the `BaseEntityData` layer."]
12576 pub fn base(&self) -> &BaseEntityData {
12577 &self.abstract_arrow.base
12578 }
12579 #[doc = "Returns the mutable `BaseEntityData` layer."]
12580 pub fn base_mut(&mut self) -> &mut BaseEntityData {
12581 &mut self.abstract_arrow.base
12582 }
12583 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
12584 #[doc = r" Returns `None` if no values are dirty."]
12585 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12586 let mut values = Vec::new();
12587 self.pack_dirty_into(&mut values);
12588 if values.is_empty() {
12589 None
12590 } else {
12591 Some(values)
12592 }
12593 }
12594 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
12595 self.abstract_arrow.pack_dirty_into(values);
12596 if self.id_loyalty.is_dirty() {
12597 values.push(DataValue {
12598 index: 11u8,
12599 serializer_id: 0i32,
12600 value: EntityData::Byte(*self.id_loyalty.get()),
12601 });
12602 self.id_loyalty.clear_dirty();
12603 }
12604 if self.id_foil.is_dirty() {
12605 values.push(DataValue {
12606 index: 12u8,
12607 serializer_id: 8i32,
12608 value: EntityData::Boolean(*self.id_foil.get()),
12609 });
12610 self.id_foil.clear_dirty();
12611 }
12612 }
12613 #[doc = r" Pack all non-default values (for initial entity spawn)."]
12614 pub fn pack_all(&self) -> Vec<DataValue> {
12615 let mut values = Vec::new();
12616 self.pack_all_into(&mut values);
12617 values
12618 }
12619 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
12620 self.abstract_arrow.pack_all_into(values);
12621 if !self.id_loyalty.is_default() {
12622 values.push(DataValue {
12623 index: 11u8,
12624 serializer_id: 0i32,
12625 value: EntityData::Byte(*self.id_loyalty.get()),
12626 });
12627 }
12628 if !self.id_foil.is_default() {
12629 values.push(DataValue {
12630 index: 12u8,
12631 serializer_id: 8i32,
12632 value: EntityData::Boolean(*self.id_foil.get()),
12633 });
12634 }
12635 }
12636 #[doc = r" Returns `true` if any field has been modified."]
12637 pub fn is_dirty(&self) -> bool {
12638 self.abstract_arrow.is_dirty() || self.id_loyalty.is_dirty() || self.id_foil.is_dirty()
12639 }
12640}
12641impl Default for ThrownTridentEntityData {
12642 fn default() -> Self {
12643 Self::new()
12644 }
12645}
12646impl VanillaEntityData for ThrownTridentEntityData {
12647 fn base(&self) -> &BaseEntityData {
12648 ThrownTridentEntityData::base(self)
12649 }
12650 fn base_mut(&mut self) -> &mut BaseEntityData {
12651 ThrownTridentEntityData::base_mut(self)
12652 }
12653 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12654 ThrownTridentEntityData::pack_dirty(self)
12655 }
12656 fn pack_all(&self) -> Vec<DataValue> {
12657 ThrownTridentEntityData::pack_all(self)
12658 }
12659 fn is_dirty(&self) -> bool {
12660 ThrownTridentEntityData::is_dirty(self)
12661 }
12662}
12663#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
12664#[derive(Debug, Clone)]
12665pub struct TropicalFishEntityData {
12666 pub abstract_fish: AbstractFishEntityData,
12667 pub id_type_variant: SyncedValue<i32>,
12668}
12669impl TropicalFishEntityData {
12670 #[doc = r" Create new entity data with default values."]
12671 pub fn new() -> Self {
12672 Self {
12673 abstract_fish: AbstractFishEntityData::new(),
12674 id_type_variant: SyncedValue::new(0i32),
12675 }
12676 }
12677 #[doc = "Returns the `TropicalFishEntityData` layer."]
12678 pub fn tropical_fish(&self) -> &TropicalFishEntityData {
12679 self
12680 }
12681 #[doc = "Returns the mutable `TropicalFishEntityData` layer."]
12682 pub fn tropical_fish_mut(&mut self) -> &mut TropicalFishEntityData {
12683 self
12684 }
12685 #[doc = "Returns the `AbstractFishEntityData` layer."]
12686 pub fn abstract_fish(&self) -> &AbstractFishEntityData {
12687 &self.abstract_fish
12688 }
12689 #[doc = "Returns the mutable `AbstractFishEntityData` layer."]
12690 pub fn abstract_fish_mut(&mut self) -> &mut AbstractFishEntityData {
12691 &mut self.abstract_fish
12692 }
12693 #[doc = "Returns the `MobEntityData` layer."]
12694 pub fn mob(&self) -> &MobEntityData {
12695 &self.abstract_fish.mob
12696 }
12697 #[doc = "Returns the mutable `MobEntityData` layer."]
12698 pub fn mob_mut(&mut self) -> &mut MobEntityData {
12699 &mut self.abstract_fish.mob
12700 }
12701 #[doc = "Returns the `LivingEntityData` layer."]
12702 pub fn living_entity(&self) -> &LivingEntityData {
12703 &self.abstract_fish.mob.living_entity
12704 }
12705 #[doc = "Returns the mutable `LivingEntityData` layer."]
12706 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
12707 &mut self.abstract_fish.mob.living_entity
12708 }
12709 #[doc = "Returns the `BaseEntityData` layer."]
12710 pub fn base(&self) -> &BaseEntityData {
12711 &self.abstract_fish.mob.living_entity.base
12712 }
12713 #[doc = "Returns the mutable `BaseEntityData` layer."]
12714 pub fn base_mut(&mut self) -> &mut BaseEntityData {
12715 &mut self.abstract_fish.mob.living_entity.base
12716 }
12717 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
12718 #[doc = r" Returns `None` if no values are dirty."]
12719 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12720 let mut values = Vec::new();
12721 self.pack_dirty_into(&mut values);
12722 if values.is_empty() {
12723 None
12724 } else {
12725 Some(values)
12726 }
12727 }
12728 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
12729 self.abstract_fish.pack_dirty_into(values);
12730 if self.id_type_variant.is_dirty() {
12731 values.push(DataValue {
12732 index: 17u8,
12733 serializer_id: 1i32,
12734 value: EntityData::Int(*self.id_type_variant.get()),
12735 });
12736 self.id_type_variant.clear_dirty();
12737 }
12738 }
12739 #[doc = r" Pack all non-default values (for initial entity spawn)."]
12740 pub fn pack_all(&self) -> Vec<DataValue> {
12741 let mut values = Vec::new();
12742 self.pack_all_into(&mut values);
12743 values
12744 }
12745 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
12746 self.abstract_fish.pack_all_into(values);
12747 if !self.id_type_variant.is_default() {
12748 values.push(DataValue {
12749 index: 17u8,
12750 serializer_id: 1i32,
12751 value: EntityData::Int(*self.id_type_variant.get()),
12752 });
12753 }
12754 }
12755 #[doc = r" Returns `true` if any field has been modified."]
12756 pub fn is_dirty(&self) -> bool {
12757 self.abstract_fish.is_dirty() || self.id_type_variant.is_dirty()
12758 }
12759}
12760impl Default for TropicalFishEntityData {
12761 fn default() -> Self {
12762 Self::new()
12763 }
12764}
12765impl VanillaEntityData for TropicalFishEntityData {
12766 fn base(&self) -> &BaseEntityData {
12767 TropicalFishEntityData::base(self)
12768 }
12769 fn base_mut(&mut self) -> &mut BaseEntityData {
12770 TropicalFishEntityData::base_mut(self)
12771 }
12772 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12773 TropicalFishEntityData::pack_dirty(self)
12774 }
12775 fn pack_all(&self) -> Vec<DataValue> {
12776 TropicalFishEntityData::pack_all(self)
12777 }
12778 fn is_dirty(&self) -> bool {
12779 TropicalFishEntityData::is_dirty(self)
12780 }
12781}
12782impl VanillaLivingEntityData for TropicalFishEntityData {
12783 fn living_entity(&self) -> &LivingEntityData {
12784 TropicalFishEntityData::living_entity(self)
12785 }
12786 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
12787 TropicalFishEntityData::living_entity_mut(self)
12788 }
12789}
12790#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
12791#[derive(Debug, Clone)]
12792pub struct TurtleEntityData {
12793 pub ageable_mob: AgeableMobEntityData,
12794 pub has_egg: SyncedValue<bool>,
12795 pub laying_egg: SyncedValue<bool>,
12796}
12797impl TurtleEntityData {
12798 #[doc = r" Create new entity data with default values."]
12799 pub fn new() -> Self {
12800 Self {
12801 ageable_mob: AgeableMobEntityData::new(),
12802 has_egg: SyncedValue::new(false),
12803 laying_egg: SyncedValue::new(false),
12804 }
12805 }
12806 #[doc = "Returns the `TurtleEntityData` layer."]
12807 pub fn turtle(&self) -> &TurtleEntityData {
12808 self
12809 }
12810 #[doc = "Returns the mutable `TurtleEntityData` layer."]
12811 pub fn turtle_mut(&mut self) -> &mut TurtleEntityData {
12812 self
12813 }
12814 #[doc = "Returns the `AgeableMobEntityData` layer."]
12815 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
12816 &self.ageable_mob
12817 }
12818 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
12819 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
12820 &mut self.ageable_mob
12821 }
12822 #[doc = "Returns the `MobEntityData` layer."]
12823 pub fn mob(&self) -> &MobEntityData {
12824 &self.ageable_mob.mob
12825 }
12826 #[doc = "Returns the mutable `MobEntityData` layer."]
12827 pub fn mob_mut(&mut self) -> &mut MobEntityData {
12828 &mut self.ageable_mob.mob
12829 }
12830 #[doc = "Returns the `LivingEntityData` layer."]
12831 pub fn living_entity(&self) -> &LivingEntityData {
12832 &self.ageable_mob.mob.living_entity
12833 }
12834 #[doc = "Returns the mutable `LivingEntityData` layer."]
12835 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
12836 &mut self.ageable_mob.mob.living_entity
12837 }
12838 #[doc = "Returns the `BaseEntityData` layer."]
12839 pub fn base(&self) -> &BaseEntityData {
12840 &self.ageable_mob.mob.living_entity.base
12841 }
12842 #[doc = "Returns the mutable `BaseEntityData` layer."]
12843 pub fn base_mut(&mut self) -> &mut BaseEntityData {
12844 &mut self.ageable_mob.mob.living_entity.base
12845 }
12846 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
12847 #[doc = r" Returns `None` if no values are dirty."]
12848 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12849 let mut values = Vec::new();
12850 self.pack_dirty_into(&mut values);
12851 if values.is_empty() {
12852 None
12853 } else {
12854 Some(values)
12855 }
12856 }
12857 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
12858 self.ageable_mob.pack_dirty_into(values);
12859 if self.has_egg.is_dirty() {
12860 values.push(DataValue {
12861 index: 18u8,
12862 serializer_id: 8i32,
12863 value: EntityData::Boolean(*self.has_egg.get()),
12864 });
12865 self.has_egg.clear_dirty();
12866 }
12867 if self.laying_egg.is_dirty() {
12868 values.push(DataValue {
12869 index: 19u8,
12870 serializer_id: 8i32,
12871 value: EntityData::Boolean(*self.laying_egg.get()),
12872 });
12873 self.laying_egg.clear_dirty();
12874 }
12875 }
12876 #[doc = r" Pack all non-default values (for initial entity spawn)."]
12877 pub fn pack_all(&self) -> Vec<DataValue> {
12878 let mut values = Vec::new();
12879 self.pack_all_into(&mut values);
12880 values
12881 }
12882 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
12883 self.ageable_mob.pack_all_into(values);
12884 if !self.has_egg.is_default() {
12885 values.push(DataValue {
12886 index: 18u8,
12887 serializer_id: 8i32,
12888 value: EntityData::Boolean(*self.has_egg.get()),
12889 });
12890 }
12891 if !self.laying_egg.is_default() {
12892 values.push(DataValue {
12893 index: 19u8,
12894 serializer_id: 8i32,
12895 value: EntityData::Boolean(*self.laying_egg.get()),
12896 });
12897 }
12898 }
12899 #[doc = r" Returns `true` if any field has been modified."]
12900 pub fn is_dirty(&self) -> bool {
12901 self.ageable_mob.is_dirty() || self.has_egg.is_dirty() || self.laying_egg.is_dirty()
12902 }
12903}
12904impl Default for TurtleEntityData {
12905 fn default() -> Self {
12906 Self::new()
12907 }
12908}
12909impl VanillaEntityData for TurtleEntityData {
12910 fn base(&self) -> &BaseEntityData {
12911 TurtleEntityData::base(self)
12912 }
12913 fn base_mut(&mut self) -> &mut BaseEntityData {
12914 TurtleEntityData::base_mut(self)
12915 }
12916 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12917 TurtleEntityData::pack_dirty(self)
12918 }
12919 fn pack_all(&self) -> Vec<DataValue> {
12920 TurtleEntityData::pack_all(self)
12921 }
12922 fn is_dirty(&self) -> bool {
12923 TurtleEntityData::is_dirty(self)
12924 }
12925}
12926impl VanillaLivingEntityData for TurtleEntityData {
12927 fn living_entity(&self) -> &LivingEntityData {
12928 TurtleEntityData::living_entity(self)
12929 }
12930 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
12931 TurtleEntityData::living_entity_mut(self)
12932 }
12933}
12934#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
12935#[derive(Debug, Clone)]
12936pub struct VexEntityData {
12937 pub mob: MobEntityData,
12938 pub flags: SyncedValue<i8>,
12939}
12940impl VexEntityData {
12941 #[doc = r" Create new entity data with default values."]
12942 pub fn new() -> Self {
12943 Self {
12944 mob: MobEntityData::new(),
12945 flags: SyncedValue::new(0i8),
12946 }
12947 }
12948 #[doc = "Returns the `VexEntityData` layer."]
12949 pub fn vex(&self) -> &VexEntityData {
12950 self
12951 }
12952 #[doc = "Returns the mutable `VexEntityData` layer."]
12953 pub fn vex_mut(&mut self) -> &mut VexEntityData {
12954 self
12955 }
12956 #[doc = "Returns the `MobEntityData` layer."]
12957 pub fn mob(&self) -> &MobEntityData {
12958 &self.mob
12959 }
12960 #[doc = "Returns the mutable `MobEntityData` layer."]
12961 pub fn mob_mut(&mut self) -> &mut MobEntityData {
12962 &mut self.mob
12963 }
12964 #[doc = "Returns the `LivingEntityData` layer."]
12965 pub fn living_entity(&self) -> &LivingEntityData {
12966 &self.mob.living_entity
12967 }
12968 #[doc = "Returns the mutable `LivingEntityData` layer."]
12969 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
12970 &mut self.mob.living_entity
12971 }
12972 #[doc = "Returns the `BaseEntityData` layer."]
12973 pub fn base(&self) -> &BaseEntityData {
12974 &self.mob.living_entity.base
12975 }
12976 #[doc = "Returns the mutable `BaseEntityData` layer."]
12977 pub fn base_mut(&mut self) -> &mut BaseEntityData {
12978 &mut self.mob.living_entity.base
12979 }
12980 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
12981 #[doc = r" Returns `None` if no values are dirty."]
12982 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
12983 let mut values = Vec::new();
12984 self.pack_dirty_into(&mut values);
12985 if values.is_empty() {
12986 None
12987 } else {
12988 Some(values)
12989 }
12990 }
12991 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
12992 self.mob.pack_dirty_into(values);
12993 if self.flags.is_dirty() {
12994 values.push(DataValue {
12995 index: 16u8,
12996 serializer_id: 0i32,
12997 value: EntityData::Byte(*self.flags.get()),
12998 });
12999 self.flags.clear_dirty();
13000 }
13001 }
13002 #[doc = r" Pack all non-default values (for initial entity spawn)."]
13003 pub fn pack_all(&self) -> Vec<DataValue> {
13004 let mut values = Vec::new();
13005 self.pack_all_into(&mut values);
13006 values
13007 }
13008 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
13009 self.mob.pack_all_into(values);
13010 if !self.flags.is_default() {
13011 values.push(DataValue {
13012 index: 16u8,
13013 serializer_id: 0i32,
13014 value: EntityData::Byte(*self.flags.get()),
13015 });
13016 }
13017 }
13018 #[doc = r" Returns `true` if any field has been modified."]
13019 pub fn is_dirty(&self) -> bool {
13020 self.mob.is_dirty() || self.flags.is_dirty()
13021 }
13022}
13023impl Default for VexEntityData {
13024 fn default() -> Self {
13025 Self::new()
13026 }
13027}
13028impl VanillaEntityData for VexEntityData {
13029 fn base(&self) -> &BaseEntityData {
13030 VexEntityData::base(self)
13031 }
13032 fn base_mut(&mut self) -> &mut BaseEntityData {
13033 VexEntityData::base_mut(self)
13034 }
13035 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13036 VexEntityData::pack_dirty(self)
13037 }
13038 fn pack_all(&self) -> Vec<DataValue> {
13039 VexEntityData::pack_all(self)
13040 }
13041 fn is_dirty(&self) -> bool {
13042 VexEntityData::is_dirty(self)
13043 }
13044}
13045impl VanillaLivingEntityData for VexEntityData {
13046 fn living_entity(&self) -> &LivingEntityData {
13047 VexEntityData::living_entity(self)
13048 }
13049 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13050 VexEntityData::living_entity_mut(self)
13051 }
13052}
13053#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
13054#[derive(Debug, Clone)]
13055pub struct AbstractVillagerEntityData {
13056 pub ageable_mob: AgeableMobEntityData,
13057 pub unhappy_counter: SyncedValue<i32>,
13058}
13059impl AbstractVillagerEntityData {
13060 #[doc = r" Create new entity data with default values."]
13061 pub fn new() -> Self {
13062 Self {
13063 ageable_mob: AgeableMobEntityData::new(),
13064 unhappy_counter: SyncedValue::new(0i32),
13065 }
13066 }
13067 #[doc = "Returns the `AbstractVillagerEntityData` layer."]
13068 pub fn abstract_villager(&self) -> &AbstractVillagerEntityData {
13069 self
13070 }
13071 #[doc = "Returns the mutable `AbstractVillagerEntityData` layer."]
13072 pub fn abstract_villager_mut(&mut self) -> &mut AbstractVillagerEntityData {
13073 self
13074 }
13075 #[doc = "Returns the `AgeableMobEntityData` layer."]
13076 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
13077 &self.ageable_mob
13078 }
13079 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
13080 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
13081 &mut self.ageable_mob
13082 }
13083 #[doc = "Returns the `MobEntityData` layer."]
13084 pub fn mob(&self) -> &MobEntityData {
13085 &self.ageable_mob.mob
13086 }
13087 #[doc = "Returns the mutable `MobEntityData` layer."]
13088 pub fn mob_mut(&mut self) -> &mut MobEntityData {
13089 &mut self.ageable_mob.mob
13090 }
13091 #[doc = "Returns the `LivingEntityData` layer."]
13092 pub fn living_entity(&self) -> &LivingEntityData {
13093 &self.ageable_mob.mob.living_entity
13094 }
13095 #[doc = "Returns the mutable `LivingEntityData` layer."]
13096 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13097 &mut self.ageable_mob.mob.living_entity
13098 }
13099 #[doc = "Returns the `BaseEntityData` layer."]
13100 pub fn base(&self) -> &BaseEntityData {
13101 &self.ageable_mob.mob.living_entity.base
13102 }
13103 #[doc = "Returns the mutable `BaseEntityData` layer."]
13104 pub fn base_mut(&mut self) -> &mut BaseEntityData {
13105 &mut self.ageable_mob.mob.living_entity.base
13106 }
13107 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
13108 #[doc = r" Returns `None` if no values are dirty."]
13109 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13110 let mut values = Vec::new();
13111 self.pack_dirty_into(&mut values);
13112 if values.is_empty() {
13113 None
13114 } else {
13115 Some(values)
13116 }
13117 }
13118 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
13119 self.ageable_mob.pack_dirty_into(values);
13120 if self.unhappy_counter.is_dirty() {
13121 values.push(DataValue {
13122 index: 18u8,
13123 serializer_id: 1i32,
13124 value: EntityData::Int(*self.unhappy_counter.get()),
13125 });
13126 self.unhappy_counter.clear_dirty();
13127 }
13128 }
13129 #[doc = r" Pack all non-default values (for initial entity spawn)."]
13130 pub fn pack_all(&self) -> Vec<DataValue> {
13131 let mut values = Vec::new();
13132 self.pack_all_into(&mut values);
13133 values
13134 }
13135 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
13136 self.ageable_mob.pack_all_into(values);
13137 if !self.unhappy_counter.is_default() {
13138 values.push(DataValue {
13139 index: 18u8,
13140 serializer_id: 1i32,
13141 value: EntityData::Int(*self.unhappy_counter.get()),
13142 });
13143 }
13144 }
13145 #[doc = r" Returns `true` if any field has been modified."]
13146 pub fn is_dirty(&self) -> bool {
13147 self.ageable_mob.is_dirty() || self.unhappy_counter.is_dirty()
13148 }
13149}
13150impl Default for AbstractVillagerEntityData {
13151 fn default() -> Self {
13152 Self::new()
13153 }
13154}
13155impl VanillaEntityData for AbstractVillagerEntityData {
13156 fn base(&self) -> &BaseEntityData {
13157 AbstractVillagerEntityData::base(self)
13158 }
13159 fn base_mut(&mut self) -> &mut BaseEntityData {
13160 AbstractVillagerEntityData::base_mut(self)
13161 }
13162 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13163 AbstractVillagerEntityData::pack_dirty(self)
13164 }
13165 fn pack_all(&self) -> Vec<DataValue> {
13166 AbstractVillagerEntityData::pack_all(self)
13167 }
13168 fn is_dirty(&self) -> bool {
13169 AbstractVillagerEntityData::is_dirty(self)
13170 }
13171}
13172impl VanillaLivingEntityData for AbstractVillagerEntityData {
13173 fn living_entity(&self) -> &LivingEntityData {
13174 AbstractVillagerEntityData::living_entity(self)
13175 }
13176 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13177 AbstractVillagerEntityData::living_entity_mut(self)
13178 }
13179}
13180#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
13181#[derive(Debug, Clone)]
13182pub struct VillagerEntityData {
13183 pub abstract_villager: AbstractVillagerEntityData,
13184 pub villager_data: SyncedValue<VillagerData>,
13185 pub villager_data_finalized: SyncedValue<bool>,
13186}
13187impl VillagerEntityData {
13188 #[doc = r" Create new entity data with default values."]
13189 pub fn new() -> Self {
13190 Self {
13191 abstract_villager: AbstractVillagerEntityData::new(),
13192 villager_data: SyncedValue::new(VillagerData::new(2, 0, 1i32)),
13193 villager_data_finalized: SyncedValue::new(false),
13194 }
13195 }
13196 #[doc = "Returns the `VillagerEntityData` layer."]
13197 pub fn villager(&self) -> &VillagerEntityData {
13198 self
13199 }
13200 #[doc = "Returns the mutable `VillagerEntityData` layer."]
13201 pub fn villager_mut(&mut self) -> &mut VillagerEntityData {
13202 self
13203 }
13204 #[doc = "Returns the `AbstractVillagerEntityData` layer."]
13205 pub fn abstract_villager(&self) -> &AbstractVillagerEntityData {
13206 &self.abstract_villager
13207 }
13208 #[doc = "Returns the mutable `AbstractVillagerEntityData` layer."]
13209 pub fn abstract_villager_mut(&mut self) -> &mut AbstractVillagerEntityData {
13210 &mut self.abstract_villager
13211 }
13212 #[doc = "Returns the `AgeableMobEntityData` layer."]
13213 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
13214 &self.abstract_villager.ageable_mob
13215 }
13216 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
13217 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
13218 &mut self.abstract_villager.ageable_mob
13219 }
13220 #[doc = "Returns the `MobEntityData` layer."]
13221 pub fn mob(&self) -> &MobEntityData {
13222 &self.abstract_villager.ageable_mob.mob
13223 }
13224 #[doc = "Returns the mutable `MobEntityData` layer."]
13225 pub fn mob_mut(&mut self) -> &mut MobEntityData {
13226 &mut self.abstract_villager.ageable_mob.mob
13227 }
13228 #[doc = "Returns the `LivingEntityData` layer."]
13229 pub fn living_entity(&self) -> &LivingEntityData {
13230 &self.abstract_villager.ageable_mob.mob.living_entity
13231 }
13232 #[doc = "Returns the mutable `LivingEntityData` layer."]
13233 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13234 &mut self.abstract_villager.ageable_mob.mob.living_entity
13235 }
13236 #[doc = "Returns the `BaseEntityData` layer."]
13237 pub fn base(&self) -> &BaseEntityData {
13238 &self.abstract_villager.ageable_mob.mob.living_entity.base
13239 }
13240 #[doc = "Returns the mutable `BaseEntityData` layer."]
13241 pub fn base_mut(&mut self) -> &mut BaseEntityData {
13242 &mut self.abstract_villager.ageable_mob.mob.living_entity.base
13243 }
13244 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
13245 #[doc = r" Returns `None` if no values are dirty."]
13246 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13247 let mut values = Vec::new();
13248 self.pack_dirty_into(&mut values);
13249 if values.is_empty() {
13250 None
13251 } else {
13252 Some(values)
13253 }
13254 }
13255 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
13256 self.abstract_villager.pack_dirty_into(values);
13257 if self.villager_data.is_dirty() {
13258 values.push(DataValue {
13259 index: 19u8,
13260 serializer_id: 18i32,
13261 value: EntityData::VillagerData(self.villager_data.get().clone()),
13262 });
13263 self.villager_data.clear_dirty();
13264 }
13265 if self.villager_data_finalized.is_dirty() {
13266 values.push(DataValue {
13267 index: 20u8,
13268 serializer_id: 8i32,
13269 value: EntityData::Boolean(*self.villager_data_finalized.get()),
13270 });
13271 self.villager_data_finalized.clear_dirty();
13272 }
13273 }
13274 #[doc = r" Pack all non-default values (for initial entity spawn)."]
13275 pub fn pack_all(&self) -> Vec<DataValue> {
13276 let mut values = Vec::new();
13277 self.pack_all_into(&mut values);
13278 values
13279 }
13280 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
13281 self.abstract_villager.pack_all_into(values);
13282 if !self.villager_data.is_default() {
13283 values.push(DataValue {
13284 index: 19u8,
13285 serializer_id: 18i32,
13286 value: EntityData::VillagerData(self.villager_data.get().clone()),
13287 });
13288 }
13289 if !self.villager_data_finalized.is_default() {
13290 values.push(DataValue {
13291 index: 20u8,
13292 serializer_id: 8i32,
13293 value: EntityData::Boolean(*self.villager_data_finalized.get()),
13294 });
13295 }
13296 }
13297 #[doc = r" Returns `true` if any field has been modified."]
13298 pub fn is_dirty(&self) -> bool {
13299 self.abstract_villager.is_dirty()
13300 || self.villager_data.is_dirty()
13301 || self.villager_data_finalized.is_dirty()
13302 }
13303}
13304impl Default for VillagerEntityData {
13305 fn default() -> Self {
13306 Self::new()
13307 }
13308}
13309impl VanillaEntityData for VillagerEntityData {
13310 fn base(&self) -> &BaseEntityData {
13311 VillagerEntityData::base(self)
13312 }
13313 fn base_mut(&mut self) -> &mut BaseEntityData {
13314 VillagerEntityData::base_mut(self)
13315 }
13316 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13317 VillagerEntityData::pack_dirty(self)
13318 }
13319 fn pack_all(&self) -> Vec<DataValue> {
13320 VillagerEntityData::pack_all(self)
13321 }
13322 fn is_dirty(&self) -> bool {
13323 VillagerEntityData::is_dirty(self)
13324 }
13325}
13326impl VanillaLivingEntityData for VillagerEntityData {
13327 fn living_entity(&self) -> &LivingEntityData {
13328 VillagerEntityData::living_entity(self)
13329 }
13330 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13331 VillagerEntityData::living_entity_mut(self)
13332 }
13333}
13334#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
13335#[derive(Debug, Clone)]
13336pub struct WardenEntityData {
13337 pub mob: MobEntityData,
13338 pub client_anger_level: SyncedValue<i32>,
13339}
13340impl WardenEntityData {
13341 #[doc = r" Create new entity data with default values."]
13342 pub fn new() -> Self {
13343 Self {
13344 mob: MobEntityData::new(),
13345 client_anger_level: SyncedValue::new(0i32),
13346 }
13347 }
13348 #[doc = "Returns the `WardenEntityData` layer."]
13349 pub fn warden(&self) -> &WardenEntityData {
13350 self
13351 }
13352 #[doc = "Returns the mutable `WardenEntityData` layer."]
13353 pub fn warden_mut(&mut self) -> &mut WardenEntityData {
13354 self
13355 }
13356 #[doc = "Returns the `MobEntityData` layer."]
13357 pub fn mob(&self) -> &MobEntityData {
13358 &self.mob
13359 }
13360 #[doc = "Returns the mutable `MobEntityData` layer."]
13361 pub fn mob_mut(&mut self) -> &mut MobEntityData {
13362 &mut self.mob
13363 }
13364 #[doc = "Returns the `LivingEntityData` layer."]
13365 pub fn living_entity(&self) -> &LivingEntityData {
13366 &self.mob.living_entity
13367 }
13368 #[doc = "Returns the mutable `LivingEntityData` layer."]
13369 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13370 &mut self.mob.living_entity
13371 }
13372 #[doc = "Returns the `BaseEntityData` layer."]
13373 pub fn base(&self) -> &BaseEntityData {
13374 &self.mob.living_entity.base
13375 }
13376 #[doc = "Returns the mutable `BaseEntityData` layer."]
13377 pub fn base_mut(&mut self) -> &mut BaseEntityData {
13378 &mut self.mob.living_entity.base
13379 }
13380 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
13381 #[doc = r" Returns `None` if no values are dirty."]
13382 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13383 let mut values = Vec::new();
13384 self.pack_dirty_into(&mut values);
13385 if values.is_empty() {
13386 None
13387 } else {
13388 Some(values)
13389 }
13390 }
13391 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
13392 self.mob.pack_dirty_into(values);
13393 if self.client_anger_level.is_dirty() {
13394 values.push(DataValue {
13395 index: 16u8,
13396 serializer_id: 1i32,
13397 value: EntityData::Int(*self.client_anger_level.get()),
13398 });
13399 self.client_anger_level.clear_dirty();
13400 }
13401 }
13402 #[doc = r" Pack all non-default values (for initial entity spawn)."]
13403 pub fn pack_all(&self) -> Vec<DataValue> {
13404 let mut values = Vec::new();
13405 self.pack_all_into(&mut values);
13406 values
13407 }
13408 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
13409 self.mob.pack_all_into(values);
13410 if !self.client_anger_level.is_default() {
13411 values.push(DataValue {
13412 index: 16u8,
13413 serializer_id: 1i32,
13414 value: EntityData::Int(*self.client_anger_level.get()),
13415 });
13416 }
13417 }
13418 #[doc = r" Returns `true` if any field has been modified."]
13419 pub fn is_dirty(&self) -> bool {
13420 self.mob.is_dirty() || self.client_anger_level.is_dirty()
13421 }
13422}
13423impl Default for WardenEntityData {
13424 fn default() -> Self {
13425 Self::new()
13426 }
13427}
13428impl VanillaEntityData for WardenEntityData {
13429 fn base(&self) -> &BaseEntityData {
13430 WardenEntityData::base(self)
13431 }
13432 fn base_mut(&mut self) -> &mut BaseEntityData {
13433 WardenEntityData::base_mut(self)
13434 }
13435 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13436 WardenEntityData::pack_dirty(self)
13437 }
13438 fn pack_all(&self) -> Vec<DataValue> {
13439 WardenEntityData::pack_all(self)
13440 }
13441 fn is_dirty(&self) -> bool {
13442 WardenEntityData::is_dirty(self)
13443 }
13444}
13445impl VanillaLivingEntityData for WardenEntityData {
13446 fn living_entity(&self) -> &LivingEntityData {
13447 WardenEntityData::living_entity(self)
13448 }
13449 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13450 WardenEntityData::living_entity_mut(self)
13451 }
13452}
13453#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
13454#[derive(Debug, Clone)]
13455pub struct WitchEntityData {
13456 pub raider: RaiderEntityData,
13457 pub using_item: SyncedValue<bool>,
13458}
13459impl WitchEntityData {
13460 #[doc = r" Create new entity data with default values."]
13461 pub fn new() -> Self {
13462 Self {
13463 raider: RaiderEntityData::new(),
13464 using_item: SyncedValue::new(false),
13465 }
13466 }
13467 #[doc = "Returns the `WitchEntityData` layer."]
13468 pub fn witch(&self) -> &WitchEntityData {
13469 self
13470 }
13471 #[doc = "Returns the mutable `WitchEntityData` layer."]
13472 pub fn witch_mut(&mut self) -> &mut WitchEntityData {
13473 self
13474 }
13475 #[doc = "Returns the `RaiderEntityData` layer."]
13476 pub fn raider(&self) -> &RaiderEntityData {
13477 &self.raider
13478 }
13479 #[doc = "Returns the mutable `RaiderEntityData` layer."]
13480 pub fn raider_mut(&mut self) -> &mut RaiderEntityData {
13481 &mut self.raider
13482 }
13483 #[doc = "Returns the `MobEntityData` layer."]
13484 pub fn mob(&self) -> &MobEntityData {
13485 &self.raider.mob
13486 }
13487 #[doc = "Returns the mutable `MobEntityData` layer."]
13488 pub fn mob_mut(&mut self) -> &mut MobEntityData {
13489 &mut self.raider.mob
13490 }
13491 #[doc = "Returns the `LivingEntityData` layer."]
13492 pub fn living_entity(&self) -> &LivingEntityData {
13493 &self.raider.mob.living_entity
13494 }
13495 #[doc = "Returns the mutable `LivingEntityData` layer."]
13496 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13497 &mut self.raider.mob.living_entity
13498 }
13499 #[doc = "Returns the `BaseEntityData` layer."]
13500 pub fn base(&self) -> &BaseEntityData {
13501 &self.raider.mob.living_entity.base
13502 }
13503 #[doc = "Returns the mutable `BaseEntityData` layer."]
13504 pub fn base_mut(&mut self) -> &mut BaseEntityData {
13505 &mut self.raider.mob.living_entity.base
13506 }
13507 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
13508 #[doc = r" Returns `None` if no values are dirty."]
13509 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13510 let mut values = Vec::new();
13511 self.pack_dirty_into(&mut values);
13512 if values.is_empty() {
13513 None
13514 } else {
13515 Some(values)
13516 }
13517 }
13518 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
13519 self.raider.pack_dirty_into(values);
13520 if self.using_item.is_dirty() {
13521 values.push(DataValue {
13522 index: 17u8,
13523 serializer_id: 8i32,
13524 value: EntityData::Boolean(*self.using_item.get()),
13525 });
13526 self.using_item.clear_dirty();
13527 }
13528 }
13529 #[doc = r" Pack all non-default values (for initial entity spawn)."]
13530 pub fn pack_all(&self) -> Vec<DataValue> {
13531 let mut values = Vec::new();
13532 self.pack_all_into(&mut values);
13533 values
13534 }
13535 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
13536 self.raider.pack_all_into(values);
13537 if !self.using_item.is_default() {
13538 values.push(DataValue {
13539 index: 17u8,
13540 serializer_id: 8i32,
13541 value: EntityData::Boolean(*self.using_item.get()),
13542 });
13543 }
13544 }
13545 #[doc = r" Returns `true` if any field has been modified."]
13546 pub fn is_dirty(&self) -> bool {
13547 self.raider.is_dirty() || self.using_item.is_dirty()
13548 }
13549}
13550impl Default for WitchEntityData {
13551 fn default() -> Self {
13552 Self::new()
13553 }
13554}
13555impl VanillaEntityData for WitchEntityData {
13556 fn base(&self) -> &BaseEntityData {
13557 WitchEntityData::base(self)
13558 }
13559 fn base_mut(&mut self) -> &mut BaseEntityData {
13560 WitchEntityData::base_mut(self)
13561 }
13562 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13563 WitchEntityData::pack_dirty(self)
13564 }
13565 fn pack_all(&self) -> Vec<DataValue> {
13566 WitchEntityData::pack_all(self)
13567 }
13568 fn is_dirty(&self) -> bool {
13569 WitchEntityData::is_dirty(self)
13570 }
13571}
13572impl VanillaLivingEntityData for WitchEntityData {
13573 fn living_entity(&self) -> &LivingEntityData {
13574 WitchEntityData::living_entity(self)
13575 }
13576 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13577 WitchEntityData::living_entity_mut(self)
13578 }
13579}
13580#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
13581#[derive(Debug, Clone)]
13582pub struct WitherBossEntityData {
13583 pub mob: MobEntityData,
13584 pub target_a: SyncedValue<i32>,
13585 pub target_b: SyncedValue<i32>,
13586 pub target_c: SyncedValue<i32>,
13587 pub id_inv: SyncedValue<i32>,
13588}
13589impl WitherBossEntityData {
13590 #[doc = r" Create new entity data with default values."]
13591 pub fn new() -> Self {
13592 Self {
13593 mob: MobEntityData::new(),
13594 target_a: SyncedValue::new(0i32),
13595 target_b: SyncedValue::new(0i32),
13596 target_c: SyncedValue::new(0i32),
13597 id_inv: SyncedValue::new(0i32),
13598 }
13599 }
13600 #[doc = "Returns the `WitherBossEntityData` layer."]
13601 pub fn wither_boss(&self) -> &WitherBossEntityData {
13602 self
13603 }
13604 #[doc = "Returns the mutable `WitherBossEntityData` layer."]
13605 pub fn wither_boss_mut(&mut self) -> &mut WitherBossEntityData {
13606 self
13607 }
13608 #[doc = "Returns the `MobEntityData` layer."]
13609 pub fn mob(&self) -> &MobEntityData {
13610 &self.mob
13611 }
13612 #[doc = "Returns the mutable `MobEntityData` layer."]
13613 pub fn mob_mut(&mut self) -> &mut MobEntityData {
13614 &mut self.mob
13615 }
13616 #[doc = "Returns the `LivingEntityData` layer."]
13617 pub fn living_entity(&self) -> &LivingEntityData {
13618 &self.mob.living_entity
13619 }
13620 #[doc = "Returns the mutable `LivingEntityData` layer."]
13621 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13622 &mut self.mob.living_entity
13623 }
13624 #[doc = "Returns the `BaseEntityData` layer."]
13625 pub fn base(&self) -> &BaseEntityData {
13626 &self.mob.living_entity.base
13627 }
13628 #[doc = "Returns the mutable `BaseEntityData` layer."]
13629 pub fn base_mut(&mut self) -> &mut BaseEntityData {
13630 &mut self.mob.living_entity.base
13631 }
13632 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
13633 #[doc = r" Returns `None` if no values are dirty."]
13634 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13635 let mut values = Vec::new();
13636 self.pack_dirty_into(&mut values);
13637 if values.is_empty() {
13638 None
13639 } else {
13640 Some(values)
13641 }
13642 }
13643 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
13644 self.mob.pack_dirty_into(values);
13645 if self.target_a.is_dirty() {
13646 values.push(DataValue {
13647 index: 16u8,
13648 serializer_id: 1i32,
13649 value: EntityData::Int(*self.target_a.get()),
13650 });
13651 self.target_a.clear_dirty();
13652 }
13653 if self.target_b.is_dirty() {
13654 values.push(DataValue {
13655 index: 17u8,
13656 serializer_id: 1i32,
13657 value: EntityData::Int(*self.target_b.get()),
13658 });
13659 self.target_b.clear_dirty();
13660 }
13661 if self.target_c.is_dirty() {
13662 values.push(DataValue {
13663 index: 18u8,
13664 serializer_id: 1i32,
13665 value: EntityData::Int(*self.target_c.get()),
13666 });
13667 self.target_c.clear_dirty();
13668 }
13669 if self.id_inv.is_dirty() {
13670 values.push(DataValue {
13671 index: 19u8,
13672 serializer_id: 1i32,
13673 value: EntityData::Int(*self.id_inv.get()),
13674 });
13675 self.id_inv.clear_dirty();
13676 }
13677 }
13678 #[doc = r" Pack all non-default values (for initial entity spawn)."]
13679 pub fn pack_all(&self) -> Vec<DataValue> {
13680 let mut values = Vec::new();
13681 self.pack_all_into(&mut values);
13682 values
13683 }
13684 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
13685 self.mob.pack_all_into(values);
13686 if !self.target_a.is_default() {
13687 values.push(DataValue {
13688 index: 16u8,
13689 serializer_id: 1i32,
13690 value: EntityData::Int(*self.target_a.get()),
13691 });
13692 }
13693 if !self.target_b.is_default() {
13694 values.push(DataValue {
13695 index: 17u8,
13696 serializer_id: 1i32,
13697 value: EntityData::Int(*self.target_b.get()),
13698 });
13699 }
13700 if !self.target_c.is_default() {
13701 values.push(DataValue {
13702 index: 18u8,
13703 serializer_id: 1i32,
13704 value: EntityData::Int(*self.target_c.get()),
13705 });
13706 }
13707 if !self.id_inv.is_default() {
13708 values.push(DataValue {
13709 index: 19u8,
13710 serializer_id: 1i32,
13711 value: EntityData::Int(*self.id_inv.get()),
13712 });
13713 }
13714 }
13715 #[doc = r" Returns `true` if any field has been modified."]
13716 pub fn is_dirty(&self) -> bool {
13717 self.mob.is_dirty()
13718 || self.target_a.is_dirty()
13719 || self.target_b.is_dirty()
13720 || self.target_c.is_dirty()
13721 || self.id_inv.is_dirty()
13722 }
13723}
13724impl Default for WitherBossEntityData {
13725 fn default() -> Self {
13726 Self::new()
13727 }
13728}
13729impl VanillaEntityData for WitherBossEntityData {
13730 fn base(&self) -> &BaseEntityData {
13731 WitherBossEntityData::base(self)
13732 }
13733 fn base_mut(&mut self) -> &mut BaseEntityData {
13734 WitherBossEntityData::base_mut(self)
13735 }
13736 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13737 WitherBossEntityData::pack_dirty(self)
13738 }
13739 fn pack_all(&self) -> Vec<DataValue> {
13740 WitherBossEntityData::pack_all(self)
13741 }
13742 fn is_dirty(&self) -> bool {
13743 WitherBossEntityData::is_dirty(self)
13744 }
13745}
13746impl VanillaLivingEntityData for WitherBossEntityData {
13747 fn living_entity(&self) -> &LivingEntityData {
13748 WitherBossEntityData::living_entity(self)
13749 }
13750 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13751 WitherBossEntityData::living_entity_mut(self)
13752 }
13753}
13754#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
13755#[derive(Debug, Clone)]
13756pub struct WitherSkullEntityData {
13757 pub base: BaseEntityData,
13758 pub dangerous: SyncedValue<bool>,
13759}
13760impl WitherSkullEntityData {
13761 #[doc = r" Create new entity data with default values."]
13762 pub fn new() -> Self {
13763 Self {
13764 base: BaseEntityData::new(),
13765 dangerous: SyncedValue::new(false),
13766 }
13767 }
13768 #[doc = "Returns the `WitherSkullEntityData` layer."]
13769 pub fn wither_skull(&self) -> &WitherSkullEntityData {
13770 self
13771 }
13772 #[doc = "Returns the mutable `WitherSkullEntityData` layer."]
13773 pub fn wither_skull_mut(&mut self) -> &mut WitherSkullEntityData {
13774 self
13775 }
13776 #[doc = "Returns the `BaseEntityData` layer."]
13777 pub fn base(&self) -> &BaseEntityData {
13778 &self.base
13779 }
13780 #[doc = "Returns the mutable `BaseEntityData` layer."]
13781 pub fn base_mut(&mut self) -> &mut BaseEntityData {
13782 &mut self.base
13783 }
13784 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
13785 #[doc = r" Returns `None` if no values are dirty."]
13786 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13787 let mut values = Vec::new();
13788 self.pack_dirty_into(&mut values);
13789 if values.is_empty() {
13790 None
13791 } else {
13792 Some(values)
13793 }
13794 }
13795 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
13796 self.base.pack_dirty_into(values);
13797 if self.dangerous.is_dirty() {
13798 values.push(DataValue {
13799 index: 8u8,
13800 serializer_id: 8i32,
13801 value: EntityData::Boolean(*self.dangerous.get()),
13802 });
13803 self.dangerous.clear_dirty();
13804 }
13805 }
13806 #[doc = r" Pack all non-default values (for initial entity spawn)."]
13807 pub fn pack_all(&self) -> Vec<DataValue> {
13808 let mut values = Vec::new();
13809 self.pack_all_into(&mut values);
13810 values
13811 }
13812 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
13813 self.base.pack_all_into(values);
13814 if !self.dangerous.is_default() {
13815 values.push(DataValue {
13816 index: 8u8,
13817 serializer_id: 8i32,
13818 value: EntityData::Boolean(*self.dangerous.get()),
13819 });
13820 }
13821 }
13822 #[doc = r" Returns `true` if any field has been modified."]
13823 pub fn is_dirty(&self) -> bool {
13824 self.base.is_dirty() || self.dangerous.is_dirty()
13825 }
13826}
13827impl Default for WitherSkullEntityData {
13828 fn default() -> Self {
13829 Self::new()
13830 }
13831}
13832impl VanillaEntityData for WitherSkullEntityData {
13833 fn base(&self) -> &BaseEntityData {
13834 WitherSkullEntityData::base(self)
13835 }
13836 fn base_mut(&mut self) -> &mut BaseEntityData {
13837 WitherSkullEntityData::base_mut(self)
13838 }
13839 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13840 WitherSkullEntityData::pack_dirty(self)
13841 }
13842 fn pack_all(&self) -> Vec<DataValue> {
13843 WitherSkullEntityData::pack_all(self)
13844 }
13845 fn is_dirty(&self) -> bool {
13846 WitherSkullEntityData::is_dirty(self)
13847 }
13848}
13849#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
13850#[derive(Debug, Clone)]
13851pub struct WolfEntityData {
13852 pub tamable_animal: TamableAnimalEntityData,
13853 pub interested: SyncedValue<bool>,
13854 pub collar_color: SyncedValue<i32>,
13855 pub anger_end_time: SyncedValue<i64>,
13856 pub variant: SyncedValue<i32>,
13857 pub sound_variant: SyncedValue<i32>,
13858}
13859impl WolfEntityData {
13860 #[doc = r" Create new entity data with default values."]
13861 pub fn new() -> Self {
13862 Self {
13863 tamable_animal: TamableAnimalEntityData::new(),
13864 interested: SyncedValue::new(false),
13865 collar_color: SyncedValue::new(14i32),
13866 anger_end_time: SyncedValue::new(-1i64),
13867 variant: SyncedValue::new(0),
13868 sound_variant: SyncedValue::new(0),
13869 }
13870 }
13871 #[doc = "Returns the `WolfEntityData` layer."]
13872 pub fn wolf(&self) -> &WolfEntityData {
13873 self
13874 }
13875 #[doc = "Returns the mutable `WolfEntityData` layer."]
13876 pub fn wolf_mut(&mut self) -> &mut WolfEntityData {
13877 self
13878 }
13879 #[doc = "Returns the `TamableAnimalEntityData` layer."]
13880 pub fn tamable_animal(&self) -> &TamableAnimalEntityData {
13881 &self.tamable_animal
13882 }
13883 #[doc = "Returns the mutable `TamableAnimalEntityData` layer."]
13884 pub fn tamable_animal_mut(&mut self) -> &mut TamableAnimalEntityData {
13885 &mut self.tamable_animal
13886 }
13887 #[doc = "Returns the `AgeableMobEntityData` layer."]
13888 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
13889 &self.tamable_animal.ageable_mob
13890 }
13891 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
13892 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
13893 &mut self.tamable_animal.ageable_mob
13894 }
13895 #[doc = "Returns the `MobEntityData` layer."]
13896 pub fn mob(&self) -> &MobEntityData {
13897 &self.tamable_animal.ageable_mob.mob
13898 }
13899 #[doc = "Returns the mutable `MobEntityData` layer."]
13900 pub fn mob_mut(&mut self) -> &mut MobEntityData {
13901 &mut self.tamable_animal.ageable_mob.mob
13902 }
13903 #[doc = "Returns the `LivingEntityData` layer."]
13904 pub fn living_entity(&self) -> &LivingEntityData {
13905 &self.tamable_animal.ageable_mob.mob.living_entity
13906 }
13907 #[doc = "Returns the mutable `LivingEntityData` layer."]
13908 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
13909 &mut self.tamable_animal.ageable_mob.mob.living_entity
13910 }
13911 #[doc = "Returns the `BaseEntityData` layer."]
13912 pub fn base(&self) -> &BaseEntityData {
13913 &self.tamable_animal.ageable_mob.mob.living_entity.base
13914 }
13915 #[doc = "Returns the mutable `BaseEntityData` layer."]
13916 pub fn base_mut(&mut self) -> &mut BaseEntityData {
13917 &mut self.tamable_animal.ageable_mob.mob.living_entity.base
13918 }
13919 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
13920 #[doc = r" Returns `None` if no values are dirty."]
13921 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
13922 let mut values = Vec::new();
13923 self.pack_dirty_into(&mut values);
13924 if values.is_empty() {
13925 None
13926 } else {
13927 Some(values)
13928 }
13929 }
13930 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
13931 self.tamable_animal.pack_dirty_into(values);
13932 if self.interested.is_dirty() {
13933 values.push(DataValue {
13934 index: 20u8,
13935 serializer_id: 8i32,
13936 value: EntityData::Boolean(*self.interested.get()),
13937 });
13938 self.interested.clear_dirty();
13939 }
13940 if self.collar_color.is_dirty() {
13941 values.push(DataValue {
13942 index: 21u8,
13943 serializer_id: 1i32,
13944 value: EntityData::Int(*self.collar_color.get()),
13945 });
13946 self.collar_color.clear_dirty();
13947 }
13948 if self.anger_end_time.is_dirty() {
13949 values.push(DataValue {
13950 index: 22u8,
13951 serializer_id: 2i32,
13952 value: EntityData::Long(*self.anger_end_time.get()),
13953 });
13954 self.anger_end_time.clear_dirty();
13955 }
13956 if self.variant.is_dirty() {
13957 values.push(DataValue {
13958 index: 23u8,
13959 serializer_id: 25i32,
13960 value: EntityData::WolfVariant(*self.variant.get()),
13961 });
13962 self.variant.clear_dirty();
13963 }
13964 if self.sound_variant.is_dirty() {
13965 values.push(DataValue {
13966 index: 24u8,
13967 serializer_id: 26i32,
13968 value: EntityData::WolfSoundVariant(*self.sound_variant.get()),
13969 });
13970 self.sound_variant.clear_dirty();
13971 }
13972 }
13973 #[doc = r" Pack all non-default values (for initial entity spawn)."]
13974 pub fn pack_all(&self) -> Vec<DataValue> {
13975 let mut values = Vec::new();
13976 self.pack_all_into(&mut values);
13977 values
13978 }
13979 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
13980 self.tamable_animal.pack_all_into(values);
13981 if !self.interested.is_default() {
13982 values.push(DataValue {
13983 index: 20u8,
13984 serializer_id: 8i32,
13985 value: EntityData::Boolean(*self.interested.get()),
13986 });
13987 }
13988 if !self.collar_color.is_default() {
13989 values.push(DataValue {
13990 index: 21u8,
13991 serializer_id: 1i32,
13992 value: EntityData::Int(*self.collar_color.get()),
13993 });
13994 }
13995 if !self.anger_end_time.is_default() {
13996 values.push(DataValue {
13997 index: 22u8,
13998 serializer_id: 2i32,
13999 value: EntityData::Long(*self.anger_end_time.get()),
14000 });
14001 }
14002 if !self.variant.is_default() {
14003 values.push(DataValue {
14004 index: 23u8,
14005 serializer_id: 25i32,
14006 value: EntityData::WolfVariant(*self.variant.get()),
14007 });
14008 }
14009 if !self.sound_variant.is_default() {
14010 values.push(DataValue {
14011 index: 24u8,
14012 serializer_id: 26i32,
14013 value: EntityData::WolfSoundVariant(*self.sound_variant.get()),
14014 });
14015 }
14016 }
14017 #[doc = r" Returns `true` if any field has been modified."]
14018 pub fn is_dirty(&self) -> bool {
14019 self.tamable_animal.is_dirty()
14020 || self.interested.is_dirty()
14021 || self.collar_color.is_dirty()
14022 || self.anger_end_time.is_dirty()
14023 || self.variant.is_dirty()
14024 || self.sound_variant.is_dirty()
14025 }
14026}
14027impl Default for WolfEntityData {
14028 fn default() -> Self {
14029 Self::new()
14030 }
14031}
14032impl VanillaEntityData for WolfEntityData {
14033 fn base(&self) -> &BaseEntityData {
14034 WolfEntityData::base(self)
14035 }
14036 fn base_mut(&mut self) -> &mut BaseEntityData {
14037 WolfEntityData::base_mut(self)
14038 }
14039 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14040 WolfEntityData::pack_dirty(self)
14041 }
14042 fn pack_all(&self) -> Vec<DataValue> {
14043 WolfEntityData::pack_all(self)
14044 }
14045 fn is_dirty(&self) -> bool {
14046 WolfEntityData::is_dirty(self)
14047 }
14048}
14049impl VanillaLivingEntityData for WolfEntityData {
14050 fn living_entity(&self) -> &LivingEntityData {
14051 WolfEntityData::living_entity(self)
14052 }
14053 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
14054 WolfEntityData::living_entity_mut(self)
14055 }
14056}
14057#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
14058#[derive(Debug, Clone)]
14059pub struct ZoglinEntityData {
14060 pub mob: MobEntityData,
14061 pub baby: SyncedValue<bool>,
14062}
14063impl ZoglinEntityData {
14064 #[doc = r" Create new entity data with default values."]
14065 pub fn new() -> Self {
14066 Self {
14067 mob: MobEntityData::new(),
14068 baby: SyncedValue::new(false),
14069 }
14070 }
14071 #[doc = "Returns the `ZoglinEntityData` layer."]
14072 pub fn zoglin(&self) -> &ZoglinEntityData {
14073 self
14074 }
14075 #[doc = "Returns the mutable `ZoglinEntityData` layer."]
14076 pub fn zoglin_mut(&mut self) -> &mut ZoglinEntityData {
14077 self
14078 }
14079 #[doc = "Returns the `MobEntityData` layer."]
14080 pub fn mob(&self) -> &MobEntityData {
14081 &self.mob
14082 }
14083 #[doc = "Returns the mutable `MobEntityData` layer."]
14084 pub fn mob_mut(&mut self) -> &mut MobEntityData {
14085 &mut self.mob
14086 }
14087 #[doc = "Returns the `LivingEntityData` layer."]
14088 pub fn living_entity(&self) -> &LivingEntityData {
14089 &self.mob.living_entity
14090 }
14091 #[doc = "Returns the mutable `LivingEntityData` layer."]
14092 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
14093 &mut self.mob.living_entity
14094 }
14095 #[doc = "Returns the `BaseEntityData` layer."]
14096 pub fn base(&self) -> &BaseEntityData {
14097 &self.mob.living_entity.base
14098 }
14099 #[doc = "Returns the mutable `BaseEntityData` layer."]
14100 pub fn base_mut(&mut self) -> &mut BaseEntityData {
14101 &mut self.mob.living_entity.base
14102 }
14103 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
14104 #[doc = r" Returns `None` if no values are dirty."]
14105 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14106 let mut values = Vec::new();
14107 self.pack_dirty_into(&mut values);
14108 if values.is_empty() {
14109 None
14110 } else {
14111 Some(values)
14112 }
14113 }
14114 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
14115 self.mob.pack_dirty_into(values);
14116 if self.baby.is_dirty() {
14117 values.push(DataValue {
14118 index: 16u8,
14119 serializer_id: 8i32,
14120 value: EntityData::Boolean(*self.baby.get()),
14121 });
14122 self.baby.clear_dirty();
14123 }
14124 }
14125 #[doc = r" Pack all non-default values (for initial entity spawn)."]
14126 pub fn pack_all(&self) -> Vec<DataValue> {
14127 let mut values = Vec::new();
14128 self.pack_all_into(&mut values);
14129 values
14130 }
14131 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
14132 self.mob.pack_all_into(values);
14133 if !self.baby.is_default() {
14134 values.push(DataValue {
14135 index: 16u8,
14136 serializer_id: 8i32,
14137 value: EntityData::Boolean(*self.baby.get()),
14138 });
14139 }
14140 }
14141 #[doc = r" Returns `true` if any field has been modified."]
14142 pub fn is_dirty(&self) -> bool {
14143 self.mob.is_dirty() || self.baby.is_dirty()
14144 }
14145}
14146impl Default for ZoglinEntityData {
14147 fn default() -> Self {
14148 Self::new()
14149 }
14150}
14151impl VanillaEntityData for ZoglinEntityData {
14152 fn base(&self) -> &BaseEntityData {
14153 ZoglinEntityData::base(self)
14154 }
14155 fn base_mut(&mut self) -> &mut BaseEntityData {
14156 ZoglinEntityData::base_mut(self)
14157 }
14158 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14159 ZoglinEntityData::pack_dirty(self)
14160 }
14161 fn pack_all(&self) -> Vec<DataValue> {
14162 ZoglinEntityData::pack_all(self)
14163 }
14164 fn is_dirty(&self) -> bool {
14165 ZoglinEntityData::is_dirty(self)
14166 }
14167}
14168impl VanillaLivingEntityData for ZoglinEntityData {
14169 fn living_entity(&self) -> &LivingEntityData {
14170 ZoglinEntityData::living_entity(self)
14171 }
14172 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
14173 ZoglinEntityData::living_entity_mut(self)
14174 }
14175}
14176#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
14177#[derive(Debug, Clone)]
14178pub struct ZombieNautilusEntityData {
14179 pub abstract_nautilus: AbstractNautilusEntityData,
14180 pub variant: SyncedValue<i32>,
14181}
14182impl ZombieNautilusEntityData {
14183 #[doc = r" Create new entity data with default values."]
14184 pub fn new() -> Self {
14185 Self {
14186 abstract_nautilus: AbstractNautilusEntityData::new(),
14187 variant: SyncedValue::new(0),
14188 }
14189 }
14190 #[doc = "Returns the `ZombieNautilusEntityData` layer."]
14191 pub fn zombie_nautilus(&self) -> &ZombieNautilusEntityData {
14192 self
14193 }
14194 #[doc = "Returns the mutable `ZombieNautilusEntityData` layer."]
14195 pub fn zombie_nautilus_mut(&mut self) -> &mut ZombieNautilusEntityData {
14196 self
14197 }
14198 #[doc = "Returns the `AbstractNautilusEntityData` layer."]
14199 pub fn abstract_nautilus(&self) -> &AbstractNautilusEntityData {
14200 &self.abstract_nautilus
14201 }
14202 #[doc = "Returns the mutable `AbstractNautilusEntityData` layer."]
14203 pub fn abstract_nautilus_mut(&mut self) -> &mut AbstractNautilusEntityData {
14204 &mut self.abstract_nautilus
14205 }
14206 #[doc = "Returns the `TamableAnimalEntityData` layer."]
14207 pub fn tamable_animal(&self) -> &TamableAnimalEntityData {
14208 &self.abstract_nautilus.tamable_animal
14209 }
14210 #[doc = "Returns the mutable `TamableAnimalEntityData` layer."]
14211 pub fn tamable_animal_mut(&mut self) -> &mut TamableAnimalEntityData {
14212 &mut self.abstract_nautilus.tamable_animal
14213 }
14214 #[doc = "Returns the `AgeableMobEntityData` layer."]
14215 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
14216 &self.abstract_nautilus.tamable_animal.ageable_mob
14217 }
14218 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
14219 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
14220 &mut self.abstract_nautilus.tamable_animal.ageable_mob
14221 }
14222 #[doc = "Returns the `MobEntityData` layer."]
14223 pub fn mob(&self) -> &MobEntityData {
14224 &self.abstract_nautilus.tamable_animal.ageable_mob.mob
14225 }
14226 #[doc = "Returns the mutable `MobEntityData` layer."]
14227 pub fn mob_mut(&mut self) -> &mut MobEntityData {
14228 &mut self.abstract_nautilus.tamable_animal.ageable_mob.mob
14229 }
14230 #[doc = "Returns the `LivingEntityData` layer."]
14231 pub fn living_entity(&self) -> &LivingEntityData {
14232 &self
14233 .abstract_nautilus
14234 .tamable_animal
14235 .ageable_mob
14236 .mob
14237 .living_entity
14238 }
14239 #[doc = "Returns the mutable `LivingEntityData` layer."]
14240 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
14241 &mut self
14242 .abstract_nautilus
14243 .tamable_animal
14244 .ageable_mob
14245 .mob
14246 .living_entity
14247 }
14248 #[doc = "Returns the `BaseEntityData` layer."]
14249 pub fn base(&self) -> &BaseEntityData {
14250 &self
14251 .abstract_nautilus
14252 .tamable_animal
14253 .ageable_mob
14254 .mob
14255 .living_entity
14256 .base
14257 }
14258 #[doc = "Returns the mutable `BaseEntityData` layer."]
14259 pub fn base_mut(&mut self) -> &mut BaseEntityData {
14260 &mut self
14261 .abstract_nautilus
14262 .tamable_animal
14263 .ageable_mob
14264 .mob
14265 .living_entity
14266 .base
14267 }
14268 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
14269 #[doc = r" Returns `None` if no values are dirty."]
14270 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14271 let mut values = Vec::new();
14272 self.pack_dirty_into(&mut values);
14273 if values.is_empty() {
14274 None
14275 } else {
14276 Some(values)
14277 }
14278 }
14279 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
14280 self.abstract_nautilus.pack_dirty_into(values);
14281 if self.variant.is_dirty() {
14282 values.push(DataValue {
14283 index: 21u8,
14284 serializer_id: 32i32,
14285 value: EntityData::ZombieNautilusVariant(*self.variant.get()),
14286 });
14287 self.variant.clear_dirty();
14288 }
14289 }
14290 #[doc = r" Pack all non-default values (for initial entity spawn)."]
14291 pub fn pack_all(&self) -> Vec<DataValue> {
14292 let mut values = Vec::new();
14293 self.pack_all_into(&mut values);
14294 values
14295 }
14296 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
14297 self.abstract_nautilus.pack_all_into(values);
14298 if !self.variant.is_default() {
14299 values.push(DataValue {
14300 index: 21u8,
14301 serializer_id: 32i32,
14302 value: EntityData::ZombieNautilusVariant(*self.variant.get()),
14303 });
14304 }
14305 }
14306 #[doc = r" Returns `true` if any field has been modified."]
14307 pub fn is_dirty(&self) -> bool {
14308 self.abstract_nautilus.is_dirty() || self.variant.is_dirty()
14309 }
14310}
14311impl Default for ZombieNautilusEntityData {
14312 fn default() -> Self {
14313 Self::new()
14314 }
14315}
14316impl VanillaEntityData for ZombieNautilusEntityData {
14317 fn base(&self) -> &BaseEntityData {
14318 ZombieNautilusEntityData::base(self)
14319 }
14320 fn base_mut(&mut self) -> &mut BaseEntityData {
14321 ZombieNautilusEntityData::base_mut(self)
14322 }
14323 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14324 ZombieNautilusEntityData::pack_dirty(self)
14325 }
14326 fn pack_all(&self) -> Vec<DataValue> {
14327 ZombieNautilusEntityData::pack_all(self)
14328 }
14329 fn is_dirty(&self) -> bool {
14330 ZombieNautilusEntityData::is_dirty(self)
14331 }
14332}
14333impl VanillaLivingEntityData for ZombieNautilusEntityData {
14334 fn living_entity(&self) -> &LivingEntityData {
14335 ZombieNautilusEntityData::living_entity(self)
14336 }
14337 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
14338 ZombieNautilusEntityData::living_entity_mut(self)
14339 }
14340}
14341#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
14342#[derive(Debug, Clone)]
14343pub struct ZombieVillagerEntityData {
14344 pub zombie: ZombieEntityData,
14345 pub converting: SyncedValue<bool>,
14346 pub villager_data: SyncedValue<VillagerData>,
14347 pub villager_data_finalized: SyncedValue<bool>,
14348}
14349impl ZombieVillagerEntityData {
14350 #[doc = r" Create new entity data with default values."]
14351 pub fn new() -> Self {
14352 Self {
14353 zombie: ZombieEntityData::new(),
14354 converting: SyncedValue::new(false),
14355 villager_data: SyncedValue::new(VillagerData::new(0, 14, 1i32)),
14356 villager_data_finalized: SyncedValue::new(false),
14357 }
14358 }
14359 #[doc = "Returns the `ZombieVillagerEntityData` layer."]
14360 pub fn zombie_villager(&self) -> &ZombieVillagerEntityData {
14361 self
14362 }
14363 #[doc = "Returns the mutable `ZombieVillagerEntityData` layer."]
14364 pub fn zombie_villager_mut(&mut self) -> &mut ZombieVillagerEntityData {
14365 self
14366 }
14367 #[doc = "Returns the `ZombieEntityData` layer."]
14368 pub fn zombie(&self) -> &ZombieEntityData {
14369 &self.zombie
14370 }
14371 #[doc = "Returns the mutable `ZombieEntityData` layer."]
14372 pub fn zombie_mut(&mut self) -> &mut ZombieEntityData {
14373 &mut self.zombie
14374 }
14375 #[doc = "Returns the `MobEntityData` layer."]
14376 pub fn mob(&self) -> &MobEntityData {
14377 &self.zombie.mob
14378 }
14379 #[doc = "Returns the mutable `MobEntityData` layer."]
14380 pub fn mob_mut(&mut self) -> &mut MobEntityData {
14381 &mut self.zombie.mob
14382 }
14383 #[doc = "Returns the `LivingEntityData` layer."]
14384 pub fn living_entity(&self) -> &LivingEntityData {
14385 &self.zombie.mob.living_entity
14386 }
14387 #[doc = "Returns the mutable `LivingEntityData` layer."]
14388 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
14389 &mut self.zombie.mob.living_entity
14390 }
14391 #[doc = "Returns the `BaseEntityData` layer."]
14392 pub fn base(&self) -> &BaseEntityData {
14393 &self.zombie.mob.living_entity.base
14394 }
14395 #[doc = "Returns the mutable `BaseEntityData` layer."]
14396 pub fn base_mut(&mut self) -> &mut BaseEntityData {
14397 &mut self.zombie.mob.living_entity.base
14398 }
14399 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
14400 #[doc = r" Returns `None` if no values are dirty."]
14401 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14402 let mut values = Vec::new();
14403 self.pack_dirty_into(&mut values);
14404 if values.is_empty() {
14405 None
14406 } else {
14407 Some(values)
14408 }
14409 }
14410 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
14411 self.zombie.pack_dirty_into(values);
14412 if self.converting.is_dirty() {
14413 values.push(DataValue {
14414 index: 19u8,
14415 serializer_id: 8i32,
14416 value: EntityData::Boolean(*self.converting.get()),
14417 });
14418 self.converting.clear_dirty();
14419 }
14420 if self.villager_data.is_dirty() {
14421 values.push(DataValue {
14422 index: 20u8,
14423 serializer_id: 18i32,
14424 value: EntityData::VillagerData(self.villager_data.get().clone()),
14425 });
14426 self.villager_data.clear_dirty();
14427 }
14428 if self.villager_data_finalized.is_dirty() {
14429 values.push(DataValue {
14430 index: 21u8,
14431 serializer_id: 8i32,
14432 value: EntityData::Boolean(*self.villager_data_finalized.get()),
14433 });
14434 self.villager_data_finalized.clear_dirty();
14435 }
14436 }
14437 #[doc = r" Pack all non-default values (for initial entity spawn)."]
14438 pub fn pack_all(&self) -> Vec<DataValue> {
14439 let mut values = Vec::new();
14440 self.pack_all_into(&mut values);
14441 values
14442 }
14443 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
14444 self.zombie.pack_all_into(values);
14445 if !self.converting.is_default() {
14446 values.push(DataValue {
14447 index: 19u8,
14448 serializer_id: 8i32,
14449 value: EntityData::Boolean(*self.converting.get()),
14450 });
14451 }
14452 if !self.villager_data.is_default() {
14453 values.push(DataValue {
14454 index: 20u8,
14455 serializer_id: 18i32,
14456 value: EntityData::VillagerData(self.villager_data.get().clone()),
14457 });
14458 }
14459 if !self.villager_data_finalized.is_default() {
14460 values.push(DataValue {
14461 index: 21u8,
14462 serializer_id: 8i32,
14463 value: EntityData::Boolean(*self.villager_data_finalized.get()),
14464 });
14465 }
14466 }
14467 #[doc = r" Returns `true` if any field has been modified."]
14468 pub fn is_dirty(&self) -> bool {
14469 self.zombie.is_dirty()
14470 || self.converting.is_dirty()
14471 || self.villager_data.is_dirty()
14472 || self.villager_data_finalized.is_dirty()
14473 }
14474}
14475impl Default for ZombieVillagerEntityData {
14476 fn default() -> Self {
14477 Self::new()
14478 }
14479}
14480impl VanillaEntityData for ZombieVillagerEntityData {
14481 fn base(&self) -> &BaseEntityData {
14482 ZombieVillagerEntityData::base(self)
14483 }
14484 fn base_mut(&mut self) -> &mut BaseEntityData {
14485 ZombieVillagerEntityData::base_mut(self)
14486 }
14487 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14488 ZombieVillagerEntityData::pack_dirty(self)
14489 }
14490 fn pack_all(&self) -> Vec<DataValue> {
14491 ZombieVillagerEntityData::pack_all(self)
14492 }
14493 fn is_dirty(&self) -> bool {
14494 ZombieVillagerEntityData::is_dirty(self)
14495 }
14496}
14497impl VanillaLivingEntityData for ZombieVillagerEntityData {
14498 fn living_entity(&self) -> &LivingEntityData {
14499 ZombieVillagerEntityData::living_entity(self)
14500 }
14501 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
14502 ZombieVillagerEntityData::living_entity_mut(self)
14503 }
14504}
14505#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
14506#[derive(Debug, Clone)]
14507pub struct PlayerEntityData {
14508 pub avatar: AvatarEntityData,
14509 pub player_absorption: SyncedValue<f32>,
14510 pub score: SyncedValue<i32>,
14511 pub shoulder_parrot_left: SyncedValue<Option<u32>>,
14512 pub shoulder_parrot_right: SyncedValue<Option<u32>>,
14513}
14514impl PlayerEntityData {
14515 #[doc = r" Create new entity data with default values."]
14516 pub fn new() -> Self {
14517 Self {
14518 avatar: AvatarEntityData::new(),
14519 player_absorption: SyncedValue::new(0f32),
14520 score: SyncedValue::new(0i32),
14521 shoulder_parrot_left: SyncedValue::new(None),
14522 shoulder_parrot_right: SyncedValue::new(None),
14523 }
14524 }
14525 #[doc = "Returns the `PlayerEntityData` layer."]
14526 pub fn player(&self) -> &PlayerEntityData {
14527 self
14528 }
14529 #[doc = "Returns the mutable `PlayerEntityData` layer."]
14530 pub fn player_mut(&mut self) -> &mut PlayerEntityData {
14531 self
14532 }
14533 #[doc = "Returns the `AvatarEntityData` layer."]
14534 pub fn avatar(&self) -> &AvatarEntityData {
14535 &self.avatar
14536 }
14537 #[doc = "Returns the mutable `AvatarEntityData` layer."]
14538 pub fn avatar_mut(&mut self) -> &mut AvatarEntityData {
14539 &mut self.avatar
14540 }
14541 #[doc = "Returns the `LivingEntityData` layer."]
14542 pub fn living_entity(&self) -> &LivingEntityData {
14543 &self.avatar.living_entity
14544 }
14545 #[doc = "Returns the mutable `LivingEntityData` layer."]
14546 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
14547 &mut self.avatar.living_entity
14548 }
14549 #[doc = "Returns the `BaseEntityData` layer."]
14550 pub fn base(&self) -> &BaseEntityData {
14551 &self.avatar.living_entity.base
14552 }
14553 #[doc = "Returns the mutable `BaseEntityData` layer."]
14554 pub fn base_mut(&mut self) -> &mut BaseEntityData {
14555 &mut self.avatar.living_entity.base
14556 }
14557 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
14558 #[doc = r" Returns `None` if no values are dirty."]
14559 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14560 let mut values = Vec::new();
14561 self.pack_dirty_into(&mut values);
14562 if values.is_empty() {
14563 None
14564 } else {
14565 Some(values)
14566 }
14567 }
14568 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
14569 self.avatar.pack_dirty_into(values);
14570 if self.player_absorption.is_dirty() {
14571 values.push(DataValue {
14572 index: 17u8,
14573 serializer_id: 3i32,
14574 value: EntityData::Float(*self.player_absorption.get()),
14575 });
14576 self.player_absorption.clear_dirty();
14577 }
14578 if self.score.is_dirty() {
14579 values.push(DataValue {
14580 index: 18u8,
14581 serializer_id: 1i32,
14582 value: EntityData::Int(*self.score.get()),
14583 });
14584 self.score.clear_dirty();
14585 }
14586 if self.shoulder_parrot_left.is_dirty() {
14587 values.push(DataValue {
14588 index: 19u8,
14589 serializer_id: 19i32,
14590 value: EntityData::OptionalUnsignedInt(self.shoulder_parrot_left.get().clone()),
14591 });
14592 self.shoulder_parrot_left.clear_dirty();
14593 }
14594 if self.shoulder_parrot_right.is_dirty() {
14595 values.push(DataValue {
14596 index: 20u8,
14597 serializer_id: 19i32,
14598 value: EntityData::OptionalUnsignedInt(self.shoulder_parrot_right.get().clone()),
14599 });
14600 self.shoulder_parrot_right.clear_dirty();
14601 }
14602 }
14603 #[doc = r" Pack all non-default values (for initial entity spawn)."]
14604 pub fn pack_all(&self) -> Vec<DataValue> {
14605 let mut values = Vec::new();
14606 self.pack_all_into(&mut values);
14607 values
14608 }
14609 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
14610 self.avatar.pack_all_into(values);
14611 if !self.player_absorption.is_default() {
14612 values.push(DataValue {
14613 index: 17u8,
14614 serializer_id: 3i32,
14615 value: EntityData::Float(*self.player_absorption.get()),
14616 });
14617 }
14618 if !self.score.is_default() {
14619 values.push(DataValue {
14620 index: 18u8,
14621 serializer_id: 1i32,
14622 value: EntityData::Int(*self.score.get()),
14623 });
14624 }
14625 if !self.shoulder_parrot_left.is_default() {
14626 values.push(DataValue {
14627 index: 19u8,
14628 serializer_id: 19i32,
14629 value: EntityData::OptionalUnsignedInt(self.shoulder_parrot_left.get().clone()),
14630 });
14631 }
14632 if !self.shoulder_parrot_right.is_default() {
14633 values.push(DataValue {
14634 index: 20u8,
14635 serializer_id: 19i32,
14636 value: EntityData::OptionalUnsignedInt(self.shoulder_parrot_right.get().clone()),
14637 });
14638 }
14639 }
14640 #[doc = r" Returns `true` if any field has been modified."]
14641 pub fn is_dirty(&self) -> bool {
14642 self.avatar.is_dirty()
14643 || self.player_absorption.is_dirty()
14644 || self.score.is_dirty()
14645 || self.shoulder_parrot_left.is_dirty()
14646 || self.shoulder_parrot_right.is_dirty()
14647 }
14648}
14649impl Default for PlayerEntityData {
14650 fn default() -> Self {
14651 Self::new()
14652 }
14653}
14654impl VanillaEntityData for PlayerEntityData {
14655 fn base(&self) -> &BaseEntityData {
14656 PlayerEntityData::base(self)
14657 }
14658 fn base_mut(&mut self) -> &mut BaseEntityData {
14659 PlayerEntityData::base_mut(self)
14660 }
14661 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14662 PlayerEntityData::pack_dirty(self)
14663 }
14664 fn pack_all(&self) -> Vec<DataValue> {
14665 PlayerEntityData::pack_all(self)
14666 }
14667 fn is_dirty(&self) -> bool {
14668 PlayerEntityData::is_dirty(self)
14669 }
14670}
14671impl VanillaLivingEntityData for PlayerEntityData {
14672 fn living_entity(&self) -> &LivingEntityData {
14673 PlayerEntityData::living_entity(self)
14674 }
14675 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
14676 PlayerEntityData::living_entity_mut(self)
14677 }
14678}
14679#[doc = r" Synchronized entity data declared by the vanilla `#struct_name` layer."]
14680#[derive(Debug, Clone)]
14681pub struct FishingHookEntityData {
14682 pub base: BaseEntityData,
14683 pub hooked_entity: SyncedValue<i32>,
14684 pub biting: SyncedValue<bool>,
14685}
14686impl FishingHookEntityData {
14687 #[doc = r" Create new entity data with default values."]
14688 pub fn new() -> Self {
14689 Self {
14690 base: BaseEntityData::new(),
14691 hooked_entity: SyncedValue::new(0i32),
14692 biting: SyncedValue::new(false),
14693 }
14694 }
14695 #[doc = "Returns the `FishingHookEntityData` layer."]
14696 pub fn fishing_hook(&self) -> &FishingHookEntityData {
14697 self
14698 }
14699 #[doc = "Returns the mutable `FishingHookEntityData` layer."]
14700 pub fn fishing_hook_mut(&mut self) -> &mut FishingHookEntityData {
14701 self
14702 }
14703 #[doc = "Returns the `BaseEntityData` layer."]
14704 pub fn base(&self) -> &BaseEntityData {
14705 &self.base
14706 }
14707 #[doc = "Returns the mutable `BaseEntityData` layer."]
14708 pub fn base_mut(&mut self) -> &mut BaseEntityData {
14709 &mut self.base
14710 }
14711 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
14712 #[doc = r" Returns `None` if no values are dirty."]
14713 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14714 let mut values = Vec::new();
14715 self.pack_dirty_into(&mut values);
14716 if values.is_empty() {
14717 None
14718 } else {
14719 Some(values)
14720 }
14721 }
14722 fn pack_dirty_into(&mut self, values: &mut Vec<DataValue>) {
14723 self.base.pack_dirty_into(values);
14724 if self.hooked_entity.is_dirty() {
14725 values.push(DataValue {
14726 index: 8u8,
14727 serializer_id: 1i32,
14728 value: EntityData::Int(*self.hooked_entity.get()),
14729 });
14730 self.hooked_entity.clear_dirty();
14731 }
14732 if self.biting.is_dirty() {
14733 values.push(DataValue {
14734 index: 9u8,
14735 serializer_id: 8i32,
14736 value: EntityData::Boolean(*self.biting.get()),
14737 });
14738 self.biting.clear_dirty();
14739 }
14740 }
14741 #[doc = r" Pack all non-default values (for initial entity spawn)."]
14742 pub fn pack_all(&self) -> Vec<DataValue> {
14743 let mut values = Vec::new();
14744 self.pack_all_into(&mut values);
14745 values
14746 }
14747 fn pack_all_into(&self, values: &mut Vec<DataValue>) {
14748 self.base.pack_all_into(values);
14749 if !self.hooked_entity.is_default() {
14750 values.push(DataValue {
14751 index: 8u8,
14752 serializer_id: 1i32,
14753 value: EntityData::Int(*self.hooked_entity.get()),
14754 });
14755 }
14756 if !self.biting.is_default() {
14757 values.push(DataValue {
14758 index: 9u8,
14759 serializer_id: 8i32,
14760 value: EntityData::Boolean(*self.biting.get()),
14761 });
14762 }
14763 }
14764 #[doc = r" Returns `true` if any field has been modified."]
14765 pub fn is_dirty(&self) -> bool {
14766 self.base.is_dirty() || self.hooked_entity.is_dirty() || self.biting.is_dirty()
14767 }
14768}
14769impl Default for FishingHookEntityData {
14770 fn default() -> Self {
14771 Self::new()
14772 }
14773}
14774impl VanillaEntityData for FishingHookEntityData {
14775 fn base(&self) -> &BaseEntityData {
14776 FishingHookEntityData::base(self)
14777 }
14778 fn base_mut(&mut self) -> &mut BaseEntityData {
14779 FishingHookEntityData::base_mut(self)
14780 }
14781 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14782 FishingHookEntityData::pack_dirty(self)
14783 }
14784 fn pack_all(&self) -> Vec<DataValue> {
14785 FishingHookEntityData::pack_all(self)
14786 }
14787 fn is_dirty(&self) -> bool {
14788 FishingHookEntityData::is_dirty(self)
14789 }
14790}
14791#[doc = "Concrete synchronized entity data for vanilla entity `acacia_boat`."]
14792#[derive(Debug, Clone)]
14793pub struct AcaciaBoatEntityData {
14794 pub abstract_boat: AbstractBoatEntityData,
14795}
14796impl AcaciaBoatEntityData {
14797 #[doc = r" Create new entity data with default values."]
14798 pub fn new() -> Self {
14799 Self {
14800 abstract_boat: AbstractBoatEntityData::new(),
14801 }
14802 }
14803 #[doc = "Returns the `AbstractBoatEntityData` layer."]
14804 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
14805 &self.abstract_boat
14806 }
14807 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
14808 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
14809 &mut self.abstract_boat
14810 }
14811 #[doc = "Returns the `VehicleEntityData` layer."]
14812 pub fn vehicle_entity(&self) -> &VehicleEntityData {
14813 &self.abstract_boat.vehicle_entity
14814 }
14815 #[doc = "Returns the mutable `VehicleEntityData` layer."]
14816 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
14817 &mut self.abstract_boat.vehicle_entity
14818 }
14819 #[doc = "Returns the `BaseEntityData` layer."]
14820 pub fn base(&self) -> &BaseEntityData {
14821 &self.abstract_boat.vehicle_entity.base
14822 }
14823 #[doc = "Returns the mutable `BaseEntityData` layer."]
14824 pub fn base_mut(&mut self) -> &mut BaseEntityData {
14825 &mut self.abstract_boat.vehicle_entity.base
14826 }
14827 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
14828 #[doc = r" Returns `None` if no values are dirty."]
14829 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14830 self.abstract_boat.pack_dirty()
14831 }
14832 #[doc = r" Pack all non-default values (for initial entity spawn)."]
14833 pub fn pack_all(&self) -> Vec<DataValue> {
14834 self.abstract_boat.pack_all()
14835 }
14836 #[doc = r" Returns `true` if any field has been modified."]
14837 pub fn is_dirty(&self) -> bool {
14838 self.abstract_boat.is_dirty()
14839 }
14840}
14841impl Default for AcaciaBoatEntityData {
14842 fn default() -> Self {
14843 Self::new()
14844 }
14845}
14846impl VanillaEntityData for AcaciaBoatEntityData {
14847 fn base(&self) -> &BaseEntityData {
14848 AcaciaBoatEntityData::base(self)
14849 }
14850 fn base_mut(&mut self) -> &mut BaseEntityData {
14851 AcaciaBoatEntityData::base_mut(self)
14852 }
14853 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14854 AcaciaBoatEntityData::pack_dirty(self)
14855 }
14856 fn pack_all(&self) -> Vec<DataValue> {
14857 AcaciaBoatEntityData::pack_all(self)
14858 }
14859 fn is_dirty(&self) -> bool {
14860 AcaciaBoatEntityData::is_dirty(self)
14861 }
14862}
14863#[doc = "Concrete synchronized entity data for vanilla entity `acacia_chest_boat`."]
14864#[derive(Debug, Clone)]
14865pub struct AcaciaChestBoatEntityData {
14866 pub abstract_boat: AbstractBoatEntityData,
14867}
14868impl AcaciaChestBoatEntityData {
14869 #[doc = r" Create new entity data with default values."]
14870 pub fn new() -> Self {
14871 Self {
14872 abstract_boat: AbstractBoatEntityData::new(),
14873 }
14874 }
14875 #[doc = "Returns the `AbstractBoatEntityData` layer."]
14876 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
14877 &self.abstract_boat
14878 }
14879 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
14880 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
14881 &mut self.abstract_boat
14882 }
14883 #[doc = "Returns the `VehicleEntityData` layer."]
14884 pub fn vehicle_entity(&self) -> &VehicleEntityData {
14885 &self.abstract_boat.vehicle_entity
14886 }
14887 #[doc = "Returns the mutable `VehicleEntityData` layer."]
14888 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
14889 &mut self.abstract_boat.vehicle_entity
14890 }
14891 #[doc = "Returns the `BaseEntityData` layer."]
14892 pub fn base(&self) -> &BaseEntityData {
14893 &self.abstract_boat.vehicle_entity.base
14894 }
14895 #[doc = "Returns the mutable `BaseEntityData` layer."]
14896 pub fn base_mut(&mut self) -> &mut BaseEntityData {
14897 &mut self.abstract_boat.vehicle_entity.base
14898 }
14899 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
14900 #[doc = r" Returns `None` if no values are dirty."]
14901 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14902 self.abstract_boat.pack_dirty()
14903 }
14904 #[doc = r" Pack all non-default values (for initial entity spawn)."]
14905 pub fn pack_all(&self) -> Vec<DataValue> {
14906 self.abstract_boat.pack_all()
14907 }
14908 #[doc = r" Returns `true` if any field has been modified."]
14909 pub fn is_dirty(&self) -> bool {
14910 self.abstract_boat.is_dirty()
14911 }
14912}
14913impl Default for AcaciaChestBoatEntityData {
14914 fn default() -> Self {
14915 Self::new()
14916 }
14917}
14918impl VanillaEntityData for AcaciaChestBoatEntityData {
14919 fn base(&self) -> &BaseEntityData {
14920 AcaciaChestBoatEntityData::base(self)
14921 }
14922 fn base_mut(&mut self) -> &mut BaseEntityData {
14923 AcaciaChestBoatEntityData::base_mut(self)
14924 }
14925 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14926 AcaciaChestBoatEntityData::pack_dirty(self)
14927 }
14928 fn pack_all(&self) -> Vec<DataValue> {
14929 AcaciaChestBoatEntityData::pack_all(self)
14930 }
14931 fn is_dirty(&self) -> bool {
14932 AcaciaChestBoatEntityData::is_dirty(self)
14933 }
14934}
14935#[doc = "Concrete synchronized entity data for vanilla entity `bamboo_chest_raft`."]
14936#[derive(Debug, Clone)]
14937pub struct BambooChestRaftEntityData {
14938 pub abstract_boat: AbstractBoatEntityData,
14939}
14940impl BambooChestRaftEntityData {
14941 #[doc = r" Create new entity data with default values."]
14942 pub fn new() -> Self {
14943 Self {
14944 abstract_boat: AbstractBoatEntityData::new(),
14945 }
14946 }
14947 #[doc = "Returns the `AbstractBoatEntityData` layer."]
14948 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
14949 &self.abstract_boat
14950 }
14951 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
14952 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
14953 &mut self.abstract_boat
14954 }
14955 #[doc = "Returns the `VehicleEntityData` layer."]
14956 pub fn vehicle_entity(&self) -> &VehicleEntityData {
14957 &self.abstract_boat.vehicle_entity
14958 }
14959 #[doc = "Returns the mutable `VehicleEntityData` layer."]
14960 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
14961 &mut self.abstract_boat.vehicle_entity
14962 }
14963 #[doc = "Returns the `BaseEntityData` layer."]
14964 pub fn base(&self) -> &BaseEntityData {
14965 &self.abstract_boat.vehicle_entity.base
14966 }
14967 #[doc = "Returns the mutable `BaseEntityData` layer."]
14968 pub fn base_mut(&mut self) -> &mut BaseEntityData {
14969 &mut self.abstract_boat.vehicle_entity.base
14970 }
14971 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
14972 #[doc = r" Returns `None` if no values are dirty."]
14973 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14974 self.abstract_boat.pack_dirty()
14975 }
14976 #[doc = r" Pack all non-default values (for initial entity spawn)."]
14977 pub fn pack_all(&self) -> Vec<DataValue> {
14978 self.abstract_boat.pack_all()
14979 }
14980 #[doc = r" Returns `true` if any field has been modified."]
14981 pub fn is_dirty(&self) -> bool {
14982 self.abstract_boat.is_dirty()
14983 }
14984}
14985impl Default for BambooChestRaftEntityData {
14986 fn default() -> Self {
14987 Self::new()
14988 }
14989}
14990impl VanillaEntityData for BambooChestRaftEntityData {
14991 fn base(&self) -> &BaseEntityData {
14992 BambooChestRaftEntityData::base(self)
14993 }
14994 fn base_mut(&mut self) -> &mut BaseEntityData {
14995 BambooChestRaftEntityData::base_mut(self)
14996 }
14997 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
14998 BambooChestRaftEntityData::pack_dirty(self)
14999 }
15000 fn pack_all(&self) -> Vec<DataValue> {
15001 BambooChestRaftEntityData::pack_all(self)
15002 }
15003 fn is_dirty(&self) -> bool {
15004 BambooChestRaftEntityData::is_dirty(self)
15005 }
15006}
15007#[doc = "Concrete synchronized entity data for vanilla entity `bamboo_raft`."]
15008#[derive(Debug, Clone)]
15009pub struct BambooRaftEntityData {
15010 pub abstract_boat: AbstractBoatEntityData,
15011}
15012impl BambooRaftEntityData {
15013 #[doc = r" Create new entity data with default values."]
15014 pub fn new() -> Self {
15015 Self {
15016 abstract_boat: AbstractBoatEntityData::new(),
15017 }
15018 }
15019 #[doc = "Returns the `AbstractBoatEntityData` layer."]
15020 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
15021 &self.abstract_boat
15022 }
15023 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
15024 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
15025 &mut self.abstract_boat
15026 }
15027 #[doc = "Returns the `VehicleEntityData` layer."]
15028 pub fn vehicle_entity(&self) -> &VehicleEntityData {
15029 &self.abstract_boat.vehicle_entity
15030 }
15031 #[doc = "Returns the mutable `VehicleEntityData` layer."]
15032 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
15033 &mut self.abstract_boat.vehicle_entity
15034 }
15035 #[doc = "Returns the `BaseEntityData` layer."]
15036 pub fn base(&self) -> &BaseEntityData {
15037 &self.abstract_boat.vehicle_entity.base
15038 }
15039 #[doc = "Returns the mutable `BaseEntityData` layer."]
15040 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15041 &mut self.abstract_boat.vehicle_entity.base
15042 }
15043 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15044 #[doc = r" Returns `None` if no values are dirty."]
15045 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15046 self.abstract_boat.pack_dirty()
15047 }
15048 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15049 pub fn pack_all(&self) -> Vec<DataValue> {
15050 self.abstract_boat.pack_all()
15051 }
15052 #[doc = r" Returns `true` if any field has been modified."]
15053 pub fn is_dirty(&self) -> bool {
15054 self.abstract_boat.is_dirty()
15055 }
15056}
15057impl Default for BambooRaftEntityData {
15058 fn default() -> Self {
15059 Self::new()
15060 }
15061}
15062impl VanillaEntityData for BambooRaftEntityData {
15063 fn base(&self) -> &BaseEntityData {
15064 BambooRaftEntityData::base(self)
15065 }
15066 fn base_mut(&mut self) -> &mut BaseEntityData {
15067 BambooRaftEntityData::base_mut(self)
15068 }
15069 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15070 BambooRaftEntityData::pack_dirty(self)
15071 }
15072 fn pack_all(&self) -> Vec<DataValue> {
15073 BambooRaftEntityData::pack_all(self)
15074 }
15075 fn is_dirty(&self) -> bool {
15076 BambooRaftEntityData::is_dirty(self)
15077 }
15078}
15079#[doc = "Concrete synchronized entity data for vanilla entity `birch_boat`."]
15080#[derive(Debug, Clone)]
15081pub struct BirchBoatEntityData {
15082 pub abstract_boat: AbstractBoatEntityData,
15083}
15084impl BirchBoatEntityData {
15085 #[doc = r" Create new entity data with default values."]
15086 pub fn new() -> Self {
15087 Self {
15088 abstract_boat: AbstractBoatEntityData::new(),
15089 }
15090 }
15091 #[doc = "Returns the `AbstractBoatEntityData` layer."]
15092 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
15093 &self.abstract_boat
15094 }
15095 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
15096 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
15097 &mut self.abstract_boat
15098 }
15099 #[doc = "Returns the `VehicleEntityData` layer."]
15100 pub fn vehicle_entity(&self) -> &VehicleEntityData {
15101 &self.abstract_boat.vehicle_entity
15102 }
15103 #[doc = "Returns the mutable `VehicleEntityData` layer."]
15104 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
15105 &mut self.abstract_boat.vehicle_entity
15106 }
15107 #[doc = "Returns the `BaseEntityData` layer."]
15108 pub fn base(&self) -> &BaseEntityData {
15109 &self.abstract_boat.vehicle_entity.base
15110 }
15111 #[doc = "Returns the mutable `BaseEntityData` layer."]
15112 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15113 &mut self.abstract_boat.vehicle_entity.base
15114 }
15115 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15116 #[doc = r" Returns `None` if no values are dirty."]
15117 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15118 self.abstract_boat.pack_dirty()
15119 }
15120 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15121 pub fn pack_all(&self) -> Vec<DataValue> {
15122 self.abstract_boat.pack_all()
15123 }
15124 #[doc = r" Returns `true` if any field has been modified."]
15125 pub fn is_dirty(&self) -> bool {
15126 self.abstract_boat.is_dirty()
15127 }
15128}
15129impl Default for BirchBoatEntityData {
15130 fn default() -> Self {
15131 Self::new()
15132 }
15133}
15134impl VanillaEntityData for BirchBoatEntityData {
15135 fn base(&self) -> &BaseEntityData {
15136 BirchBoatEntityData::base(self)
15137 }
15138 fn base_mut(&mut self) -> &mut BaseEntityData {
15139 BirchBoatEntityData::base_mut(self)
15140 }
15141 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15142 BirchBoatEntityData::pack_dirty(self)
15143 }
15144 fn pack_all(&self) -> Vec<DataValue> {
15145 BirchBoatEntityData::pack_all(self)
15146 }
15147 fn is_dirty(&self) -> bool {
15148 BirchBoatEntityData::is_dirty(self)
15149 }
15150}
15151#[doc = "Concrete synchronized entity data for vanilla entity `birch_chest_boat`."]
15152#[derive(Debug, Clone)]
15153pub struct BirchChestBoatEntityData {
15154 pub abstract_boat: AbstractBoatEntityData,
15155}
15156impl BirchChestBoatEntityData {
15157 #[doc = r" Create new entity data with default values."]
15158 pub fn new() -> Self {
15159 Self {
15160 abstract_boat: AbstractBoatEntityData::new(),
15161 }
15162 }
15163 #[doc = "Returns the `AbstractBoatEntityData` layer."]
15164 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
15165 &self.abstract_boat
15166 }
15167 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
15168 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
15169 &mut self.abstract_boat
15170 }
15171 #[doc = "Returns the `VehicleEntityData` layer."]
15172 pub fn vehicle_entity(&self) -> &VehicleEntityData {
15173 &self.abstract_boat.vehicle_entity
15174 }
15175 #[doc = "Returns the mutable `VehicleEntityData` layer."]
15176 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
15177 &mut self.abstract_boat.vehicle_entity
15178 }
15179 #[doc = "Returns the `BaseEntityData` layer."]
15180 pub fn base(&self) -> &BaseEntityData {
15181 &self.abstract_boat.vehicle_entity.base
15182 }
15183 #[doc = "Returns the mutable `BaseEntityData` layer."]
15184 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15185 &mut self.abstract_boat.vehicle_entity.base
15186 }
15187 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15188 #[doc = r" Returns `None` if no values are dirty."]
15189 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15190 self.abstract_boat.pack_dirty()
15191 }
15192 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15193 pub fn pack_all(&self) -> Vec<DataValue> {
15194 self.abstract_boat.pack_all()
15195 }
15196 #[doc = r" Returns `true` if any field has been modified."]
15197 pub fn is_dirty(&self) -> bool {
15198 self.abstract_boat.is_dirty()
15199 }
15200}
15201impl Default for BirchChestBoatEntityData {
15202 fn default() -> Self {
15203 Self::new()
15204 }
15205}
15206impl VanillaEntityData for BirchChestBoatEntityData {
15207 fn base(&self) -> &BaseEntityData {
15208 BirchChestBoatEntityData::base(self)
15209 }
15210 fn base_mut(&mut self) -> &mut BaseEntityData {
15211 BirchChestBoatEntityData::base_mut(self)
15212 }
15213 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15214 BirchChestBoatEntityData::pack_dirty(self)
15215 }
15216 fn pack_all(&self) -> Vec<DataValue> {
15217 BirchChestBoatEntityData::pack_all(self)
15218 }
15219 fn is_dirty(&self) -> bool {
15220 BirchChestBoatEntityData::is_dirty(self)
15221 }
15222}
15223#[doc = "Concrete synchronized entity data for vanilla entity `breeze`."]
15224#[derive(Debug, Clone)]
15225pub struct BreezeEntityData {
15226 pub mob: MobEntityData,
15227}
15228impl BreezeEntityData {
15229 #[doc = r" Create new entity data with default values."]
15230 pub fn new() -> Self {
15231 Self {
15232 mob: MobEntityData::new(),
15233 }
15234 }
15235 #[doc = "Returns the `MobEntityData` layer."]
15236 pub fn mob(&self) -> &MobEntityData {
15237 &self.mob
15238 }
15239 #[doc = "Returns the mutable `MobEntityData` layer."]
15240 pub fn mob_mut(&mut self) -> &mut MobEntityData {
15241 &mut self.mob
15242 }
15243 #[doc = "Returns the `LivingEntityData` layer."]
15244 pub fn living_entity(&self) -> &LivingEntityData {
15245 &self.mob.living_entity
15246 }
15247 #[doc = "Returns the mutable `LivingEntityData` layer."]
15248 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
15249 &mut self.mob.living_entity
15250 }
15251 #[doc = "Returns the `BaseEntityData` layer."]
15252 pub fn base(&self) -> &BaseEntityData {
15253 &self.mob.living_entity.base
15254 }
15255 #[doc = "Returns the mutable `BaseEntityData` layer."]
15256 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15257 &mut self.mob.living_entity.base
15258 }
15259 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15260 #[doc = r" Returns `None` if no values are dirty."]
15261 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15262 self.mob.pack_dirty()
15263 }
15264 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15265 pub fn pack_all(&self) -> Vec<DataValue> {
15266 self.mob.pack_all()
15267 }
15268 #[doc = r" Returns `true` if any field has been modified."]
15269 pub fn is_dirty(&self) -> bool {
15270 self.mob.is_dirty()
15271 }
15272}
15273impl Default for BreezeEntityData {
15274 fn default() -> Self {
15275 Self::new()
15276 }
15277}
15278impl VanillaEntityData for BreezeEntityData {
15279 fn base(&self) -> &BaseEntityData {
15280 BreezeEntityData::base(self)
15281 }
15282 fn base_mut(&mut self) -> &mut BaseEntityData {
15283 BreezeEntityData::base_mut(self)
15284 }
15285 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15286 BreezeEntityData::pack_dirty(self)
15287 }
15288 fn pack_all(&self) -> Vec<DataValue> {
15289 BreezeEntityData::pack_all(self)
15290 }
15291 fn is_dirty(&self) -> bool {
15292 BreezeEntityData::is_dirty(self)
15293 }
15294}
15295impl VanillaLivingEntityData for BreezeEntityData {
15296 fn living_entity(&self) -> &LivingEntityData {
15297 BreezeEntityData::living_entity(self)
15298 }
15299 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
15300 BreezeEntityData::living_entity_mut(self)
15301 }
15302}
15303#[doc = "Concrete synchronized entity data for vanilla entity `breeze_wind_charge`."]
15304#[derive(Debug, Clone)]
15305pub struct BreezeWindChargeEntityData {
15306 pub base: BaseEntityData,
15307}
15308impl BreezeWindChargeEntityData {
15309 #[doc = r" Create new entity data with default values."]
15310 pub fn new() -> Self {
15311 Self {
15312 base: BaseEntityData::new(),
15313 }
15314 }
15315 #[doc = "Returns the `BaseEntityData` layer."]
15316 pub fn base(&self) -> &BaseEntityData {
15317 &self.base
15318 }
15319 #[doc = "Returns the mutable `BaseEntityData` layer."]
15320 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15321 &mut self.base
15322 }
15323 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15324 #[doc = r" Returns `None` if no values are dirty."]
15325 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15326 self.base.pack_dirty()
15327 }
15328 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15329 pub fn pack_all(&self) -> Vec<DataValue> {
15330 self.base.pack_all()
15331 }
15332 #[doc = r" Returns `true` if any field has been modified."]
15333 pub fn is_dirty(&self) -> bool {
15334 self.base.is_dirty()
15335 }
15336}
15337impl Default for BreezeWindChargeEntityData {
15338 fn default() -> Self {
15339 Self::new()
15340 }
15341}
15342impl VanillaEntityData for BreezeWindChargeEntityData {
15343 fn base(&self) -> &BaseEntityData {
15344 BreezeWindChargeEntityData::base(self)
15345 }
15346 fn base_mut(&mut self) -> &mut BaseEntityData {
15347 BreezeWindChargeEntityData::base_mut(self)
15348 }
15349 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15350 BreezeWindChargeEntityData::pack_dirty(self)
15351 }
15352 fn pack_all(&self) -> Vec<DataValue> {
15353 BreezeWindChargeEntityData::pack_all(self)
15354 }
15355 fn is_dirty(&self) -> bool {
15356 BreezeWindChargeEntityData::is_dirty(self)
15357 }
15358}
15359#[doc = "Concrete synchronized entity data for vanilla entity `camel_husk`."]
15360#[derive(Debug, Clone)]
15361pub struct CamelHuskEntityData {
15362 pub camel: CamelEntityData,
15363}
15364impl CamelHuskEntityData {
15365 #[doc = r" Create new entity data with default values."]
15366 pub fn new() -> Self {
15367 Self {
15368 camel: CamelEntityData::new(),
15369 }
15370 }
15371 #[doc = "Returns the `CamelEntityData` layer."]
15372 pub fn camel(&self) -> &CamelEntityData {
15373 &self.camel
15374 }
15375 #[doc = "Returns the mutable `CamelEntityData` layer."]
15376 pub fn camel_mut(&mut self) -> &mut CamelEntityData {
15377 &mut self.camel
15378 }
15379 #[doc = "Returns the `AbstractHorseEntityData` layer."]
15380 pub fn abstract_horse(&self) -> &AbstractHorseEntityData {
15381 &self.camel.abstract_horse
15382 }
15383 #[doc = "Returns the mutable `AbstractHorseEntityData` layer."]
15384 pub fn abstract_horse_mut(&mut self) -> &mut AbstractHorseEntityData {
15385 &mut self.camel.abstract_horse
15386 }
15387 #[doc = "Returns the `AgeableMobEntityData` layer."]
15388 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
15389 &self.camel.abstract_horse.ageable_mob
15390 }
15391 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
15392 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
15393 &mut self.camel.abstract_horse.ageable_mob
15394 }
15395 #[doc = "Returns the `MobEntityData` layer."]
15396 pub fn mob(&self) -> &MobEntityData {
15397 &self.camel.abstract_horse.ageable_mob.mob
15398 }
15399 #[doc = "Returns the mutable `MobEntityData` layer."]
15400 pub fn mob_mut(&mut self) -> &mut MobEntityData {
15401 &mut self.camel.abstract_horse.ageable_mob.mob
15402 }
15403 #[doc = "Returns the `LivingEntityData` layer."]
15404 pub fn living_entity(&self) -> &LivingEntityData {
15405 &self.camel.abstract_horse.ageable_mob.mob.living_entity
15406 }
15407 #[doc = "Returns the mutable `LivingEntityData` layer."]
15408 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
15409 &mut self.camel.abstract_horse.ageable_mob.mob.living_entity
15410 }
15411 #[doc = "Returns the `BaseEntityData` layer."]
15412 pub fn base(&self) -> &BaseEntityData {
15413 &self.camel.abstract_horse.ageable_mob.mob.living_entity.base
15414 }
15415 #[doc = "Returns the mutable `BaseEntityData` layer."]
15416 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15417 &mut self.camel.abstract_horse.ageable_mob.mob.living_entity.base
15418 }
15419 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15420 #[doc = r" Returns `None` if no values are dirty."]
15421 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15422 self.camel.pack_dirty()
15423 }
15424 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15425 pub fn pack_all(&self) -> Vec<DataValue> {
15426 self.camel.pack_all()
15427 }
15428 #[doc = r" Returns `true` if any field has been modified."]
15429 pub fn is_dirty(&self) -> bool {
15430 self.camel.is_dirty()
15431 }
15432}
15433impl Default for CamelHuskEntityData {
15434 fn default() -> Self {
15435 Self::new()
15436 }
15437}
15438impl VanillaEntityData for CamelHuskEntityData {
15439 fn base(&self) -> &BaseEntityData {
15440 CamelHuskEntityData::base(self)
15441 }
15442 fn base_mut(&mut self) -> &mut BaseEntityData {
15443 CamelHuskEntityData::base_mut(self)
15444 }
15445 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15446 CamelHuskEntityData::pack_dirty(self)
15447 }
15448 fn pack_all(&self) -> Vec<DataValue> {
15449 CamelHuskEntityData::pack_all(self)
15450 }
15451 fn is_dirty(&self) -> bool {
15452 CamelHuskEntityData::is_dirty(self)
15453 }
15454}
15455impl VanillaLivingEntityData for CamelHuskEntityData {
15456 fn living_entity(&self) -> &LivingEntityData {
15457 CamelHuskEntityData::living_entity(self)
15458 }
15459 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
15460 CamelHuskEntityData::living_entity_mut(self)
15461 }
15462}
15463#[doc = "Concrete synchronized entity data for vanilla entity `cave_spider`."]
15464#[derive(Debug, Clone)]
15465pub struct CaveSpiderEntityData {
15466 pub spider: SpiderEntityData,
15467}
15468impl CaveSpiderEntityData {
15469 #[doc = r" Create new entity data with default values."]
15470 pub fn new() -> Self {
15471 Self {
15472 spider: SpiderEntityData::new(),
15473 }
15474 }
15475 #[doc = "Returns the `SpiderEntityData` layer."]
15476 pub fn spider(&self) -> &SpiderEntityData {
15477 &self.spider
15478 }
15479 #[doc = "Returns the mutable `SpiderEntityData` layer."]
15480 pub fn spider_mut(&mut self) -> &mut SpiderEntityData {
15481 &mut self.spider
15482 }
15483 #[doc = "Returns the `MobEntityData` layer."]
15484 pub fn mob(&self) -> &MobEntityData {
15485 &self.spider.mob
15486 }
15487 #[doc = "Returns the mutable `MobEntityData` layer."]
15488 pub fn mob_mut(&mut self) -> &mut MobEntityData {
15489 &mut self.spider.mob
15490 }
15491 #[doc = "Returns the `LivingEntityData` layer."]
15492 pub fn living_entity(&self) -> &LivingEntityData {
15493 &self.spider.mob.living_entity
15494 }
15495 #[doc = "Returns the mutable `LivingEntityData` layer."]
15496 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
15497 &mut self.spider.mob.living_entity
15498 }
15499 #[doc = "Returns the `BaseEntityData` layer."]
15500 pub fn base(&self) -> &BaseEntityData {
15501 &self.spider.mob.living_entity.base
15502 }
15503 #[doc = "Returns the mutable `BaseEntityData` layer."]
15504 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15505 &mut self.spider.mob.living_entity.base
15506 }
15507 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15508 #[doc = r" Returns `None` if no values are dirty."]
15509 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15510 self.spider.pack_dirty()
15511 }
15512 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15513 pub fn pack_all(&self) -> Vec<DataValue> {
15514 self.spider.pack_all()
15515 }
15516 #[doc = r" Returns `true` if any field has been modified."]
15517 pub fn is_dirty(&self) -> bool {
15518 self.spider.is_dirty()
15519 }
15520}
15521impl Default for CaveSpiderEntityData {
15522 fn default() -> Self {
15523 Self::new()
15524 }
15525}
15526impl VanillaEntityData for CaveSpiderEntityData {
15527 fn base(&self) -> &BaseEntityData {
15528 CaveSpiderEntityData::base(self)
15529 }
15530 fn base_mut(&mut self) -> &mut BaseEntityData {
15531 CaveSpiderEntityData::base_mut(self)
15532 }
15533 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15534 CaveSpiderEntityData::pack_dirty(self)
15535 }
15536 fn pack_all(&self) -> Vec<DataValue> {
15537 CaveSpiderEntityData::pack_all(self)
15538 }
15539 fn is_dirty(&self) -> bool {
15540 CaveSpiderEntityData::is_dirty(self)
15541 }
15542}
15543impl VanillaLivingEntityData for CaveSpiderEntityData {
15544 fn living_entity(&self) -> &LivingEntityData {
15545 CaveSpiderEntityData::living_entity(self)
15546 }
15547 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
15548 CaveSpiderEntityData::living_entity_mut(self)
15549 }
15550}
15551#[doc = "Concrete synchronized entity data for vanilla entity `cherry_boat`."]
15552#[derive(Debug, Clone)]
15553pub struct CherryBoatEntityData {
15554 pub abstract_boat: AbstractBoatEntityData,
15555}
15556impl CherryBoatEntityData {
15557 #[doc = r" Create new entity data with default values."]
15558 pub fn new() -> Self {
15559 Self {
15560 abstract_boat: AbstractBoatEntityData::new(),
15561 }
15562 }
15563 #[doc = "Returns the `AbstractBoatEntityData` layer."]
15564 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
15565 &self.abstract_boat
15566 }
15567 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
15568 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
15569 &mut self.abstract_boat
15570 }
15571 #[doc = "Returns the `VehicleEntityData` layer."]
15572 pub fn vehicle_entity(&self) -> &VehicleEntityData {
15573 &self.abstract_boat.vehicle_entity
15574 }
15575 #[doc = "Returns the mutable `VehicleEntityData` layer."]
15576 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
15577 &mut self.abstract_boat.vehicle_entity
15578 }
15579 #[doc = "Returns the `BaseEntityData` layer."]
15580 pub fn base(&self) -> &BaseEntityData {
15581 &self.abstract_boat.vehicle_entity.base
15582 }
15583 #[doc = "Returns the mutable `BaseEntityData` layer."]
15584 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15585 &mut self.abstract_boat.vehicle_entity.base
15586 }
15587 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15588 #[doc = r" Returns `None` if no values are dirty."]
15589 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15590 self.abstract_boat.pack_dirty()
15591 }
15592 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15593 pub fn pack_all(&self) -> Vec<DataValue> {
15594 self.abstract_boat.pack_all()
15595 }
15596 #[doc = r" Returns `true` if any field has been modified."]
15597 pub fn is_dirty(&self) -> bool {
15598 self.abstract_boat.is_dirty()
15599 }
15600}
15601impl Default for CherryBoatEntityData {
15602 fn default() -> Self {
15603 Self::new()
15604 }
15605}
15606impl VanillaEntityData for CherryBoatEntityData {
15607 fn base(&self) -> &BaseEntityData {
15608 CherryBoatEntityData::base(self)
15609 }
15610 fn base_mut(&mut self) -> &mut BaseEntityData {
15611 CherryBoatEntityData::base_mut(self)
15612 }
15613 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15614 CherryBoatEntityData::pack_dirty(self)
15615 }
15616 fn pack_all(&self) -> Vec<DataValue> {
15617 CherryBoatEntityData::pack_all(self)
15618 }
15619 fn is_dirty(&self) -> bool {
15620 CherryBoatEntityData::is_dirty(self)
15621 }
15622}
15623#[doc = "Concrete synchronized entity data for vanilla entity `cherry_chest_boat`."]
15624#[derive(Debug, Clone)]
15625pub struct CherryChestBoatEntityData {
15626 pub abstract_boat: AbstractBoatEntityData,
15627}
15628impl CherryChestBoatEntityData {
15629 #[doc = r" Create new entity data with default values."]
15630 pub fn new() -> Self {
15631 Self {
15632 abstract_boat: AbstractBoatEntityData::new(),
15633 }
15634 }
15635 #[doc = "Returns the `AbstractBoatEntityData` layer."]
15636 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
15637 &self.abstract_boat
15638 }
15639 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
15640 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
15641 &mut self.abstract_boat
15642 }
15643 #[doc = "Returns the `VehicleEntityData` layer."]
15644 pub fn vehicle_entity(&self) -> &VehicleEntityData {
15645 &self.abstract_boat.vehicle_entity
15646 }
15647 #[doc = "Returns the mutable `VehicleEntityData` layer."]
15648 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
15649 &mut self.abstract_boat.vehicle_entity
15650 }
15651 #[doc = "Returns the `BaseEntityData` layer."]
15652 pub fn base(&self) -> &BaseEntityData {
15653 &self.abstract_boat.vehicle_entity.base
15654 }
15655 #[doc = "Returns the mutable `BaseEntityData` layer."]
15656 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15657 &mut self.abstract_boat.vehicle_entity.base
15658 }
15659 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15660 #[doc = r" Returns `None` if no values are dirty."]
15661 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15662 self.abstract_boat.pack_dirty()
15663 }
15664 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15665 pub fn pack_all(&self) -> Vec<DataValue> {
15666 self.abstract_boat.pack_all()
15667 }
15668 #[doc = r" Returns `true` if any field has been modified."]
15669 pub fn is_dirty(&self) -> bool {
15670 self.abstract_boat.is_dirty()
15671 }
15672}
15673impl Default for CherryChestBoatEntityData {
15674 fn default() -> Self {
15675 Self::new()
15676 }
15677}
15678impl VanillaEntityData for CherryChestBoatEntityData {
15679 fn base(&self) -> &BaseEntityData {
15680 CherryChestBoatEntityData::base(self)
15681 }
15682 fn base_mut(&mut self) -> &mut BaseEntityData {
15683 CherryChestBoatEntityData::base_mut(self)
15684 }
15685 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15686 CherryChestBoatEntityData::pack_dirty(self)
15687 }
15688 fn pack_all(&self) -> Vec<DataValue> {
15689 CherryChestBoatEntityData::pack_all(self)
15690 }
15691 fn is_dirty(&self) -> bool {
15692 CherryChestBoatEntityData::is_dirty(self)
15693 }
15694}
15695#[doc = "Concrete synchronized entity data for vanilla entity `chest_minecart`."]
15696#[derive(Debug, Clone)]
15697pub struct ChestMinecartEntityData {
15698 pub abstract_minecart: AbstractMinecartEntityData,
15699}
15700impl ChestMinecartEntityData {
15701 #[doc = r" Create new entity data with default values."]
15702 pub fn new() -> Self {
15703 Self {
15704 abstract_minecart: AbstractMinecartEntityData::new(),
15705 }
15706 }
15707 #[doc = "Returns the `AbstractMinecartEntityData` layer."]
15708 pub fn abstract_minecart(&self) -> &AbstractMinecartEntityData {
15709 &self.abstract_minecart
15710 }
15711 #[doc = "Returns the mutable `AbstractMinecartEntityData` layer."]
15712 pub fn abstract_minecart_mut(&mut self) -> &mut AbstractMinecartEntityData {
15713 &mut self.abstract_minecart
15714 }
15715 #[doc = "Returns the `VehicleEntityData` layer."]
15716 pub fn vehicle_entity(&self) -> &VehicleEntityData {
15717 &self.abstract_minecart.vehicle_entity
15718 }
15719 #[doc = "Returns the mutable `VehicleEntityData` layer."]
15720 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
15721 &mut self.abstract_minecart.vehicle_entity
15722 }
15723 #[doc = "Returns the `BaseEntityData` layer."]
15724 pub fn base(&self) -> &BaseEntityData {
15725 &self.abstract_minecart.vehicle_entity.base
15726 }
15727 #[doc = "Returns the mutable `BaseEntityData` layer."]
15728 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15729 &mut self.abstract_minecart.vehicle_entity.base
15730 }
15731 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15732 #[doc = r" Returns `None` if no values are dirty."]
15733 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15734 self.abstract_minecart.pack_dirty()
15735 }
15736 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15737 pub fn pack_all(&self) -> Vec<DataValue> {
15738 self.abstract_minecart.pack_all()
15739 }
15740 #[doc = r" Returns `true` if any field has been modified."]
15741 pub fn is_dirty(&self) -> bool {
15742 self.abstract_minecart.is_dirty()
15743 }
15744}
15745impl Default for ChestMinecartEntityData {
15746 fn default() -> Self {
15747 Self::new()
15748 }
15749}
15750impl VanillaEntityData for ChestMinecartEntityData {
15751 fn base(&self) -> &BaseEntityData {
15752 ChestMinecartEntityData::base(self)
15753 }
15754 fn base_mut(&mut self) -> &mut BaseEntityData {
15755 ChestMinecartEntityData::base_mut(self)
15756 }
15757 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15758 ChestMinecartEntityData::pack_dirty(self)
15759 }
15760 fn pack_all(&self) -> Vec<DataValue> {
15761 ChestMinecartEntityData::pack_all(self)
15762 }
15763 fn is_dirty(&self) -> bool {
15764 ChestMinecartEntityData::is_dirty(self)
15765 }
15766}
15767#[doc = "Concrete synchronized entity data for vanilla entity `cod`."]
15768#[derive(Debug, Clone)]
15769pub struct CodEntityData {
15770 pub abstract_fish: AbstractFishEntityData,
15771}
15772impl CodEntityData {
15773 #[doc = r" Create new entity data with default values."]
15774 pub fn new() -> Self {
15775 Self {
15776 abstract_fish: AbstractFishEntityData::new(),
15777 }
15778 }
15779 #[doc = "Returns the `AbstractFishEntityData` layer."]
15780 pub fn abstract_fish(&self) -> &AbstractFishEntityData {
15781 &self.abstract_fish
15782 }
15783 #[doc = "Returns the mutable `AbstractFishEntityData` layer."]
15784 pub fn abstract_fish_mut(&mut self) -> &mut AbstractFishEntityData {
15785 &mut self.abstract_fish
15786 }
15787 #[doc = "Returns the `MobEntityData` layer."]
15788 pub fn mob(&self) -> &MobEntityData {
15789 &self.abstract_fish.mob
15790 }
15791 #[doc = "Returns the mutable `MobEntityData` layer."]
15792 pub fn mob_mut(&mut self) -> &mut MobEntityData {
15793 &mut self.abstract_fish.mob
15794 }
15795 #[doc = "Returns the `LivingEntityData` layer."]
15796 pub fn living_entity(&self) -> &LivingEntityData {
15797 &self.abstract_fish.mob.living_entity
15798 }
15799 #[doc = "Returns the mutable `LivingEntityData` layer."]
15800 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
15801 &mut self.abstract_fish.mob.living_entity
15802 }
15803 #[doc = "Returns the `BaseEntityData` layer."]
15804 pub fn base(&self) -> &BaseEntityData {
15805 &self.abstract_fish.mob.living_entity.base
15806 }
15807 #[doc = "Returns the mutable `BaseEntityData` layer."]
15808 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15809 &mut self.abstract_fish.mob.living_entity.base
15810 }
15811 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15812 #[doc = r" Returns `None` if no values are dirty."]
15813 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15814 self.abstract_fish.pack_dirty()
15815 }
15816 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15817 pub fn pack_all(&self) -> Vec<DataValue> {
15818 self.abstract_fish.pack_all()
15819 }
15820 #[doc = r" Returns `true` if any field has been modified."]
15821 pub fn is_dirty(&self) -> bool {
15822 self.abstract_fish.is_dirty()
15823 }
15824}
15825impl Default for CodEntityData {
15826 fn default() -> Self {
15827 Self::new()
15828 }
15829}
15830impl VanillaEntityData for CodEntityData {
15831 fn base(&self) -> &BaseEntityData {
15832 CodEntityData::base(self)
15833 }
15834 fn base_mut(&mut self) -> &mut BaseEntityData {
15835 CodEntityData::base_mut(self)
15836 }
15837 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15838 CodEntityData::pack_dirty(self)
15839 }
15840 fn pack_all(&self) -> Vec<DataValue> {
15841 CodEntityData::pack_all(self)
15842 }
15843 fn is_dirty(&self) -> bool {
15844 CodEntityData::is_dirty(self)
15845 }
15846}
15847impl VanillaLivingEntityData for CodEntityData {
15848 fn living_entity(&self) -> &LivingEntityData {
15849 CodEntityData::living_entity(self)
15850 }
15851 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
15852 CodEntityData::living_entity_mut(self)
15853 }
15854}
15855#[doc = "Concrete synchronized entity data for vanilla entity `command_block_minecart`."]
15856#[derive(Debug, Clone)]
15857pub struct CommandBlockMinecartEntityData {
15858 pub minecart_command_block: MinecartCommandBlockEntityData,
15859}
15860impl CommandBlockMinecartEntityData {
15861 #[doc = r" Create new entity data with default values."]
15862 pub fn new() -> Self {
15863 let mut data = MinecartCommandBlockEntityData::new();
15864 data.abstract_minecart.id_display_offset = SyncedValue::new(6i32);
15865 Self {
15866 minecart_command_block: data,
15867 }
15868 }
15869 #[doc = "Returns the `MinecartCommandBlockEntityData` layer."]
15870 pub fn minecart_command_block(&self) -> &MinecartCommandBlockEntityData {
15871 &self.minecart_command_block
15872 }
15873 #[doc = "Returns the mutable `MinecartCommandBlockEntityData` layer."]
15874 pub fn minecart_command_block_mut(&mut self) -> &mut MinecartCommandBlockEntityData {
15875 &mut self.minecart_command_block
15876 }
15877 #[doc = "Returns the `AbstractMinecartEntityData` layer."]
15878 pub fn abstract_minecart(&self) -> &AbstractMinecartEntityData {
15879 &self.minecart_command_block.abstract_minecart
15880 }
15881 #[doc = "Returns the mutable `AbstractMinecartEntityData` layer."]
15882 pub fn abstract_minecart_mut(&mut self) -> &mut AbstractMinecartEntityData {
15883 &mut self.minecart_command_block.abstract_minecart
15884 }
15885 #[doc = "Returns the `VehicleEntityData` layer."]
15886 pub fn vehicle_entity(&self) -> &VehicleEntityData {
15887 &self.minecart_command_block.abstract_minecart.vehicle_entity
15888 }
15889 #[doc = "Returns the mutable `VehicleEntityData` layer."]
15890 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
15891 &mut self.minecart_command_block.abstract_minecart.vehicle_entity
15892 }
15893 #[doc = "Returns the `BaseEntityData` layer."]
15894 pub fn base(&self) -> &BaseEntityData {
15895 &self
15896 .minecart_command_block
15897 .abstract_minecart
15898 .vehicle_entity
15899 .base
15900 }
15901 #[doc = "Returns the mutable `BaseEntityData` layer."]
15902 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15903 &mut self
15904 .minecart_command_block
15905 .abstract_minecart
15906 .vehicle_entity
15907 .base
15908 }
15909 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15910 #[doc = r" Returns `None` if no values are dirty."]
15911 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15912 self.minecart_command_block.pack_dirty()
15913 }
15914 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15915 pub fn pack_all(&self) -> Vec<DataValue> {
15916 self.minecart_command_block.pack_all()
15917 }
15918 #[doc = r" Returns `true` if any field has been modified."]
15919 pub fn is_dirty(&self) -> bool {
15920 self.minecart_command_block.is_dirty()
15921 }
15922}
15923impl Default for CommandBlockMinecartEntityData {
15924 fn default() -> Self {
15925 Self::new()
15926 }
15927}
15928impl VanillaEntityData for CommandBlockMinecartEntityData {
15929 fn base(&self) -> &BaseEntityData {
15930 CommandBlockMinecartEntityData::base(self)
15931 }
15932 fn base_mut(&mut self) -> &mut BaseEntityData {
15933 CommandBlockMinecartEntityData::base_mut(self)
15934 }
15935 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15936 CommandBlockMinecartEntityData::pack_dirty(self)
15937 }
15938 fn pack_all(&self) -> Vec<DataValue> {
15939 CommandBlockMinecartEntityData::pack_all(self)
15940 }
15941 fn is_dirty(&self) -> bool {
15942 CommandBlockMinecartEntityData::is_dirty(self)
15943 }
15944}
15945#[doc = "Concrete synchronized entity data for vanilla entity `dark_oak_boat`."]
15946#[derive(Debug, Clone)]
15947pub struct DarkOakBoatEntityData {
15948 pub abstract_boat: AbstractBoatEntityData,
15949}
15950impl DarkOakBoatEntityData {
15951 #[doc = r" Create new entity data with default values."]
15952 pub fn new() -> Self {
15953 Self {
15954 abstract_boat: AbstractBoatEntityData::new(),
15955 }
15956 }
15957 #[doc = "Returns the `AbstractBoatEntityData` layer."]
15958 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
15959 &self.abstract_boat
15960 }
15961 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
15962 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
15963 &mut self.abstract_boat
15964 }
15965 #[doc = "Returns the `VehicleEntityData` layer."]
15966 pub fn vehicle_entity(&self) -> &VehicleEntityData {
15967 &self.abstract_boat.vehicle_entity
15968 }
15969 #[doc = "Returns the mutable `VehicleEntityData` layer."]
15970 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
15971 &mut self.abstract_boat.vehicle_entity
15972 }
15973 #[doc = "Returns the `BaseEntityData` layer."]
15974 pub fn base(&self) -> &BaseEntityData {
15975 &self.abstract_boat.vehicle_entity.base
15976 }
15977 #[doc = "Returns the mutable `BaseEntityData` layer."]
15978 pub fn base_mut(&mut self) -> &mut BaseEntityData {
15979 &mut self.abstract_boat.vehicle_entity.base
15980 }
15981 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
15982 #[doc = r" Returns `None` if no values are dirty."]
15983 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
15984 self.abstract_boat.pack_dirty()
15985 }
15986 #[doc = r" Pack all non-default values (for initial entity spawn)."]
15987 pub fn pack_all(&self) -> Vec<DataValue> {
15988 self.abstract_boat.pack_all()
15989 }
15990 #[doc = r" Returns `true` if any field has been modified."]
15991 pub fn is_dirty(&self) -> bool {
15992 self.abstract_boat.is_dirty()
15993 }
15994}
15995impl Default for DarkOakBoatEntityData {
15996 fn default() -> Self {
15997 Self::new()
15998 }
15999}
16000impl VanillaEntityData for DarkOakBoatEntityData {
16001 fn base(&self) -> &BaseEntityData {
16002 DarkOakBoatEntityData::base(self)
16003 }
16004 fn base_mut(&mut self) -> &mut BaseEntityData {
16005 DarkOakBoatEntityData::base_mut(self)
16006 }
16007 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16008 DarkOakBoatEntityData::pack_dirty(self)
16009 }
16010 fn pack_all(&self) -> Vec<DataValue> {
16011 DarkOakBoatEntityData::pack_all(self)
16012 }
16013 fn is_dirty(&self) -> bool {
16014 DarkOakBoatEntityData::is_dirty(self)
16015 }
16016}
16017#[doc = "Concrete synchronized entity data for vanilla entity `dark_oak_chest_boat`."]
16018#[derive(Debug, Clone)]
16019pub struct DarkOakChestBoatEntityData {
16020 pub abstract_boat: AbstractBoatEntityData,
16021}
16022impl DarkOakChestBoatEntityData {
16023 #[doc = r" Create new entity data with default values."]
16024 pub fn new() -> Self {
16025 Self {
16026 abstract_boat: AbstractBoatEntityData::new(),
16027 }
16028 }
16029 #[doc = "Returns the `AbstractBoatEntityData` layer."]
16030 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
16031 &self.abstract_boat
16032 }
16033 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
16034 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
16035 &mut self.abstract_boat
16036 }
16037 #[doc = "Returns the `VehicleEntityData` layer."]
16038 pub fn vehicle_entity(&self) -> &VehicleEntityData {
16039 &self.abstract_boat.vehicle_entity
16040 }
16041 #[doc = "Returns the mutable `VehicleEntityData` layer."]
16042 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
16043 &mut self.abstract_boat.vehicle_entity
16044 }
16045 #[doc = "Returns the `BaseEntityData` layer."]
16046 pub fn base(&self) -> &BaseEntityData {
16047 &self.abstract_boat.vehicle_entity.base
16048 }
16049 #[doc = "Returns the mutable `BaseEntityData` layer."]
16050 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16051 &mut self.abstract_boat.vehicle_entity.base
16052 }
16053 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16054 #[doc = r" Returns `None` if no values are dirty."]
16055 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16056 self.abstract_boat.pack_dirty()
16057 }
16058 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16059 pub fn pack_all(&self) -> Vec<DataValue> {
16060 self.abstract_boat.pack_all()
16061 }
16062 #[doc = r" Returns `true` if any field has been modified."]
16063 pub fn is_dirty(&self) -> bool {
16064 self.abstract_boat.is_dirty()
16065 }
16066}
16067impl Default for DarkOakChestBoatEntityData {
16068 fn default() -> Self {
16069 Self::new()
16070 }
16071}
16072impl VanillaEntityData for DarkOakChestBoatEntityData {
16073 fn base(&self) -> &BaseEntityData {
16074 DarkOakChestBoatEntityData::base(self)
16075 }
16076 fn base_mut(&mut self) -> &mut BaseEntityData {
16077 DarkOakChestBoatEntityData::base_mut(self)
16078 }
16079 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16080 DarkOakChestBoatEntityData::pack_dirty(self)
16081 }
16082 fn pack_all(&self) -> Vec<DataValue> {
16083 DarkOakChestBoatEntityData::pack_all(self)
16084 }
16085 fn is_dirty(&self) -> bool {
16086 DarkOakChestBoatEntityData::is_dirty(self)
16087 }
16088}
16089#[doc = "Concrete synchronized entity data for vanilla entity `donkey`."]
16090#[derive(Debug, Clone)]
16091pub struct DonkeyEntityData {
16092 pub abstract_chested_horse: AbstractChestedHorseEntityData,
16093}
16094impl DonkeyEntityData {
16095 #[doc = r" Create new entity data with default values."]
16096 pub fn new() -> Self {
16097 Self {
16098 abstract_chested_horse: AbstractChestedHorseEntityData::new(),
16099 }
16100 }
16101 #[doc = "Returns the `AbstractChestedHorseEntityData` layer."]
16102 pub fn abstract_chested_horse(&self) -> &AbstractChestedHorseEntityData {
16103 &self.abstract_chested_horse
16104 }
16105 #[doc = "Returns the mutable `AbstractChestedHorseEntityData` layer."]
16106 pub fn abstract_chested_horse_mut(&mut self) -> &mut AbstractChestedHorseEntityData {
16107 &mut self.abstract_chested_horse
16108 }
16109 #[doc = "Returns the `AbstractHorseEntityData` layer."]
16110 pub fn abstract_horse(&self) -> &AbstractHorseEntityData {
16111 &self.abstract_chested_horse.abstract_horse
16112 }
16113 #[doc = "Returns the mutable `AbstractHorseEntityData` layer."]
16114 pub fn abstract_horse_mut(&mut self) -> &mut AbstractHorseEntityData {
16115 &mut self.abstract_chested_horse.abstract_horse
16116 }
16117 #[doc = "Returns the `AgeableMobEntityData` layer."]
16118 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
16119 &self.abstract_chested_horse.abstract_horse.ageable_mob
16120 }
16121 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
16122 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
16123 &mut self.abstract_chested_horse.abstract_horse.ageable_mob
16124 }
16125 #[doc = "Returns the `MobEntityData` layer."]
16126 pub fn mob(&self) -> &MobEntityData {
16127 &self.abstract_chested_horse.abstract_horse.ageable_mob.mob
16128 }
16129 #[doc = "Returns the mutable `MobEntityData` layer."]
16130 pub fn mob_mut(&mut self) -> &mut MobEntityData {
16131 &mut self.abstract_chested_horse.abstract_horse.ageable_mob.mob
16132 }
16133 #[doc = "Returns the `LivingEntityData` layer."]
16134 pub fn living_entity(&self) -> &LivingEntityData {
16135 &self
16136 .abstract_chested_horse
16137 .abstract_horse
16138 .ageable_mob
16139 .mob
16140 .living_entity
16141 }
16142 #[doc = "Returns the mutable `LivingEntityData` layer."]
16143 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16144 &mut self
16145 .abstract_chested_horse
16146 .abstract_horse
16147 .ageable_mob
16148 .mob
16149 .living_entity
16150 }
16151 #[doc = "Returns the `BaseEntityData` layer."]
16152 pub fn base(&self) -> &BaseEntityData {
16153 &self
16154 .abstract_chested_horse
16155 .abstract_horse
16156 .ageable_mob
16157 .mob
16158 .living_entity
16159 .base
16160 }
16161 #[doc = "Returns the mutable `BaseEntityData` layer."]
16162 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16163 &mut self
16164 .abstract_chested_horse
16165 .abstract_horse
16166 .ageable_mob
16167 .mob
16168 .living_entity
16169 .base
16170 }
16171 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16172 #[doc = r" Returns `None` if no values are dirty."]
16173 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16174 self.abstract_chested_horse.pack_dirty()
16175 }
16176 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16177 pub fn pack_all(&self) -> Vec<DataValue> {
16178 self.abstract_chested_horse.pack_all()
16179 }
16180 #[doc = r" Returns `true` if any field has been modified."]
16181 pub fn is_dirty(&self) -> bool {
16182 self.abstract_chested_horse.is_dirty()
16183 }
16184}
16185impl Default for DonkeyEntityData {
16186 fn default() -> Self {
16187 Self::new()
16188 }
16189}
16190impl VanillaEntityData for DonkeyEntityData {
16191 fn base(&self) -> &BaseEntityData {
16192 DonkeyEntityData::base(self)
16193 }
16194 fn base_mut(&mut self) -> &mut BaseEntityData {
16195 DonkeyEntityData::base_mut(self)
16196 }
16197 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16198 DonkeyEntityData::pack_dirty(self)
16199 }
16200 fn pack_all(&self) -> Vec<DataValue> {
16201 DonkeyEntityData::pack_all(self)
16202 }
16203 fn is_dirty(&self) -> bool {
16204 DonkeyEntityData::is_dirty(self)
16205 }
16206}
16207impl VanillaLivingEntityData for DonkeyEntityData {
16208 fn living_entity(&self) -> &LivingEntityData {
16209 DonkeyEntityData::living_entity(self)
16210 }
16211 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16212 DonkeyEntityData::living_entity_mut(self)
16213 }
16214}
16215#[doc = "Concrete synchronized entity data for vanilla entity `dragon_fireball`."]
16216#[derive(Debug, Clone)]
16217pub struct DragonFireballEntityData {
16218 pub base: BaseEntityData,
16219}
16220impl DragonFireballEntityData {
16221 #[doc = r" Create new entity data with default values."]
16222 pub fn new() -> Self {
16223 Self {
16224 base: BaseEntityData::new(),
16225 }
16226 }
16227 #[doc = "Returns the `BaseEntityData` layer."]
16228 pub fn base(&self) -> &BaseEntityData {
16229 &self.base
16230 }
16231 #[doc = "Returns the mutable `BaseEntityData` layer."]
16232 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16233 &mut self.base
16234 }
16235 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16236 #[doc = r" Returns `None` if no values are dirty."]
16237 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16238 self.base.pack_dirty()
16239 }
16240 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16241 pub fn pack_all(&self) -> Vec<DataValue> {
16242 self.base.pack_all()
16243 }
16244 #[doc = r" Returns `true` if any field has been modified."]
16245 pub fn is_dirty(&self) -> bool {
16246 self.base.is_dirty()
16247 }
16248}
16249impl Default for DragonFireballEntityData {
16250 fn default() -> Self {
16251 Self::new()
16252 }
16253}
16254impl VanillaEntityData for DragonFireballEntityData {
16255 fn base(&self) -> &BaseEntityData {
16256 DragonFireballEntityData::base(self)
16257 }
16258 fn base_mut(&mut self) -> &mut BaseEntityData {
16259 DragonFireballEntityData::base_mut(self)
16260 }
16261 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16262 DragonFireballEntityData::pack_dirty(self)
16263 }
16264 fn pack_all(&self) -> Vec<DataValue> {
16265 DragonFireballEntityData::pack_all(self)
16266 }
16267 fn is_dirty(&self) -> bool {
16268 DragonFireballEntityData::is_dirty(self)
16269 }
16270}
16271#[doc = "Concrete synchronized entity data for vanilla entity `drowned`."]
16272#[derive(Debug, Clone)]
16273pub struct DrownedEntityData {
16274 pub zombie: ZombieEntityData,
16275}
16276impl DrownedEntityData {
16277 #[doc = r" Create new entity data with default values."]
16278 pub fn new() -> Self {
16279 Self {
16280 zombie: ZombieEntityData::new(),
16281 }
16282 }
16283 #[doc = "Returns the `ZombieEntityData` layer."]
16284 pub fn zombie(&self) -> &ZombieEntityData {
16285 &self.zombie
16286 }
16287 #[doc = "Returns the mutable `ZombieEntityData` layer."]
16288 pub fn zombie_mut(&mut self) -> &mut ZombieEntityData {
16289 &mut self.zombie
16290 }
16291 #[doc = "Returns the `MobEntityData` layer."]
16292 pub fn mob(&self) -> &MobEntityData {
16293 &self.zombie.mob
16294 }
16295 #[doc = "Returns the mutable `MobEntityData` layer."]
16296 pub fn mob_mut(&mut self) -> &mut MobEntityData {
16297 &mut self.zombie.mob
16298 }
16299 #[doc = "Returns the `LivingEntityData` layer."]
16300 pub fn living_entity(&self) -> &LivingEntityData {
16301 &self.zombie.mob.living_entity
16302 }
16303 #[doc = "Returns the mutable `LivingEntityData` layer."]
16304 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16305 &mut self.zombie.mob.living_entity
16306 }
16307 #[doc = "Returns the `BaseEntityData` layer."]
16308 pub fn base(&self) -> &BaseEntityData {
16309 &self.zombie.mob.living_entity.base
16310 }
16311 #[doc = "Returns the mutable `BaseEntityData` layer."]
16312 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16313 &mut self.zombie.mob.living_entity.base
16314 }
16315 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16316 #[doc = r" Returns `None` if no values are dirty."]
16317 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16318 self.zombie.pack_dirty()
16319 }
16320 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16321 pub fn pack_all(&self) -> Vec<DataValue> {
16322 self.zombie.pack_all()
16323 }
16324 #[doc = r" Returns `true` if any field has been modified."]
16325 pub fn is_dirty(&self) -> bool {
16326 self.zombie.is_dirty()
16327 }
16328}
16329impl Default for DrownedEntityData {
16330 fn default() -> Self {
16331 Self::new()
16332 }
16333}
16334impl VanillaEntityData for DrownedEntityData {
16335 fn base(&self) -> &BaseEntityData {
16336 DrownedEntityData::base(self)
16337 }
16338 fn base_mut(&mut self) -> &mut BaseEntityData {
16339 DrownedEntityData::base_mut(self)
16340 }
16341 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16342 DrownedEntityData::pack_dirty(self)
16343 }
16344 fn pack_all(&self) -> Vec<DataValue> {
16345 DrownedEntityData::pack_all(self)
16346 }
16347 fn is_dirty(&self) -> bool {
16348 DrownedEntityData::is_dirty(self)
16349 }
16350}
16351impl VanillaLivingEntityData for DrownedEntityData {
16352 fn living_entity(&self) -> &LivingEntityData {
16353 DrownedEntityData::living_entity(self)
16354 }
16355 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16356 DrownedEntityData::living_entity_mut(self)
16357 }
16358}
16359#[doc = "Concrete synchronized entity data for vanilla entity `egg`."]
16360#[derive(Debug, Clone)]
16361pub struct EggEntityData {
16362 pub throwable_item_projectile: ThrowableItemProjectileEntityData,
16363}
16364impl EggEntityData {
16365 #[doc = r" Create new entity data with default values."]
16366 pub fn new() -> Self {
16367 Self {
16368 throwable_item_projectile: ThrowableItemProjectileEntityData::new(),
16369 }
16370 }
16371 #[doc = "Returns the `ThrowableItemProjectileEntityData` layer."]
16372 pub fn throwable_item_projectile(&self) -> &ThrowableItemProjectileEntityData {
16373 &self.throwable_item_projectile
16374 }
16375 #[doc = "Returns the mutable `ThrowableItemProjectileEntityData` layer."]
16376 pub fn throwable_item_projectile_mut(&mut self) -> &mut ThrowableItemProjectileEntityData {
16377 &mut self.throwable_item_projectile
16378 }
16379 #[doc = "Returns the `BaseEntityData` layer."]
16380 pub fn base(&self) -> &BaseEntityData {
16381 &self.throwable_item_projectile.base
16382 }
16383 #[doc = "Returns the mutable `BaseEntityData` layer."]
16384 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16385 &mut self.throwable_item_projectile.base
16386 }
16387 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16388 #[doc = r" Returns `None` if no values are dirty."]
16389 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16390 self.throwable_item_projectile.pack_dirty()
16391 }
16392 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16393 pub fn pack_all(&self) -> Vec<DataValue> {
16394 self.throwable_item_projectile.pack_all()
16395 }
16396 #[doc = r" Returns `true` if any field has been modified."]
16397 pub fn is_dirty(&self) -> bool {
16398 self.throwable_item_projectile.is_dirty()
16399 }
16400}
16401impl Default for EggEntityData {
16402 fn default() -> Self {
16403 Self::new()
16404 }
16405}
16406impl VanillaEntityData for EggEntityData {
16407 fn base(&self) -> &BaseEntityData {
16408 EggEntityData::base(self)
16409 }
16410 fn base_mut(&mut self) -> &mut BaseEntityData {
16411 EggEntityData::base_mut(self)
16412 }
16413 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16414 EggEntityData::pack_dirty(self)
16415 }
16416 fn pack_all(&self) -> Vec<DataValue> {
16417 EggEntityData::pack_all(self)
16418 }
16419 fn is_dirty(&self) -> bool {
16420 EggEntityData::is_dirty(self)
16421 }
16422}
16423#[doc = "Concrete synchronized entity data for vanilla entity `elder_guardian`."]
16424#[derive(Debug, Clone)]
16425pub struct ElderGuardianEntityData {
16426 pub guardian: GuardianEntityData,
16427}
16428impl ElderGuardianEntityData {
16429 #[doc = r" Create new entity data with default values."]
16430 pub fn new() -> Self {
16431 Self {
16432 guardian: GuardianEntityData::new(),
16433 }
16434 }
16435 #[doc = "Returns the `GuardianEntityData` layer."]
16436 pub fn guardian(&self) -> &GuardianEntityData {
16437 &self.guardian
16438 }
16439 #[doc = "Returns the mutable `GuardianEntityData` layer."]
16440 pub fn guardian_mut(&mut self) -> &mut GuardianEntityData {
16441 &mut self.guardian
16442 }
16443 #[doc = "Returns the `MobEntityData` layer."]
16444 pub fn mob(&self) -> &MobEntityData {
16445 &self.guardian.mob
16446 }
16447 #[doc = "Returns the mutable `MobEntityData` layer."]
16448 pub fn mob_mut(&mut self) -> &mut MobEntityData {
16449 &mut self.guardian.mob
16450 }
16451 #[doc = "Returns the `LivingEntityData` layer."]
16452 pub fn living_entity(&self) -> &LivingEntityData {
16453 &self.guardian.mob.living_entity
16454 }
16455 #[doc = "Returns the mutable `LivingEntityData` layer."]
16456 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16457 &mut self.guardian.mob.living_entity
16458 }
16459 #[doc = "Returns the `BaseEntityData` layer."]
16460 pub fn base(&self) -> &BaseEntityData {
16461 &self.guardian.mob.living_entity.base
16462 }
16463 #[doc = "Returns the mutable `BaseEntityData` layer."]
16464 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16465 &mut self.guardian.mob.living_entity.base
16466 }
16467 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16468 #[doc = r" Returns `None` if no values are dirty."]
16469 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16470 self.guardian.pack_dirty()
16471 }
16472 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16473 pub fn pack_all(&self) -> Vec<DataValue> {
16474 self.guardian.pack_all()
16475 }
16476 #[doc = r" Returns `true` if any field has been modified."]
16477 pub fn is_dirty(&self) -> bool {
16478 self.guardian.is_dirty()
16479 }
16480}
16481impl Default for ElderGuardianEntityData {
16482 fn default() -> Self {
16483 Self::new()
16484 }
16485}
16486impl VanillaEntityData for ElderGuardianEntityData {
16487 fn base(&self) -> &BaseEntityData {
16488 ElderGuardianEntityData::base(self)
16489 }
16490 fn base_mut(&mut self) -> &mut BaseEntityData {
16491 ElderGuardianEntityData::base_mut(self)
16492 }
16493 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16494 ElderGuardianEntityData::pack_dirty(self)
16495 }
16496 fn pack_all(&self) -> Vec<DataValue> {
16497 ElderGuardianEntityData::pack_all(self)
16498 }
16499 fn is_dirty(&self) -> bool {
16500 ElderGuardianEntityData::is_dirty(self)
16501 }
16502}
16503impl VanillaLivingEntityData for ElderGuardianEntityData {
16504 fn living_entity(&self) -> &LivingEntityData {
16505 ElderGuardianEntityData::living_entity(self)
16506 }
16507 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16508 ElderGuardianEntityData::living_entity_mut(self)
16509 }
16510}
16511#[doc = "Concrete synchronized entity data for vanilla entity `enderman`."]
16512#[derive(Debug, Clone)]
16513pub struct EndermanEntityData {
16514 pub ender_man: EnderManEntityData,
16515}
16516impl EndermanEntityData {
16517 #[doc = r" Create new entity data with default values."]
16518 pub fn new() -> Self {
16519 Self {
16520 ender_man: EnderManEntityData::new(),
16521 }
16522 }
16523 #[doc = "Returns the `EnderManEntityData` layer."]
16524 pub fn ender_man(&self) -> &EnderManEntityData {
16525 &self.ender_man
16526 }
16527 #[doc = "Returns the mutable `EnderManEntityData` layer."]
16528 pub fn ender_man_mut(&mut self) -> &mut EnderManEntityData {
16529 &mut self.ender_man
16530 }
16531 #[doc = "Returns the `MobEntityData` layer."]
16532 pub fn mob(&self) -> &MobEntityData {
16533 &self.ender_man.mob
16534 }
16535 #[doc = "Returns the mutable `MobEntityData` layer."]
16536 pub fn mob_mut(&mut self) -> &mut MobEntityData {
16537 &mut self.ender_man.mob
16538 }
16539 #[doc = "Returns the `LivingEntityData` layer."]
16540 pub fn living_entity(&self) -> &LivingEntityData {
16541 &self.ender_man.mob.living_entity
16542 }
16543 #[doc = "Returns the mutable `LivingEntityData` layer."]
16544 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16545 &mut self.ender_man.mob.living_entity
16546 }
16547 #[doc = "Returns the `BaseEntityData` layer."]
16548 pub fn base(&self) -> &BaseEntityData {
16549 &self.ender_man.mob.living_entity.base
16550 }
16551 #[doc = "Returns the mutable `BaseEntityData` layer."]
16552 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16553 &mut self.ender_man.mob.living_entity.base
16554 }
16555 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16556 #[doc = r" Returns `None` if no values are dirty."]
16557 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16558 self.ender_man.pack_dirty()
16559 }
16560 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16561 pub fn pack_all(&self) -> Vec<DataValue> {
16562 self.ender_man.pack_all()
16563 }
16564 #[doc = r" Returns `true` if any field has been modified."]
16565 pub fn is_dirty(&self) -> bool {
16566 self.ender_man.is_dirty()
16567 }
16568}
16569impl Default for EndermanEntityData {
16570 fn default() -> Self {
16571 Self::new()
16572 }
16573}
16574impl VanillaEntityData for EndermanEntityData {
16575 fn base(&self) -> &BaseEntityData {
16576 EndermanEntityData::base(self)
16577 }
16578 fn base_mut(&mut self) -> &mut BaseEntityData {
16579 EndermanEntityData::base_mut(self)
16580 }
16581 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16582 EndermanEntityData::pack_dirty(self)
16583 }
16584 fn pack_all(&self) -> Vec<DataValue> {
16585 EndermanEntityData::pack_all(self)
16586 }
16587 fn is_dirty(&self) -> bool {
16588 EndermanEntityData::is_dirty(self)
16589 }
16590}
16591impl VanillaLivingEntityData for EndermanEntityData {
16592 fn living_entity(&self) -> &LivingEntityData {
16593 EndermanEntityData::living_entity(self)
16594 }
16595 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16596 EndermanEntityData::living_entity_mut(self)
16597 }
16598}
16599#[doc = "Concrete synchronized entity data for vanilla entity `endermite`."]
16600#[derive(Debug, Clone)]
16601pub struct EndermiteEntityData {
16602 pub mob: MobEntityData,
16603}
16604impl EndermiteEntityData {
16605 #[doc = r" Create new entity data with default values."]
16606 pub fn new() -> Self {
16607 Self {
16608 mob: MobEntityData::new(),
16609 }
16610 }
16611 #[doc = "Returns the `MobEntityData` layer."]
16612 pub fn mob(&self) -> &MobEntityData {
16613 &self.mob
16614 }
16615 #[doc = "Returns the mutable `MobEntityData` layer."]
16616 pub fn mob_mut(&mut self) -> &mut MobEntityData {
16617 &mut self.mob
16618 }
16619 #[doc = "Returns the `LivingEntityData` layer."]
16620 pub fn living_entity(&self) -> &LivingEntityData {
16621 &self.mob.living_entity
16622 }
16623 #[doc = "Returns the mutable `LivingEntityData` layer."]
16624 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16625 &mut self.mob.living_entity
16626 }
16627 #[doc = "Returns the `BaseEntityData` layer."]
16628 pub fn base(&self) -> &BaseEntityData {
16629 &self.mob.living_entity.base
16630 }
16631 #[doc = "Returns the mutable `BaseEntityData` layer."]
16632 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16633 &mut self.mob.living_entity.base
16634 }
16635 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16636 #[doc = r" Returns `None` if no values are dirty."]
16637 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16638 self.mob.pack_dirty()
16639 }
16640 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16641 pub fn pack_all(&self) -> Vec<DataValue> {
16642 self.mob.pack_all()
16643 }
16644 #[doc = r" Returns `true` if any field has been modified."]
16645 pub fn is_dirty(&self) -> bool {
16646 self.mob.is_dirty()
16647 }
16648}
16649impl Default for EndermiteEntityData {
16650 fn default() -> Self {
16651 Self::new()
16652 }
16653}
16654impl VanillaEntityData for EndermiteEntityData {
16655 fn base(&self) -> &BaseEntityData {
16656 EndermiteEntityData::base(self)
16657 }
16658 fn base_mut(&mut self) -> &mut BaseEntityData {
16659 EndermiteEntityData::base_mut(self)
16660 }
16661 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16662 EndermiteEntityData::pack_dirty(self)
16663 }
16664 fn pack_all(&self) -> Vec<DataValue> {
16665 EndermiteEntityData::pack_all(self)
16666 }
16667 fn is_dirty(&self) -> bool {
16668 EndermiteEntityData::is_dirty(self)
16669 }
16670}
16671impl VanillaLivingEntityData for EndermiteEntityData {
16672 fn living_entity(&self) -> &LivingEntityData {
16673 EndermiteEntityData::living_entity(self)
16674 }
16675 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16676 EndermiteEntityData::living_entity_mut(self)
16677 }
16678}
16679#[doc = "Concrete synchronized entity data for vanilla entity `ender_pearl`."]
16680#[derive(Debug, Clone)]
16681pub struct EnderPearlEntityData {
16682 pub throwable_item_projectile: ThrowableItemProjectileEntityData,
16683}
16684impl EnderPearlEntityData {
16685 #[doc = r" Create new entity data with default values."]
16686 pub fn new() -> Self {
16687 let mut data = ThrowableItemProjectileEntityData::new();
16688 data.item_stack = SyncedValue::new(ItemStack::with_count(
16689 &crate::vanilla_items::ITEMS.ender_pearl,
16690 1i32,
16691 ));
16692 Self {
16693 throwable_item_projectile: data,
16694 }
16695 }
16696 #[doc = "Returns the `ThrowableItemProjectileEntityData` layer."]
16697 pub fn throwable_item_projectile(&self) -> &ThrowableItemProjectileEntityData {
16698 &self.throwable_item_projectile
16699 }
16700 #[doc = "Returns the mutable `ThrowableItemProjectileEntityData` layer."]
16701 pub fn throwable_item_projectile_mut(&mut self) -> &mut ThrowableItemProjectileEntityData {
16702 &mut self.throwable_item_projectile
16703 }
16704 #[doc = "Returns the `BaseEntityData` layer."]
16705 pub fn base(&self) -> &BaseEntityData {
16706 &self.throwable_item_projectile.base
16707 }
16708 #[doc = "Returns the mutable `BaseEntityData` layer."]
16709 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16710 &mut self.throwable_item_projectile.base
16711 }
16712 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16713 #[doc = r" Returns `None` if no values are dirty."]
16714 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16715 self.throwable_item_projectile.pack_dirty()
16716 }
16717 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16718 pub fn pack_all(&self) -> Vec<DataValue> {
16719 self.throwable_item_projectile.pack_all()
16720 }
16721 #[doc = r" Returns `true` if any field has been modified."]
16722 pub fn is_dirty(&self) -> bool {
16723 self.throwable_item_projectile.is_dirty()
16724 }
16725}
16726impl Default for EnderPearlEntityData {
16727 fn default() -> Self {
16728 Self::new()
16729 }
16730}
16731impl VanillaEntityData for EnderPearlEntityData {
16732 fn base(&self) -> &BaseEntityData {
16733 EnderPearlEntityData::base(self)
16734 }
16735 fn base_mut(&mut self) -> &mut BaseEntityData {
16736 EnderPearlEntityData::base_mut(self)
16737 }
16738 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16739 EnderPearlEntityData::pack_dirty(self)
16740 }
16741 fn pack_all(&self) -> Vec<DataValue> {
16742 EnderPearlEntityData::pack_all(self)
16743 }
16744 fn is_dirty(&self) -> bool {
16745 EnderPearlEntityData::is_dirty(self)
16746 }
16747}
16748#[doc = "Concrete synchronized entity data for vanilla entity `evoker`."]
16749#[derive(Debug, Clone)]
16750pub struct EvokerEntityData {
16751 pub spellcaster_illager: SpellcasterIllagerEntityData,
16752}
16753impl EvokerEntityData {
16754 #[doc = r" Create new entity data with default values."]
16755 pub fn new() -> Self {
16756 Self {
16757 spellcaster_illager: SpellcasterIllagerEntityData::new(),
16758 }
16759 }
16760 #[doc = "Returns the `SpellcasterIllagerEntityData` layer."]
16761 pub fn spellcaster_illager(&self) -> &SpellcasterIllagerEntityData {
16762 &self.spellcaster_illager
16763 }
16764 #[doc = "Returns the mutable `SpellcasterIllagerEntityData` layer."]
16765 pub fn spellcaster_illager_mut(&mut self) -> &mut SpellcasterIllagerEntityData {
16766 &mut self.spellcaster_illager
16767 }
16768 #[doc = "Returns the `RaiderEntityData` layer."]
16769 pub fn raider(&self) -> &RaiderEntityData {
16770 &self.spellcaster_illager.raider
16771 }
16772 #[doc = "Returns the mutable `RaiderEntityData` layer."]
16773 pub fn raider_mut(&mut self) -> &mut RaiderEntityData {
16774 &mut self.spellcaster_illager.raider
16775 }
16776 #[doc = "Returns the `MobEntityData` layer."]
16777 pub fn mob(&self) -> &MobEntityData {
16778 &self.spellcaster_illager.raider.mob
16779 }
16780 #[doc = "Returns the mutable `MobEntityData` layer."]
16781 pub fn mob_mut(&mut self) -> &mut MobEntityData {
16782 &mut self.spellcaster_illager.raider.mob
16783 }
16784 #[doc = "Returns the `LivingEntityData` layer."]
16785 pub fn living_entity(&self) -> &LivingEntityData {
16786 &self.spellcaster_illager.raider.mob.living_entity
16787 }
16788 #[doc = "Returns the mutable `LivingEntityData` layer."]
16789 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16790 &mut self.spellcaster_illager.raider.mob.living_entity
16791 }
16792 #[doc = "Returns the `BaseEntityData` layer."]
16793 pub fn base(&self) -> &BaseEntityData {
16794 &self.spellcaster_illager.raider.mob.living_entity.base
16795 }
16796 #[doc = "Returns the mutable `BaseEntityData` layer."]
16797 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16798 &mut self.spellcaster_illager.raider.mob.living_entity.base
16799 }
16800 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16801 #[doc = r" Returns `None` if no values are dirty."]
16802 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16803 self.spellcaster_illager.pack_dirty()
16804 }
16805 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16806 pub fn pack_all(&self) -> Vec<DataValue> {
16807 self.spellcaster_illager.pack_all()
16808 }
16809 #[doc = r" Returns `true` if any field has been modified."]
16810 pub fn is_dirty(&self) -> bool {
16811 self.spellcaster_illager.is_dirty()
16812 }
16813}
16814impl Default for EvokerEntityData {
16815 fn default() -> Self {
16816 Self::new()
16817 }
16818}
16819impl VanillaEntityData for EvokerEntityData {
16820 fn base(&self) -> &BaseEntityData {
16821 EvokerEntityData::base(self)
16822 }
16823 fn base_mut(&mut self) -> &mut BaseEntityData {
16824 EvokerEntityData::base_mut(self)
16825 }
16826 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16827 EvokerEntityData::pack_dirty(self)
16828 }
16829 fn pack_all(&self) -> Vec<DataValue> {
16830 EvokerEntityData::pack_all(self)
16831 }
16832 fn is_dirty(&self) -> bool {
16833 EvokerEntityData::is_dirty(self)
16834 }
16835}
16836impl VanillaLivingEntityData for EvokerEntityData {
16837 fn living_entity(&self) -> &LivingEntityData {
16838 EvokerEntityData::living_entity(self)
16839 }
16840 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
16841 EvokerEntityData::living_entity_mut(self)
16842 }
16843}
16844#[doc = "Concrete synchronized entity data for vanilla entity `evoker_fangs`."]
16845#[derive(Debug, Clone)]
16846pub struct EvokerFangsEntityData {
16847 pub base: BaseEntityData,
16848}
16849impl EvokerFangsEntityData {
16850 #[doc = r" Create new entity data with default values."]
16851 pub fn new() -> Self {
16852 Self {
16853 base: BaseEntityData::new(),
16854 }
16855 }
16856 #[doc = "Returns the `BaseEntityData` layer."]
16857 pub fn base(&self) -> &BaseEntityData {
16858 &self.base
16859 }
16860 #[doc = "Returns the mutable `BaseEntityData` layer."]
16861 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16862 &mut self.base
16863 }
16864 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16865 #[doc = r" Returns `None` if no values are dirty."]
16866 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16867 self.base.pack_dirty()
16868 }
16869 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16870 pub fn pack_all(&self) -> Vec<DataValue> {
16871 self.base.pack_all()
16872 }
16873 #[doc = r" Returns `true` if any field has been modified."]
16874 pub fn is_dirty(&self) -> bool {
16875 self.base.is_dirty()
16876 }
16877}
16878impl Default for EvokerFangsEntityData {
16879 fn default() -> Self {
16880 Self::new()
16881 }
16882}
16883impl VanillaEntityData for EvokerFangsEntityData {
16884 fn base(&self) -> &BaseEntityData {
16885 EvokerFangsEntityData::base(self)
16886 }
16887 fn base_mut(&mut self) -> &mut BaseEntityData {
16888 EvokerFangsEntityData::base_mut(self)
16889 }
16890 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16891 EvokerFangsEntityData::pack_dirty(self)
16892 }
16893 fn pack_all(&self) -> Vec<DataValue> {
16894 EvokerFangsEntityData::pack_all(self)
16895 }
16896 fn is_dirty(&self) -> bool {
16897 EvokerFangsEntityData::is_dirty(self)
16898 }
16899}
16900#[doc = "Concrete synchronized entity data for vanilla entity `experience_bottle`."]
16901#[derive(Debug, Clone)]
16902pub struct ExperienceBottleEntityData {
16903 pub throwable_item_projectile: ThrowableItemProjectileEntityData,
16904}
16905impl ExperienceBottleEntityData {
16906 #[doc = r" Create new entity data with default values."]
16907 pub fn new() -> Self {
16908 let mut data = ThrowableItemProjectileEntityData::new();
16909 data.item_stack = SyncedValue::new(ItemStack::with_count(
16910 &crate::vanilla_items::ITEMS.experience_bottle,
16911 1i32,
16912 ));
16913 Self {
16914 throwable_item_projectile: data,
16915 }
16916 }
16917 #[doc = "Returns the `ThrowableItemProjectileEntityData` layer."]
16918 pub fn throwable_item_projectile(&self) -> &ThrowableItemProjectileEntityData {
16919 &self.throwable_item_projectile
16920 }
16921 #[doc = "Returns the mutable `ThrowableItemProjectileEntityData` layer."]
16922 pub fn throwable_item_projectile_mut(&mut self) -> &mut ThrowableItemProjectileEntityData {
16923 &mut self.throwable_item_projectile
16924 }
16925 #[doc = "Returns the `BaseEntityData` layer."]
16926 pub fn base(&self) -> &BaseEntityData {
16927 &self.throwable_item_projectile.base
16928 }
16929 #[doc = "Returns the mutable `BaseEntityData` layer."]
16930 pub fn base_mut(&mut self) -> &mut BaseEntityData {
16931 &mut self.throwable_item_projectile.base
16932 }
16933 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
16934 #[doc = r" Returns `None` if no values are dirty."]
16935 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16936 self.throwable_item_projectile.pack_dirty()
16937 }
16938 #[doc = r" Pack all non-default values (for initial entity spawn)."]
16939 pub fn pack_all(&self) -> Vec<DataValue> {
16940 self.throwable_item_projectile.pack_all()
16941 }
16942 #[doc = r" Returns `true` if any field has been modified."]
16943 pub fn is_dirty(&self) -> bool {
16944 self.throwable_item_projectile.is_dirty()
16945 }
16946}
16947impl Default for ExperienceBottleEntityData {
16948 fn default() -> Self {
16949 Self::new()
16950 }
16951}
16952impl VanillaEntityData for ExperienceBottleEntityData {
16953 fn base(&self) -> &BaseEntityData {
16954 ExperienceBottleEntityData::base(self)
16955 }
16956 fn base_mut(&mut self) -> &mut BaseEntityData {
16957 ExperienceBottleEntityData::base_mut(self)
16958 }
16959 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
16960 ExperienceBottleEntityData::pack_dirty(self)
16961 }
16962 fn pack_all(&self) -> Vec<DataValue> {
16963 ExperienceBottleEntityData::pack_all(self)
16964 }
16965 fn is_dirty(&self) -> bool {
16966 ExperienceBottleEntityData::is_dirty(self)
16967 }
16968}
16969#[doc = "Concrete synchronized entity data for vanilla entity `furnace_minecart`."]
16970#[derive(Debug, Clone)]
16971pub struct FurnaceMinecartEntityData {
16972 pub minecart_furnace: MinecartFurnaceEntityData,
16973}
16974impl FurnaceMinecartEntityData {
16975 #[doc = r" Create new entity data with default values."]
16976 pub fn new() -> Self {
16977 let mut data = MinecartFurnaceEntityData::new();
16978 data.abstract_minecart.id_display_offset = SyncedValue::new(6i32);
16979 Self {
16980 minecart_furnace: data,
16981 }
16982 }
16983 #[doc = "Returns the `MinecartFurnaceEntityData` layer."]
16984 pub fn minecart_furnace(&self) -> &MinecartFurnaceEntityData {
16985 &self.minecart_furnace
16986 }
16987 #[doc = "Returns the mutable `MinecartFurnaceEntityData` layer."]
16988 pub fn minecart_furnace_mut(&mut self) -> &mut MinecartFurnaceEntityData {
16989 &mut self.minecart_furnace
16990 }
16991 #[doc = "Returns the `AbstractMinecartEntityData` layer."]
16992 pub fn abstract_minecart(&self) -> &AbstractMinecartEntityData {
16993 &self.minecart_furnace.abstract_minecart
16994 }
16995 #[doc = "Returns the mutable `AbstractMinecartEntityData` layer."]
16996 pub fn abstract_minecart_mut(&mut self) -> &mut AbstractMinecartEntityData {
16997 &mut self.minecart_furnace.abstract_minecart
16998 }
16999 #[doc = "Returns the `VehicleEntityData` layer."]
17000 pub fn vehicle_entity(&self) -> &VehicleEntityData {
17001 &self.minecart_furnace.abstract_minecart.vehicle_entity
17002 }
17003 #[doc = "Returns the mutable `VehicleEntityData` layer."]
17004 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
17005 &mut self.minecart_furnace.abstract_minecart.vehicle_entity
17006 }
17007 #[doc = "Returns the `BaseEntityData` layer."]
17008 pub fn base(&self) -> &BaseEntityData {
17009 &self.minecart_furnace.abstract_minecart.vehicle_entity.base
17010 }
17011 #[doc = "Returns the mutable `BaseEntityData` layer."]
17012 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17013 &mut self.minecart_furnace.abstract_minecart.vehicle_entity.base
17014 }
17015 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17016 #[doc = r" Returns `None` if no values are dirty."]
17017 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17018 self.minecart_furnace.pack_dirty()
17019 }
17020 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17021 pub fn pack_all(&self) -> Vec<DataValue> {
17022 self.minecart_furnace.pack_all()
17023 }
17024 #[doc = r" Returns `true` if any field has been modified."]
17025 pub fn is_dirty(&self) -> bool {
17026 self.minecart_furnace.is_dirty()
17027 }
17028}
17029impl Default for FurnaceMinecartEntityData {
17030 fn default() -> Self {
17031 Self::new()
17032 }
17033}
17034impl VanillaEntityData for FurnaceMinecartEntityData {
17035 fn base(&self) -> &BaseEntityData {
17036 FurnaceMinecartEntityData::base(self)
17037 }
17038 fn base_mut(&mut self) -> &mut BaseEntityData {
17039 FurnaceMinecartEntityData::base_mut(self)
17040 }
17041 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17042 FurnaceMinecartEntityData::pack_dirty(self)
17043 }
17044 fn pack_all(&self) -> Vec<DataValue> {
17045 FurnaceMinecartEntityData::pack_all(self)
17046 }
17047 fn is_dirty(&self) -> bool {
17048 FurnaceMinecartEntityData::is_dirty(self)
17049 }
17050}
17051#[doc = "Concrete synchronized entity data for vanilla entity `giant`."]
17052#[derive(Debug, Clone)]
17053pub struct GiantEntityData {
17054 pub mob: MobEntityData,
17055}
17056impl GiantEntityData {
17057 #[doc = r" Create new entity data with default values."]
17058 pub fn new() -> Self {
17059 Self {
17060 mob: MobEntityData::new(),
17061 }
17062 }
17063 #[doc = "Returns the `MobEntityData` layer."]
17064 pub fn mob(&self) -> &MobEntityData {
17065 &self.mob
17066 }
17067 #[doc = "Returns the mutable `MobEntityData` layer."]
17068 pub fn mob_mut(&mut self) -> &mut MobEntityData {
17069 &mut self.mob
17070 }
17071 #[doc = "Returns the `LivingEntityData` layer."]
17072 pub fn living_entity(&self) -> &LivingEntityData {
17073 &self.mob.living_entity
17074 }
17075 #[doc = "Returns the mutable `LivingEntityData` layer."]
17076 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
17077 &mut self.mob.living_entity
17078 }
17079 #[doc = "Returns the `BaseEntityData` layer."]
17080 pub fn base(&self) -> &BaseEntityData {
17081 &self.mob.living_entity.base
17082 }
17083 #[doc = "Returns the mutable `BaseEntityData` layer."]
17084 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17085 &mut self.mob.living_entity.base
17086 }
17087 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17088 #[doc = r" Returns `None` if no values are dirty."]
17089 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17090 self.mob.pack_dirty()
17091 }
17092 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17093 pub fn pack_all(&self) -> Vec<DataValue> {
17094 self.mob.pack_all()
17095 }
17096 #[doc = r" Returns `true` if any field has been modified."]
17097 pub fn is_dirty(&self) -> bool {
17098 self.mob.is_dirty()
17099 }
17100}
17101impl Default for GiantEntityData {
17102 fn default() -> Self {
17103 Self::new()
17104 }
17105}
17106impl VanillaEntityData for GiantEntityData {
17107 fn base(&self) -> &BaseEntityData {
17108 GiantEntityData::base(self)
17109 }
17110 fn base_mut(&mut self) -> &mut BaseEntityData {
17111 GiantEntityData::base_mut(self)
17112 }
17113 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17114 GiantEntityData::pack_dirty(self)
17115 }
17116 fn pack_all(&self) -> Vec<DataValue> {
17117 GiantEntityData::pack_all(self)
17118 }
17119 fn is_dirty(&self) -> bool {
17120 GiantEntityData::is_dirty(self)
17121 }
17122}
17123impl VanillaLivingEntityData for GiantEntityData {
17124 fn living_entity(&self) -> &LivingEntityData {
17125 GiantEntityData::living_entity(self)
17126 }
17127 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
17128 GiantEntityData::living_entity_mut(self)
17129 }
17130}
17131#[doc = "Concrete synchronized entity data for vanilla entity `glow_item_frame`."]
17132#[derive(Debug, Clone)]
17133pub struct GlowItemFrameEntityData {
17134 pub item_frame: ItemFrameEntityData,
17135}
17136impl GlowItemFrameEntityData {
17137 #[doc = r" Create new entity data with default values."]
17138 pub fn new() -> Self {
17139 Self {
17140 item_frame: ItemFrameEntityData::new(),
17141 }
17142 }
17143 #[doc = "Returns the `ItemFrameEntityData` layer."]
17144 pub fn item_frame(&self) -> &ItemFrameEntityData {
17145 &self.item_frame
17146 }
17147 #[doc = "Returns the mutable `ItemFrameEntityData` layer."]
17148 pub fn item_frame_mut(&mut self) -> &mut ItemFrameEntityData {
17149 &mut self.item_frame
17150 }
17151 #[doc = "Returns the `HangingEntityData` layer."]
17152 pub fn hanging_entity(&self) -> &HangingEntityData {
17153 &self.item_frame.hanging_entity
17154 }
17155 #[doc = "Returns the mutable `HangingEntityData` layer."]
17156 pub fn hanging_entity_mut(&mut self) -> &mut HangingEntityData {
17157 &mut self.item_frame.hanging_entity
17158 }
17159 #[doc = "Returns the `BaseEntityData` layer."]
17160 pub fn base(&self) -> &BaseEntityData {
17161 &self.item_frame.hanging_entity.base
17162 }
17163 #[doc = "Returns the mutable `BaseEntityData` layer."]
17164 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17165 &mut self.item_frame.hanging_entity.base
17166 }
17167 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17168 #[doc = r" Returns `None` if no values are dirty."]
17169 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17170 self.item_frame.pack_dirty()
17171 }
17172 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17173 pub fn pack_all(&self) -> Vec<DataValue> {
17174 self.item_frame.pack_all()
17175 }
17176 #[doc = r" Returns `true` if any field has been modified."]
17177 pub fn is_dirty(&self) -> bool {
17178 self.item_frame.is_dirty()
17179 }
17180}
17181impl Default for GlowItemFrameEntityData {
17182 fn default() -> Self {
17183 Self::new()
17184 }
17185}
17186impl VanillaEntityData for GlowItemFrameEntityData {
17187 fn base(&self) -> &BaseEntityData {
17188 GlowItemFrameEntityData::base(self)
17189 }
17190 fn base_mut(&mut self) -> &mut BaseEntityData {
17191 GlowItemFrameEntityData::base_mut(self)
17192 }
17193 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17194 GlowItemFrameEntityData::pack_dirty(self)
17195 }
17196 fn pack_all(&self) -> Vec<DataValue> {
17197 GlowItemFrameEntityData::pack_all(self)
17198 }
17199 fn is_dirty(&self) -> bool {
17200 GlowItemFrameEntityData::is_dirty(self)
17201 }
17202}
17203#[doc = "Concrete synchronized entity data for vanilla entity `hopper_minecart`."]
17204#[derive(Debug, Clone)]
17205pub struct HopperMinecartEntityData {
17206 pub abstract_minecart: AbstractMinecartEntityData,
17207}
17208impl HopperMinecartEntityData {
17209 #[doc = r" Create new entity data with default values."]
17210 pub fn new() -> Self {
17211 let mut data = AbstractMinecartEntityData::new();
17212 data.id_display_offset = SyncedValue::new(1i32);
17213 Self {
17214 abstract_minecart: data,
17215 }
17216 }
17217 #[doc = "Returns the `AbstractMinecartEntityData` layer."]
17218 pub fn abstract_minecart(&self) -> &AbstractMinecartEntityData {
17219 &self.abstract_minecart
17220 }
17221 #[doc = "Returns the mutable `AbstractMinecartEntityData` layer."]
17222 pub fn abstract_minecart_mut(&mut self) -> &mut AbstractMinecartEntityData {
17223 &mut self.abstract_minecart
17224 }
17225 #[doc = "Returns the `VehicleEntityData` layer."]
17226 pub fn vehicle_entity(&self) -> &VehicleEntityData {
17227 &self.abstract_minecart.vehicle_entity
17228 }
17229 #[doc = "Returns the mutable `VehicleEntityData` layer."]
17230 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
17231 &mut self.abstract_minecart.vehicle_entity
17232 }
17233 #[doc = "Returns the `BaseEntityData` layer."]
17234 pub fn base(&self) -> &BaseEntityData {
17235 &self.abstract_minecart.vehicle_entity.base
17236 }
17237 #[doc = "Returns the mutable `BaseEntityData` layer."]
17238 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17239 &mut self.abstract_minecart.vehicle_entity.base
17240 }
17241 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17242 #[doc = r" Returns `None` if no values are dirty."]
17243 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17244 self.abstract_minecart.pack_dirty()
17245 }
17246 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17247 pub fn pack_all(&self) -> Vec<DataValue> {
17248 self.abstract_minecart.pack_all()
17249 }
17250 #[doc = r" Returns `true` if any field has been modified."]
17251 pub fn is_dirty(&self) -> bool {
17252 self.abstract_minecart.is_dirty()
17253 }
17254}
17255impl Default for HopperMinecartEntityData {
17256 fn default() -> Self {
17257 Self::new()
17258 }
17259}
17260impl VanillaEntityData for HopperMinecartEntityData {
17261 fn base(&self) -> &BaseEntityData {
17262 HopperMinecartEntityData::base(self)
17263 }
17264 fn base_mut(&mut self) -> &mut BaseEntityData {
17265 HopperMinecartEntityData::base_mut(self)
17266 }
17267 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17268 HopperMinecartEntityData::pack_dirty(self)
17269 }
17270 fn pack_all(&self) -> Vec<DataValue> {
17271 HopperMinecartEntityData::pack_all(self)
17272 }
17273 fn is_dirty(&self) -> bool {
17274 HopperMinecartEntityData::is_dirty(self)
17275 }
17276}
17277#[doc = "Concrete synchronized entity data for vanilla entity `husk`."]
17278#[derive(Debug, Clone)]
17279pub struct HuskEntityData {
17280 pub zombie: ZombieEntityData,
17281}
17282impl HuskEntityData {
17283 #[doc = r" Create new entity data with default values."]
17284 pub fn new() -> Self {
17285 Self {
17286 zombie: ZombieEntityData::new(),
17287 }
17288 }
17289 #[doc = "Returns the `ZombieEntityData` layer."]
17290 pub fn zombie(&self) -> &ZombieEntityData {
17291 &self.zombie
17292 }
17293 #[doc = "Returns the mutable `ZombieEntityData` layer."]
17294 pub fn zombie_mut(&mut self) -> &mut ZombieEntityData {
17295 &mut self.zombie
17296 }
17297 #[doc = "Returns the `MobEntityData` layer."]
17298 pub fn mob(&self) -> &MobEntityData {
17299 &self.zombie.mob
17300 }
17301 #[doc = "Returns the mutable `MobEntityData` layer."]
17302 pub fn mob_mut(&mut self) -> &mut MobEntityData {
17303 &mut self.zombie.mob
17304 }
17305 #[doc = "Returns the `LivingEntityData` layer."]
17306 pub fn living_entity(&self) -> &LivingEntityData {
17307 &self.zombie.mob.living_entity
17308 }
17309 #[doc = "Returns the mutable `LivingEntityData` layer."]
17310 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
17311 &mut self.zombie.mob.living_entity
17312 }
17313 #[doc = "Returns the `BaseEntityData` layer."]
17314 pub fn base(&self) -> &BaseEntityData {
17315 &self.zombie.mob.living_entity.base
17316 }
17317 #[doc = "Returns the mutable `BaseEntityData` layer."]
17318 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17319 &mut self.zombie.mob.living_entity.base
17320 }
17321 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17322 #[doc = r" Returns `None` if no values are dirty."]
17323 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17324 self.zombie.pack_dirty()
17325 }
17326 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17327 pub fn pack_all(&self) -> Vec<DataValue> {
17328 self.zombie.pack_all()
17329 }
17330 #[doc = r" Returns `true` if any field has been modified."]
17331 pub fn is_dirty(&self) -> bool {
17332 self.zombie.is_dirty()
17333 }
17334}
17335impl Default for HuskEntityData {
17336 fn default() -> Self {
17337 Self::new()
17338 }
17339}
17340impl VanillaEntityData for HuskEntityData {
17341 fn base(&self) -> &BaseEntityData {
17342 HuskEntityData::base(self)
17343 }
17344 fn base_mut(&mut self) -> &mut BaseEntityData {
17345 HuskEntityData::base_mut(self)
17346 }
17347 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17348 HuskEntityData::pack_dirty(self)
17349 }
17350 fn pack_all(&self) -> Vec<DataValue> {
17351 HuskEntityData::pack_all(self)
17352 }
17353 fn is_dirty(&self) -> bool {
17354 HuskEntityData::is_dirty(self)
17355 }
17356}
17357impl VanillaLivingEntityData for HuskEntityData {
17358 fn living_entity(&self) -> &LivingEntityData {
17359 HuskEntityData::living_entity(self)
17360 }
17361 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
17362 HuskEntityData::living_entity_mut(self)
17363 }
17364}
17365#[doc = "Concrete synchronized entity data for vanilla entity `illusioner`."]
17366#[derive(Debug, Clone)]
17367pub struct IllusionerEntityData {
17368 pub spellcaster_illager: SpellcasterIllagerEntityData,
17369}
17370impl IllusionerEntityData {
17371 #[doc = r" Create new entity data with default values."]
17372 pub fn new() -> Self {
17373 Self {
17374 spellcaster_illager: SpellcasterIllagerEntityData::new(),
17375 }
17376 }
17377 #[doc = "Returns the `SpellcasterIllagerEntityData` layer."]
17378 pub fn spellcaster_illager(&self) -> &SpellcasterIllagerEntityData {
17379 &self.spellcaster_illager
17380 }
17381 #[doc = "Returns the mutable `SpellcasterIllagerEntityData` layer."]
17382 pub fn spellcaster_illager_mut(&mut self) -> &mut SpellcasterIllagerEntityData {
17383 &mut self.spellcaster_illager
17384 }
17385 #[doc = "Returns the `RaiderEntityData` layer."]
17386 pub fn raider(&self) -> &RaiderEntityData {
17387 &self.spellcaster_illager.raider
17388 }
17389 #[doc = "Returns the mutable `RaiderEntityData` layer."]
17390 pub fn raider_mut(&mut self) -> &mut RaiderEntityData {
17391 &mut self.spellcaster_illager.raider
17392 }
17393 #[doc = "Returns the `MobEntityData` layer."]
17394 pub fn mob(&self) -> &MobEntityData {
17395 &self.spellcaster_illager.raider.mob
17396 }
17397 #[doc = "Returns the mutable `MobEntityData` layer."]
17398 pub fn mob_mut(&mut self) -> &mut MobEntityData {
17399 &mut self.spellcaster_illager.raider.mob
17400 }
17401 #[doc = "Returns the `LivingEntityData` layer."]
17402 pub fn living_entity(&self) -> &LivingEntityData {
17403 &self.spellcaster_illager.raider.mob.living_entity
17404 }
17405 #[doc = "Returns the mutable `LivingEntityData` layer."]
17406 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
17407 &mut self.spellcaster_illager.raider.mob.living_entity
17408 }
17409 #[doc = "Returns the `BaseEntityData` layer."]
17410 pub fn base(&self) -> &BaseEntityData {
17411 &self.spellcaster_illager.raider.mob.living_entity.base
17412 }
17413 #[doc = "Returns the mutable `BaseEntityData` layer."]
17414 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17415 &mut self.spellcaster_illager.raider.mob.living_entity.base
17416 }
17417 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17418 #[doc = r" Returns `None` if no values are dirty."]
17419 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17420 self.spellcaster_illager.pack_dirty()
17421 }
17422 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17423 pub fn pack_all(&self) -> Vec<DataValue> {
17424 self.spellcaster_illager.pack_all()
17425 }
17426 #[doc = r" Returns `true` if any field has been modified."]
17427 pub fn is_dirty(&self) -> bool {
17428 self.spellcaster_illager.is_dirty()
17429 }
17430}
17431impl Default for IllusionerEntityData {
17432 fn default() -> Self {
17433 Self::new()
17434 }
17435}
17436impl VanillaEntityData for IllusionerEntityData {
17437 fn base(&self) -> &BaseEntityData {
17438 IllusionerEntityData::base(self)
17439 }
17440 fn base_mut(&mut self) -> &mut BaseEntityData {
17441 IllusionerEntityData::base_mut(self)
17442 }
17443 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17444 IllusionerEntityData::pack_dirty(self)
17445 }
17446 fn pack_all(&self) -> Vec<DataValue> {
17447 IllusionerEntityData::pack_all(self)
17448 }
17449 fn is_dirty(&self) -> bool {
17450 IllusionerEntityData::is_dirty(self)
17451 }
17452}
17453impl VanillaLivingEntityData for IllusionerEntityData {
17454 fn living_entity(&self) -> &LivingEntityData {
17455 IllusionerEntityData::living_entity(self)
17456 }
17457 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
17458 IllusionerEntityData::living_entity_mut(self)
17459 }
17460}
17461#[doc = "Concrete synchronized entity data for vanilla entity `jungle_boat`."]
17462#[derive(Debug, Clone)]
17463pub struct JungleBoatEntityData {
17464 pub abstract_boat: AbstractBoatEntityData,
17465}
17466impl JungleBoatEntityData {
17467 #[doc = r" Create new entity data with default values."]
17468 pub fn new() -> Self {
17469 Self {
17470 abstract_boat: AbstractBoatEntityData::new(),
17471 }
17472 }
17473 #[doc = "Returns the `AbstractBoatEntityData` layer."]
17474 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
17475 &self.abstract_boat
17476 }
17477 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
17478 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
17479 &mut self.abstract_boat
17480 }
17481 #[doc = "Returns the `VehicleEntityData` layer."]
17482 pub fn vehicle_entity(&self) -> &VehicleEntityData {
17483 &self.abstract_boat.vehicle_entity
17484 }
17485 #[doc = "Returns the mutable `VehicleEntityData` layer."]
17486 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
17487 &mut self.abstract_boat.vehicle_entity
17488 }
17489 #[doc = "Returns the `BaseEntityData` layer."]
17490 pub fn base(&self) -> &BaseEntityData {
17491 &self.abstract_boat.vehicle_entity.base
17492 }
17493 #[doc = "Returns the mutable `BaseEntityData` layer."]
17494 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17495 &mut self.abstract_boat.vehicle_entity.base
17496 }
17497 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17498 #[doc = r" Returns `None` if no values are dirty."]
17499 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17500 self.abstract_boat.pack_dirty()
17501 }
17502 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17503 pub fn pack_all(&self) -> Vec<DataValue> {
17504 self.abstract_boat.pack_all()
17505 }
17506 #[doc = r" Returns `true` if any field has been modified."]
17507 pub fn is_dirty(&self) -> bool {
17508 self.abstract_boat.is_dirty()
17509 }
17510}
17511impl Default for JungleBoatEntityData {
17512 fn default() -> Self {
17513 Self::new()
17514 }
17515}
17516impl VanillaEntityData for JungleBoatEntityData {
17517 fn base(&self) -> &BaseEntityData {
17518 JungleBoatEntityData::base(self)
17519 }
17520 fn base_mut(&mut self) -> &mut BaseEntityData {
17521 JungleBoatEntityData::base_mut(self)
17522 }
17523 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17524 JungleBoatEntityData::pack_dirty(self)
17525 }
17526 fn pack_all(&self) -> Vec<DataValue> {
17527 JungleBoatEntityData::pack_all(self)
17528 }
17529 fn is_dirty(&self) -> bool {
17530 JungleBoatEntityData::is_dirty(self)
17531 }
17532}
17533#[doc = "Concrete synchronized entity data for vanilla entity `jungle_chest_boat`."]
17534#[derive(Debug, Clone)]
17535pub struct JungleChestBoatEntityData {
17536 pub abstract_boat: AbstractBoatEntityData,
17537}
17538impl JungleChestBoatEntityData {
17539 #[doc = r" Create new entity data with default values."]
17540 pub fn new() -> Self {
17541 Self {
17542 abstract_boat: AbstractBoatEntityData::new(),
17543 }
17544 }
17545 #[doc = "Returns the `AbstractBoatEntityData` layer."]
17546 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
17547 &self.abstract_boat
17548 }
17549 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
17550 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
17551 &mut self.abstract_boat
17552 }
17553 #[doc = "Returns the `VehicleEntityData` layer."]
17554 pub fn vehicle_entity(&self) -> &VehicleEntityData {
17555 &self.abstract_boat.vehicle_entity
17556 }
17557 #[doc = "Returns the mutable `VehicleEntityData` layer."]
17558 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
17559 &mut self.abstract_boat.vehicle_entity
17560 }
17561 #[doc = "Returns the `BaseEntityData` layer."]
17562 pub fn base(&self) -> &BaseEntityData {
17563 &self.abstract_boat.vehicle_entity.base
17564 }
17565 #[doc = "Returns the mutable `BaseEntityData` layer."]
17566 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17567 &mut self.abstract_boat.vehicle_entity.base
17568 }
17569 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17570 #[doc = r" Returns `None` if no values are dirty."]
17571 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17572 self.abstract_boat.pack_dirty()
17573 }
17574 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17575 pub fn pack_all(&self) -> Vec<DataValue> {
17576 self.abstract_boat.pack_all()
17577 }
17578 #[doc = r" Returns `true` if any field has been modified."]
17579 pub fn is_dirty(&self) -> bool {
17580 self.abstract_boat.is_dirty()
17581 }
17582}
17583impl Default for JungleChestBoatEntityData {
17584 fn default() -> Self {
17585 Self::new()
17586 }
17587}
17588impl VanillaEntityData for JungleChestBoatEntityData {
17589 fn base(&self) -> &BaseEntityData {
17590 JungleChestBoatEntityData::base(self)
17591 }
17592 fn base_mut(&mut self) -> &mut BaseEntityData {
17593 JungleChestBoatEntityData::base_mut(self)
17594 }
17595 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17596 JungleChestBoatEntityData::pack_dirty(self)
17597 }
17598 fn pack_all(&self) -> Vec<DataValue> {
17599 JungleChestBoatEntityData::pack_all(self)
17600 }
17601 fn is_dirty(&self) -> bool {
17602 JungleChestBoatEntityData::is_dirty(self)
17603 }
17604}
17605#[doc = "Concrete synchronized entity data for vanilla entity `leash_knot`."]
17606#[derive(Debug, Clone)]
17607pub struct LeashKnotEntityData {
17608 pub base: BaseEntityData,
17609}
17610impl LeashKnotEntityData {
17611 #[doc = r" Create new entity data with default values."]
17612 pub fn new() -> Self {
17613 Self {
17614 base: BaseEntityData::new(),
17615 }
17616 }
17617 #[doc = "Returns the `BaseEntityData` layer."]
17618 pub fn base(&self) -> &BaseEntityData {
17619 &self.base
17620 }
17621 #[doc = "Returns the mutable `BaseEntityData` layer."]
17622 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17623 &mut self.base
17624 }
17625 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17626 #[doc = r" Returns `None` if no values are dirty."]
17627 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17628 self.base.pack_dirty()
17629 }
17630 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17631 pub fn pack_all(&self) -> Vec<DataValue> {
17632 self.base.pack_all()
17633 }
17634 #[doc = r" Returns `true` if any field has been modified."]
17635 pub fn is_dirty(&self) -> bool {
17636 self.base.is_dirty()
17637 }
17638}
17639impl Default for LeashKnotEntityData {
17640 fn default() -> Self {
17641 Self::new()
17642 }
17643}
17644impl VanillaEntityData for LeashKnotEntityData {
17645 fn base(&self) -> &BaseEntityData {
17646 LeashKnotEntityData::base(self)
17647 }
17648 fn base_mut(&mut self) -> &mut BaseEntityData {
17649 LeashKnotEntityData::base_mut(self)
17650 }
17651 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17652 LeashKnotEntityData::pack_dirty(self)
17653 }
17654 fn pack_all(&self) -> Vec<DataValue> {
17655 LeashKnotEntityData::pack_all(self)
17656 }
17657 fn is_dirty(&self) -> bool {
17658 LeashKnotEntityData::is_dirty(self)
17659 }
17660}
17661#[doc = "Concrete synchronized entity data for vanilla entity `lightning_bolt`."]
17662#[derive(Debug, Clone)]
17663pub struct LightningBoltEntityData {
17664 pub base: BaseEntityData,
17665}
17666impl LightningBoltEntityData {
17667 #[doc = r" Create new entity data with default values."]
17668 pub fn new() -> Self {
17669 Self {
17670 base: BaseEntityData::new(),
17671 }
17672 }
17673 #[doc = "Returns the `BaseEntityData` layer."]
17674 pub fn base(&self) -> &BaseEntityData {
17675 &self.base
17676 }
17677 #[doc = "Returns the mutable `BaseEntityData` layer."]
17678 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17679 &mut self.base
17680 }
17681 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17682 #[doc = r" Returns `None` if no values are dirty."]
17683 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17684 self.base.pack_dirty()
17685 }
17686 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17687 pub fn pack_all(&self) -> Vec<DataValue> {
17688 self.base.pack_all()
17689 }
17690 #[doc = r" Returns `true` if any field has been modified."]
17691 pub fn is_dirty(&self) -> bool {
17692 self.base.is_dirty()
17693 }
17694}
17695impl Default for LightningBoltEntityData {
17696 fn default() -> Self {
17697 Self::new()
17698 }
17699}
17700impl VanillaEntityData for LightningBoltEntityData {
17701 fn base(&self) -> &BaseEntityData {
17702 LightningBoltEntityData::base(self)
17703 }
17704 fn base_mut(&mut self) -> &mut BaseEntityData {
17705 LightningBoltEntityData::base_mut(self)
17706 }
17707 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17708 LightningBoltEntityData::pack_dirty(self)
17709 }
17710 fn pack_all(&self) -> Vec<DataValue> {
17711 LightningBoltEntityData::pack_all(self)
17712 }
17713 fn is_dirty(&self) -> bool {
17714 LightningBoltEntityData::is_dirty(self)
17715 }
17716}
17717#[doc = "Concrete synchronized entity data for vanilla entity `llama_spit`."]
17718#[derive(Debug, Clone)]
17719pub struct LlamaSpitEntityData {
17720 pub base: BaseEntityData,
17721}
17722impl LlamaSpitEntityData {
17723 #[doc = r" Create new entity data with default values."]
17724 pub fn new() -> Self {
17725 Self {
17726 base: BaseEntityData::new(),
17727 }
17728 }
17729 #[doc = "Returns the `BaseEntityData` layer."]
17730 pub fn base(&self) -> &BaseEntityData {
17731 &self.base
17732 }
17733 #[doc = "Returns the mutable `BaseEntityData` layer."]
17734 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17735 &mut self.base
17736 }
17737 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17738 #[doc = r" Returns `None` if no values are dirty."]
17739 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17740 self.base.pack_dirty()
17741 }
17742 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17743 pub fn pack_all(&self) -> Vec<DataValue> {
17744 self.base.pack_all()
17745 }
17746 #[doc = r" Returns `true` if any field has been modified."]
17747 pub fn is_dirty(&self) -> bool {
17748 self.base.is_dirty()
17749 }
17750}
17751impl Default for LlamaSpitEntityData {
17752 fn default() -> Self {
17753 Self::new()
17754 }
17755}
17756impl VanillaEntityData for LlamaSpitEntityData {
17757 fn base(&self) -> &BaseEntityData {
17758 LlamaSpitEntityData::base(self)
17759 }
17760 fn base_mut(&mut self) -> &mut BaseEntityData {
17761 LlamaSpitEntityData::base_mut(self)
17762 }
17763 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17764 LlamaSpitEntityData::pack_dirty(self)
17765 }
17766 fn pack_all(&self) -> Vec<DataValue> {
17767 LlamaSpitEntityData::pack_all(self)
17768 }
17769 fn is_dirty(&self) -> bool {
17770 LlamaSpitEntityData::is_dirty(self)
17771 }
17772}
17773#[doc = "Concrete synchronized entity data for vanilla entity `magma_cube`."]
17774#[derive(Debug, Clone)]
17775pub struct MagmaCubeEntityData {
17776 pub slime: SlimeEntityData,
17777}
17778impl MagmaCubeEntityData {
17779 #[doc = r" Create new entity data with default values."]
17780 pub fn new() -> Self {
17781 Self {
17782 slime: SlimeEntityData::new(),
17783 }
17784 }
17785 #[doc = "Returns the `SlimeEntityData` layer."]
17786 pub fn slime(&self) -> &SlimeEntityData {
17787 &self.slime
17788 }
17789 #[doc = "Returns the mutable `SlimeEntityData` layer."]
17790 pub fn slime_mut(&mut self) -> &mut SlimeEntityData {
17791 &mut self.slime
17792 }
17793 #[doc = "Returns the `MobEntityData` layer."]
17794 pub fn mob(&self) -> &MobEntityData {
17795 &self.slime.mob
17796 }
17797 #[doc = "Returns the mutable `MobEntityData` layer."]
17798 pub fn mob_mut(&mut self) -> &mut MobEntityData {
17799 &mut self.slime.mob
17800 }
17801 #[doc = "Returns the `LivingEntityData` layer."]
17802 pub fn living_entity(&self) -> &LivingEntityData {
17803 &self.slime.mob.living_entity
17804 }
17805 #[doc = "Returns the mutable `LivingEntityData` layer."]
17806 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
17807 &mut self.slime.mob.living_entity
17808 }
17809 #[doc = "Returns the `BaseEntityData` layer."]
17810 pub fn base(&self) -> &BaseEntityData {
17811 &self.slime.mob.living_entity.base
17812 }
17813 #[doc = "Returns the mutable `BaseEntityData` layer."]
17814 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17815 &mut self.slime.mob.living_entity.base
17816 }
17817 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17818 #[doc = r" Returns `None` if no values are dirty."]
17819 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17820 self.slime.pack_dirty()
17821 }
17822 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17823 pub fn pack_all(&self) -> Vec<DataValue> {
17824 self.slime.pack_all()
17825 }
17826 #[doc = r" Returns `true` if any field has been modified."]
17827 pub fn is_dirty(&self) -> bool {
17828 self.slime.is_dirty()
17829 }
17830}
17831impl Default for MagmaCubeEntityData {
17832 fn default() -> Self {
17833 Self::new()
17834 }
17835}
17836impl VanillaEntityData for MagmaCubeEntityData {
17837 fn base(&self) -> &BaseEntityData {
17838 MagmaCubeEntityData::base(self)
17839 }
17840 fn base_mut(&mut self) -> &mut BaseEntityData {
17841 MagmaCubeEntityData::base_mut(self)
17842 }
17843 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17844 MagmaCubeEntityData::pack_dirty(self)
17845 }
17846 fn pack_all(&self) -> Vec<DataValue> {
17847 MagmaCubeEntityData::pack_all(self)
17848 }
17849 fn is_dirty(&self) -> bool {
17850 MagmaCubeEntityData::is_dirty(self)
17851 }
17852}
17853impl VanillaLivingEntityData for MagmaCubeEntityData {
17854 fn living_entity(&self) -> &LivingEntityData {
17855 MagmaCubeEntityData::living_entity(self)
17856 }
17857 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
17858 MagmaCubeEntityData::living_entity_mut(self)
17859 }
17860}
17861#[doc = "Concrete synchronized entity data for vanilla entity `mangrove_boat`."]
17862#[derive(Debug, Clone)]
17863pub struct MangroveBoatEntityData {
17864 pub abstract_boat: AbstractBoatEntityData,
17865}
17866impl MangroveBoatEntityData {
17867 #[doc = r" Create new entity data with default values."]
17868 pub fn new() -> Self {
17869 Self {
17870 abstract_boat: AbstractBoatEntityData::new(),
17871 }
17872 }
17873 #[doc = "Returns the `AbstractBoatEntityData` layer."]
17874 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
17875 &self.abstract_boat
17876 }
17877 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
17878 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
17879 &mut self.abstract_boat
17880 }
17881 #[doc = "Returns the `VehicleEntityData` layer."]
17882 pub fn vehicle_entity(&self) -> &VehicleEntityData {
17883 &self.abstract_boat.vehicle_entity
17884 }
17885 #[doc = "Returns the mutable `VehicleEntityData` layer."]
17886 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
17887 &mut self.abstract_boat.vehicle_entity
17888 }
17889 #[doc = "Returns the `BaseEntityData` layer."]
17890 pub fn base(&self) -> &BaseEntityData {
17891 &self.abstract_boat.vehicle_entity.base
17892 }
17893 #[doc = "Returns the mutable `BaseEntityData` layer."]
17894 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17895 &mut self.abstract_boat.vehicle_entity.base
17896 }
17897 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17898 #[doc = r" Returns `None` if no values are dirty."]
17899 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17900 self.abstract_boat.pack_dirty()
17901 }
17902 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17903 pub fn pack_all(&self) -> Vec<DataValue> {
17904 self.abstract_boat.pack_all()
17905 }
17906 #[doc = r" Returns `true` if any field has been modified."]
17907 pub fn is_dirty(&self) -> bool {
17908 self.abstract_boat.is_dirty()
17909 }
17910}
17911impl Default for MangroveBoatEntityData {
17912 fn default() -> Self {
17913 Self::new()
17914 }
17915}
17916impl VanillaEntityData for MangroveBoatEntityData {
17917 fn base(&self) -> &BaseEntityData {
17918 MangroveBoatEntityData::base(self)
17919 }
17920 fn base_mut(&mut self) -> &mut BaseEntityData {
17921 MangroveBoatEntityData::base_mut(self)
17922 }
17923 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17924 MangroveBoatEntityData::pack_dirty(self)
17925 }
17926 fn pack_all(&self) -> Vec<DataValue> {
17927 MangroveBoatEntityData::pack_all(self)
17928 }
17929 fn is_dirty(&self) -> bool {
17930 MangroveBoatEntityData::is_dirty(self)
17931 }
17932}
17933#[doc = "Concrete synchronized entity data for vanilla entity `mangrove_chest_boat`."]
17934#[derive(Debug, Clone)]
17935pub struct MangroveChestBoatEntityData {
17936 pub abstract_boat: AbstractBoatEntityData,
17937}
17938impl MangroveChestBoatEntityData {
17939 #[doc = r" Create new entity data with default values."]
17940 pub fn new() -> Self {
17941 Self {
17942 abstract_boat: AbstractBoatEntityData::new(),
17943 }
17944 }
17945 #[doc = "Returns the `AbstractBoatEntityData` layer."]
17946 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
17947 &self.abstract_boat
17948 }
17949 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
17950 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
17951 &mut self.abstract_boat
17952 }
17953 #[doc = "Returns the `VehicleEntityData` layer."]
17954 pub fn vehicle_entity(&self) -> &VehicleEntityData {
17955 &self.abstract_boat.vehicle_entity
17956 }
17957 #[doc = "Returns the mutable `VehicleEntityData` layer."]
17958 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
17959 &mut self.abstract_boat.vehicle_entity
17960 }
17961 #[doc = "Returns the `BaseEntityData` layer."]
17962 pub fn base(&self) -> &BaseEntityData {
17963 &self.abstract_boat.vehicle_entity.base
17964 }
17965 #[doc = "Returns the mutable `BaseEntityData` layer."]
17966 pub fn base_mut(&mut self) -> &mut BaseEntityData {
17967 &mut self.abstract_boat.vehicle_entity.base
17968 }
17969 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
17970 #[doc = r" Returns `None` if no values are dirty."]
17971 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17972 self.abstract_boat.pack_dirty()
17973 }
17974 #[doc = r" Pack all non-default values (for initial entity spawn)."]
17975 pub fn pack_all(&self) -> Vec<DataValue> {
17976 self.abstract_boat.pack_all()
17977 }
17978 #[doc = r" Returns `true` if any field has been modified."]
17979 pub fn is_dirty(&self) -> bool {
17980 self.abstract_boat.is_dirty()
17981 }
17982}
17983impl Default for MangroveChestBoatEntityData {
17984 fn default() -> Self {
17985 Self::new()
17986 }
17987}
17988impl VanillaEntityData for MangroveChestBoatEntityData {
17989 fn base(&self) -> &BaseEntityData {
17990 MangroveChestBoatEntityData::base(self)
17991 }
17992 fn base_mut(&mut self) -> &mut BaseEntityData {
17993 MangroveChestBoatEntityData::base_mut(self)
17994 }
17995 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
17996 MangroveChestBoatEntityData::pack_dirty(self)
17997 }
17998 fn pack_all(&self) -> Vec<DataValue> {
17999 MangroveChestBoatEntityData::pack_all(self)
18000 }
18001 fn is_dirty(&self) -> bool {
18002 MangroveChestBoatEntityData::is_dirty(self)
18003 }
18004}
18005#[doc = "Concrete synchronized entity data for vanilla entity `marker`."]
18006#[derive(Debug, Clone)]
18007pub struct MarkerEntityData {
18008 pub base: BaseEntityData,
18009}
18010impl MarkerEntityData {
18011 #[doc = r" Create new entity data with default values."]
18012 pub fn new() -> Self {
18013 Self {
18014 base: BaseEntityData::new(),
18015 }
18016 }
18017 #[doc = "Returns the `BaseEntityData` layer."]
18018 pub fn base(&self) -> &BaseEntityData {
18019 &self.base
18020 }
18021 #[doc = "Returns the mutable `BaseEntityData` layer."]
18022 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18023 &mut self.base
18024 }
18025 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18026 #[doc = r" Returns `None` if no values are dirty."]
18027 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18028 self.base.pack_dirty()
18029 }
18030 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18031 pub fn pack_all(&self) -> Vec<DataValue> {
18032 self.base.pack_all()
18033 }
18034 #[doc = r" Returns `true` if any field has been modified."]
18035 pub fn is_dirty(&self) -> bool {
18036 self.base.is_dirty()
18037 }
18038}
18039impl Default for MarkerEntityData {
18040 fn default() -> Self {
18041 Self::new()
18042 }
18043}
18044impl VanillaEntityData for MarkerEntityData {
18045 fn base(&self) -> &BaseEntityData {
18046 MarkerEntityData::base(self)
18047 }
18048 fn base_mut(&mut self) -> &mut BaseEntityData {
18049 MarkerEntityData::base_mut(self)
18050 }
18051 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18052 MarkerEntityData::pack_dirty(self)
18053 }
18054 fn pack_all(&self) -> Vec<DataValue> {
18055 MarkerEntityData::pack_all(self)
18056 }
18057 fn is_dirty(&self) -> bool {
18058 MarkerEntityData::is_dirty(self)
18059 }
18060}
18061#[doc = "Concrete synchronized entity data for vanilla entity `minecart`."]
18062#[derive(Debug, Clone)]
18063pub struct MinecartEntityData {
18064 pub abstract_minecart: AbstractMinecartEntityData,
18065}
18066impl MinecartEntityData {
18067 #[doc = r" Create new entity data with default values."]
18068 pub fn new() -> Self {
18069 let mut data = AbstractMinecartEntityData::new();
18070 data.id_display_offset = SyncedValue::new(6i32);
18071 Self {
18072 abstract_minecart: data,
18073 }
18074 }
18075 #[doc = "Returns the `AbstractMinecartEntityData` layer."]
18076 pub fn abstract_minecart(&self) -> &AbstractMinecartEntityData {
18077 &self.abstract_minecart
18078 }
18079 #[doc = "Returns the mutable `AbstractMinecartEntityData` layer."]
18080 pub fn abstract_minecart_mut(&mut self) -> &mut AbstractMinecartEntityData {
18081 &mut self.abstract_minecart
18082 }
18083 #[doc = "Returns the `VehicleEntityData` layer."]
18084 pub fn vehicle_entity(&self) -> &VehicleEntityData {
18085 &self.abstract_minecart.vehicle_entity
18086 }
18087 #[doc = "Returns the mutable `VehicleEntityData` layer."]
18088 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
18089 &mut self.abstract_minecart.vehicle_entity
18090 }
18091 #[doc = "Returns the `BaseEntityData` layer."]
18092 pub fn base(&self) -> &BaseEntityData {
18093 &self.abstract_minecart.vehicle_entity.base
18094 }
18095 #[doc = "Returns the mutable `BaseEntityData` layer."]
18096 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18097 &mut self.abstract_minecart.vehicle_entity.base
18098 }
18099 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18100 #[doc = r" Returns `None` if no values are dirty."]
18101 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18102 self.abstract_minecart.pack_dirty()
18103 }
18104 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18105 pub fn pack_all(&self) -> Vec<DataValue> {
18106 self.abstract_minecart.pack_all()
18107 }
18108 #[doc = r" Returns `true` if any field has been modified."]
18109 pub fn is_dirty(&self) -> bool {
18110 self.abstract_minecart.is_dirty()
18111 }
18112}
18113impl Default for MinecartEntityData {
18114 fn default() -> Self {
18115 Self::new()
18116 }
18117}
18118impl VanillaEntityData for MinecartEntityData {
18119 fn base(&self) -> &BaseEntityData {
18120 MinecartEntityData::base(self)
18121 }
18122 fn base_mut(&mut self) -> &mut BaseEntityData {
18123 MinecartEntityData::base_mut(self)
18124 }
18125 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18126 MinecartEntityData::pack_dirty(self)
18127 }
18128 fn pack_all(&self) -> Vec<DataValue> {
18129 MinecartEntityData::pack_all(self)
18130 }
18131 fn is_dirty(&self) -> bool {
18132 MinecartEntityData::is_dirty(self)
18133 }
18134}
18135#[doc = "Concrete synchronized entity data for vanilla entity `mooshroom`."]
18136#[derive(Debug, Clone)]
18137pub struct MooshroomEntityData {
18138 pub mushroom_cow: MushroomCowEntityData,
18139}
18140impl MooshroomEntityData {
18141 #[doc = r" Create new entity data with default values."]
18142 pub fn new() -> Self {
18143 Self {
18144 mushroom_cow: MushroomCowEntityData::new(),
18145 }
18146 }
18147 #[doc = "Returns the `MushroomCowEntityData` layer."]
18148 pub fn mushroom_cow(&self) -> &MushroomCowEntityData {
18149 &self.mushroom_cow
18150 }
18151 #[doc = "Returns the mutable `MushroomCowEntityData` layer."]
18152 pub fn mushroom_cow_mut(&mut self) -> &mut MushroomCowEntityData {
18153 &mut self.mushroom_cow
18154 }
18155 #[doc = "Returns the `AgeableMobEntityData` layer."]
18156 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
18157 &self.mushroom_cow.ageable_mob
18158 }
18159 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
18160 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
18161 &mut self.mushroom_cow.ageable_mob
18162 }
18163 #[doc = "Returns the `MobEntityData` layer."]
18164 pub fn mob(&self) -> &MobEntityData {
18165 &self.mushroom_cow.ageable_mob.mob
18166 }
18167 #[doc = "Returns the mutable `MobEntityData` layer."]
18168 pub fn mob_mut(&mut self) -> &mut MobEntityData {
18169 &mut self.mushroom_cow.ageable_mob.mob
18170 }
18171 #[doc = "Returns the `LivingEntityData` layer."]
18172 pub fn living_entity(&self) -> &LivingEntityData {
18173 &self.mushroom_cow.ageable_mob.mob.living_entity
18174 }
18175 #[doc = "Returns the mutable `LivingEntityData` layer."]
18176 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
18177 &mut self.mushroom_cow.ageable_mob.mob.living_entity
18178 }
18179 #[doc = "Returns the `BaseEntityData` layer."]
18180 pub fn base(&self) -> &BaseEntityData {
18181 &self.mushroom_cow.ageable_mob.mob.living_entity.base
18182 }
18183 #[doc = "Returns the mutable `BaseEntityData` layer."]
18184 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18185 &mut self.mushroom_cow.ageable_mob.mob.living_entity.base
18186 }
18187 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18188 #[doc = r" Returns `None` if no values are dirty."]
18189 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18190 self.mushroom_cow.pack_dirty()
18191 }
18192 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18193 pub fn pack_all(&self) -> Vec<DataValue> {
18194 self.mushroom_cow.pack_all()
18195 }
18196 #[doc = r" Returns `true` if any field has been modified."]
18197 pub fn is_dirty(&self) -> bool {
18198 self.mushroom_cow.is_dirty()
18199 }
18200}
18201impl Default for MooshroomEntityData {
18202 fn default() -> Self {
18203 Self::new()
18204 }
18205}
18206impl VanillaEntityData for MooshroomEntityData {
18207 fn base(&self) -> &BaseEntityData {
18208 MooshroomEntityData::base(self)
18209 }
18210 fn base_mut(&mut self) -> &mut BaseEntityData {
18211 MooshroomEntityData::base_mut(self)
18212 }
18213 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18214 MooshroomEntityData::pack_dirty(self)
18215 }
18216 fn pack_all(&self) -> Vec<DataValue> {
18217 MooshroomEntityData::pack_all(self)
18218 }
18219 fn is_dirty(&self) -> bool {
18220 MooshroomEntityData::is_dirty(self)
18221 }
18222}
18223impl VanillaLivingEntityData for MooshroomEntityData {
18224 fn living_entity(&self) -> &LivingEntityData {
18225 MooshroomEntityData::living_entity(self)
18226 }
18227 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
18228 MooshroomEntityData::living_entity_mut(self)
18229 }
18230}
18231#[doc = "Concrete synchronized entity data for vanilla entity `mule`."]
18232#[derive(Debug, Clone)]
18233pub struct MuleEntityData {
18234 pub abstract_chested_horse: AbstractChestedHorseEntityData,
18235}
18236impl MuleEntityData {
18237 #[doc = r" Create new entity data with default values."]
18238 pub fn new() -> Self {
18239 Self {
18240 abstract_chested_horse: AbstractChestedHorseEntityData::new(),
18241 }
18242 }
18243 #[doc = "Returns the `AbstractChestedHorseEntityData` layer."]
18244 pub fn abstract_chested_horse(&self) -> &AbstractChestedHorseEntityData {
18245 &self.abstract_chested_horse
18246 }
18247 #[doc = "Returns the mutable `AbstractChestedHorseEntityData` layer."]
18248 pub fn abstract_chested_horse_mut(&mut self) -> &mut AbstractChestedHorseEntityData {
18249 &mut self.abstract_chested_horse
18250 }
18251 #[doc = "Returns the `AbstractHorseEntityData` layer."]
18252 pub fn abstract_horse(&self) -> &AbstractHorseEntityData {
18253 &self.abstract_chested_horse.abstract_horse
18254 }
18255 #[doc = "Returns the mutable `AbstractHorseEntityData` layer."]
18256 pub fn abstract_horse_mut(&mut self) -> &mut AbstractHorseEntityData {
18257 &mut self.abstract_chested_horse.abstract_horse
18258 }
18259 #[doc = "Returns the `AgeableMobEntityData` layer."]
18260 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
18261 &self.abstract_chested_horse.abstract_horse.ageable_mob
18262 }
18263 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
18264 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
18265 &mut self.abstract_chested_horse.abstract_horse.ageable_mob
18266 }
18267 #[doc = "Returns the `MobEntityData` layer."]
18268 pub fn mob(&self) -> &MobEntityData {
18269 &self.abstract_chested_horse.abstract_horse.ageable_mob.mob
18270 }
18271 #[doc = "Returns the mutable `MobEntityData` layer."]
18272 pub fn mob_mut(&mut self) -> &mut MobEntityData {
18273 &mut self.abstract_chested_horse.abstract_horse.ageable_mob.mob
18274 }
18275 #[doc = "Returns the `LivingEntityData` layer."]
18276 pub fn living_entity(&self) -> &LivingEntityData {
18277 &self
18278 .abstract_chested_horse
18279 .abstract_horse
18280 .ageable_mob
18281 .mob
18282 .living_entity
18283 }
18284 #[doc = "Returns the mutable `LivingEntityData` layer."]
18285 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
18286 &mut self
18287 .abstract_chested_horse
18288 .abstract_horse
18289 .ageable_mob
18290 .mob
18291 .living_entity
18292 }
18293 #[doc = "Returns the `BaseEntityData` layer."]
18294 pub fn base(&self) -> &BaseEntityData {
18295 &self
18296 .abstract_chested_horse
18297 .abstract_horse
18298 .ageable_mob
18299 .mob
18300 .living_entity
18301 .base
18302 }
18303 #[doc = "Returns the mutable `BaseEntityData` layer."]
18304 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18305 &mut self
18306 .abstract_chested_horse
18307 .abstract_horse
18308 .ageable_mob
18309 .mob
18310 .living_entity
18311 .base
18312 }
18313 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18314 #[doc = r" Returns `None` if no values are dirty."]
18315 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18316 self.abstract_chested_horse.pack_dirty()
18317 }
18318 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18319 pub fn pack_all(&self) -> Vec<DataValue> {
18320 self.abstract_chested_horse.pack_all()
18321 }
18322 #[doc = r" Returns `true` if any field has been modified."]
18323 pub fn is_dirty(&self) -> bool {
18324 self.abstract_chested_horse.is_dirty()
18325 }
18326}
18327impl Default for MuleEntityData {
18328 fn default() -> Self {
18329 Self::new()
18330 }
18331}
18332impl VanillaEntityData for MuleEntityData {
18333 fn base(&self) -> &BaseEntityData {
18334 MuleEntityData::base(self)
18335 }
18336 fn base_mut(&mut self) -> &mut BaseEntityData {
18337 MuleEntityData::base_mut(self)
18338 }
18339 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18340 MuleEntityData::pack_dirty(self)
18341 }
18342 fn pack_all(&self) -> Vec<DataValue> {
18343 MuleEntityData::pack_all(self)
18344 }
18345 fn is_dirty(&self) -> bool {
18346 MuleEntityData::is_dirty(self)
18347 }
18348}
18349impl VanillaLivingEntityData for MuleEntityData {
18350 fn living_entity(&self) -> &LivingEntityData {
18351 MuleEntityData::living_entity(self)
18352 }
18353 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
18354 MuleEntityData::living_entity_mut(self)
18355 }
18356}
18357#[doc = "Concrete synchronized entity data for vanilla entity `nautilus`."]
18358#[derive(Debug, Clone)]
18359pub struct NautilusEntityData {
18360 pub abstract_nautilus: AbstractNautilusEntityData,
18361}
18362impl NautilusEntityData {
18363 #[doc = r" Create new entity data with default values."]
18364 pub fn new() -> Self {
18365 Self {
18366 abstract_nautilus: AbstractNautilusEntityData::new(),
18367 }
18368 }
18369 #[doc = "Returns the `AbstractNautilusEntityData` layer."]
18370 pub fn abstract_nautilus(&self) -> &AbstractNautilusEntityData {
18371 &self.abstract_nautilus
18372 }
18373 #[doc = "Returns the mutable `AbstractNautilusEntityData` layer."]
18374 pub fn abstract_nautilus_mut(&mut self) -> &mut AbstractNautilusEntityData {
18375 &mut self.abstract_nautilus
18376 }
18377 #[doc = "Returns the `TamableAnimalEntityData` layer."]
18378 pub fn tamable_animal(&self) -> &TamableAnimalEntityData {
18379 &self.abstract_nautilus.tamable_animal
18380 }
18381 #[doc = "Returns the mutable `TamableAnimalEntityData` layer."]
18382 pub fn tamable_animal_mut(&mut self) -> &mut TamableAnimalEntityData {
18383 &mut self.abstract_nautilus.tamable_animal
18384 }
18385 #[doc = "Returns the `AgeableMobEntityData` layer."]
18386 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
18387 &self.abstract_nautilus.tamable_animal.ageable_mob
18388 }
18389 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
18390 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
18391 &mut self.abstract_nautilus.tamable_animal.ageable_mob
18392 }
18393 #[doc = "Returns the `MobEntityData` layer."]
18394 pub fn mob(&self) -> &MobEntityData {
18395 &self.abstract_nautilus.tamable_animal.ageable_mob.mob
18396 }
18397 #[doc = "Returns the mutable `MobEntityData` layer."]
18398 pub fn mob_mut(&mut self) -> &mut MobEntityData {
18399 &mut self.abstract_nautilus.tamable_animal.ageable_mob.mob
18400 }
18401 #[doc = "Returns the `LivingEntityData` layer."]
18402 pub fn living_entity(&self) -> &LivingEntityData {
18403 &self
18404 .abstract_nautilus
18405 .tamable_animal
18406 .ageable_mob
18407 .mob
18408 .living_entity
18409 }
18410 #[doc = "Returns the mutable `LivingEntityData` layer."]
18411 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
18412 &mut self
18413 .abstract_nautilus
18414 .tamable_animal
18415 .ageable_mob
18416 .mob
18417 .living_entity
18418 }
18419 #[doc = "Returns the `BaseEntityData` layer."]
18420 pub fn base(&self) -> &BaseEntityData {
18421 &self
18422 .abstract_nautilus
18423 .tamable_animal
18424 .ageable_mob
18425 .mob
18426 .living_entity
18427 .base
18428 }
18429 #[doc = "Returns the mutable `BaseEntityData` layer."]
18430 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18431 &mut self
18432 .abstract_nautilus
18433 .tamable_animal
18434 .ageable_mob
18435 .mob
18436 .living_entity
18437 .base
18438 }
18439 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18440 #[doc = r" Returns `None` if no values are dirty."]
18441 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18442 self.abstract_nautilus.pack_dirty()
18443 }
18444 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18445 pub fn pack_all(&self) -> Vec<DataValue> {
18446 self.abstract_nautilus.pack_all()
18447 }
18448 #[doc = r" Returns `true` if any field has been modified."]
18449 pub fn is_dirty(&self) -> bool {
18450 self.abstract_nautilus.is_dirty()
18451 }
18452}
18453impl Default for NautilusEntityData {
18454 fn default() -> Self {
18455 Self::new()
18456 }
18457}
18458impl VanillaEntityData for NautilusEntityData {
18459 fn base(&self) -> &BaseEntityData {
18460 NautilusEntityData::base(self)
18461 }
18462 fn base_mut(&mut self) -> &mut BaseEntityData {
18463 NautilusEntityData::base_mut(self)
18464 }
18465 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18466 NautilusEntityData::pack_dirty(self)
18467 }
18468 fn pack_all(&self) -> Vec<DataValue> {
18469 NautilusEntityData::pack_all(self)
18470 }
18471 fn is_dirty(&self) -> bool {
18472 NautilusEntityData::is_dirty(self)
18473 }
18474}
18475impl VanillaLivingEntityData for NautilusEntityData {
18476 fn living_entity(&self) -> &LivingEntityData {
18477 NautilusEntityData::living_entity(self)
18478 }
18479 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
18480 NautilusEntityData::living_entity_mut(self)
18481 }
18482}
18483#[doc = "Concrete synchronized entity data for vanilla entity `oak_boat`."]
18484#[derive(Debug, Clone)]
18485pub struct OakBoatEntityData {
18486 pub abstract_boat: AbstractBoatEntityData,
18487}
18488impl OakBoatEntityData {
18489 #[doc = r" Create new entity data with default values."]
18490 pub fn new() -> Self {
18491 Self {
18492 abstract_boat: AbstractBoatEntityData::new(),
18493 }
18494 }
18495 #[doc = "Returns the `AbstractBoatEntityData` layer."]
18496 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
18497 &self.abstract_boat
18498 }
18499 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
18500 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
18501 &mut self.abstract_boat
18502 }
18503 #[doc = "Returns the `VehicleEntityData` layer."]
18504 pub fn vehicle_entity(&self) -> &VehicleEntityData {
18505 &self.abstract_boat.vehicle_entity
18506 }
18507 #[doc = "Returns the mutable `VehicleEntityData` layer."]
18508 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
18509 &mut self.abstract_boat.vehicle_entity
18510 }
18511 #[doc = "Returns the `BaseEntityData` layer."]
18512 pub fn base(&self) -> &BaseEntityData {
18513 &self.abstract_boat.vehicle_entity.base
18514 }
18515 #[doc = "Returns the mutable `BaseEntityData` layer."]
18516 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18517 &mut self.abstract_boat.vehicle_entity.base
18518 }
18519 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18520 #[doc = r" Returns `None` if no values are dirty."]
18521 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18522 self.abstract_boat.pack_dirty()
18523 }
18524 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18525 pub fn pack_all(&self) -> Vec<DataValue> {
18526 self.abstract_boat.pack_all()
18527 }
18528 #[doc = r" Returns `true` if any field has been modified."]
18529 pub fn is_dirty(&self) -> bool {
18530 self.abstract_boat.is_dirty()
18531 }
18532}
18533impl Default for OakBoatEntityData {
18534 fn default() -> Self {
18535 Self::new()
18536 }
18537}
18538impl VanillaEntityData for OakBoatEntityData {
18539 fn base(&self) -> &BaseEntityData {
18540 OakBoatEntityData::base(self)
18541 }
18542 fn base_mut(&mut self) -> &mut BaseEntityData {
18543 OakBoatEntityData::base_mut(self)
18544 }
18545 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18546 OakBoatEntityData::pack_dirty(self)
18547 }
18548 fn pack_all(&self) -> Vec<DataValue> {
18549 OakBoatEntityData::pack_all(self)
18550 }
18551 fn is_dirty(&self) -> bool {
18552 OakBoatEntityData::is_dirty(self)
18553 }
18554}
18555#[doc = "Concrete synchronized entity data for vanilla entity `oak_chest_boat`."]
18556#[derive(Debug, Clone)]
18557pub struct OakChestBoatEntityData {
18558 pub abstract_boat: AbstractBoatEntityData,
18559}
18560impl OakChestBoatEntityData {
18561 #[doc = r" Create new entity data with default values."]
18562 pub fn new() -> Self {
18563 Self {
18564 abstract_boat: AbstractBoatEntityData::new(),
18565 }
18566 }
18567 #[doc = "Returns the `AbstractBoatEntityData` layer."]
18568 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
18569 &self.abstract_boat
18570 }
18571 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
18572 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
18573 &mut self.abstract_boat
18574 }
18575 #[doc = "Returns the `VehicleEntityData` layer."]
18576 pub fn vehicle_entity(&self) -> &VehicleEntityData {
18577 &self.abstract_boat.vehicle_entity
18578 }
18579 #[doc = "Returns the mutable `VehicleEntityData` layer."]
18580 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
18581 &mut self.abstract_boat.vehicle_entity
18582 }
18583 #[doc = "Returns the `BaseEntityData` layer."]
18584 pub fn base(&self) -> &BaseEntityData {
18585 &self.abstract_boat.vehicle_entity.base
18586 }
18587 #[doc = "Returns the mutable `BaseEntityData` layer."]
18588 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18589 &mut self.abstract_boat.vehicle_entity.base
18590 }
18591 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18592 #[doc = r" Returns `None` if no values are dirty."]
18593 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18594 self.abstract_boat.pack_dirty()
18595 }
18596 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18597 pub fn pack_all(&self) -> Vec<DataValue> {
18598 self.abstract_boat.pack_all()
18599 }
18600 #[doc = r" Returns `true` if any field has been modified."]
18601 pub fn is_dirty(&self) -> bool {
18602 self.abstract_boat.is_dirty()
18603 }
18604}
18605impl Default for OakChestBoatEntityData {
18606 fn default() -> Self {
18607 Self::new()
18608 }
18609}
18610impl VanillaEntityData for OakChestBoatEntityData {
18611 fn base(&self) -> &BaseEntityData {
18612 OakChestBoatEntityData::base(self)
18613 }
18614 fn base_mut(&mut self) -> &mut BaseEntityData {
18615 OakChestBoatEntityData::base_mut(self)
18616 }
18617 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18618 OakChestBoatEntityData::pack_dirty(self)
18619 }
18620 fn pack_all(&self) -> Vec<DataValue> {
18621 OakChestBoatEntityData::pack_all(self)
18622 }
18623 fn is_dirty(&self) -> bool {
18624 OakChestBoatEntityData::is_dirty(self)
18625 }
18626}
18627#[doc = "Concrete synchronized entity data for vanilla entity `pale_oak_boat`."]
18628#[derive(Debug, Clone)]
18629pub struct PaleOakBoatEntityData {
18630 pub abstract_boat: AbstractBoatEntityData,
18631}
18632impl PaleOakBoatEntityData {
18633 #[doc = r" Create new entity data with default values."]
18634 pub fn new() -> Self {
18635 Self {
18636 abstract_boat: AbstractBoatEntityData::new(),
18637 }
18638 }
18639 #[doc = "Returns the `AbstractBoatEntityData` layer."]
18640 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
18641 &self.abstract_boat
18642 }
18643 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
18644 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
18645 &mut self.abstract_boat
18646 }
18647 #[doc = "Returns the `VehicleEntityData` layer."]
18648 pub fn vehicle_entity(&self) -> &VehicleEntityData {
18649 &self.abstract_boat.vehicle_entity
18650 }
18651 #[doc = "Returns the mutable `VehicleEntityData` layer."]
18652 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
18653 &mut self.abstract_boat.vehicle_entity
18654 }
18655 #[doc = "Returns the `BaseEntityData` layer."]
18656 pub fn base(&self) -> &BaseEntityData {
18657 &self.abstract_boat.vehicle_entity.base
18658 }
18659 #[doc = "Returns the mutable `BaseEntityData` layer."]
18660 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18661 &mut self.abstract_boat.vehicle_entity.base
18662 }
18663 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18664 #[doc = r" Returns `None` if no values are dirty."]
18665 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18666 self.abstract_boat.pack_dirty()
18667 }
18668 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18669 pub fn pack_all(&self) -> Vec<DataValue> {
18670 self.abstract_boat.pack_all()
18671 }
18672 #[doc = r" Returns `true` if any field has been modified."]
18673 pub fn is_dirty(&self) -> bool {
18674 self.abstract_boat.is_dirty()
18675 }
18676}
18677impl Default for PaleOakBoatEntityData {
18678 fn default() -> Self {
18679 Self::new()
18680 }
18681}
18682impl VanillaEntityData for PaleOakBoatEntityData {
18683 fn base(&self) -> &BaseEntityData {
18684 PaleOakBoatEntityData::base(self)
18685 }
18686 fn base_mut(&mut self) -> &mut BaseEntityData {
18687 PaleOakBoatEntityData::base_mut(self)
18688 }
18689 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18690 PaleOakBoatEntityData::pack_dirty(self)
18691 }
18692 fn pack_all(&self) -> Vec<DataValue> {
18693 PaleOakBoatEntityData::pack_all(self)
18694 }
18695 fn is_dirty(&self) -> bool {
18696 PaleOakBoatEntityData::is_dirty(self)
18697 }
18698}
18699#[doc = "Concrete synchronized entity data for vanilla entity `pale_oak_chest_boat`."]
18700#[derive(Debug, Clone)]
18701pub struct PaleOakChestBoatEntityData {
18702 pub abstract_boat: AbstractBoatEntityData,
18703}
18704impl PaleOakChestBoatEntityData {
18705 #[doc = r" Create new entity data with default values."]
18706 pub fn new() -> Self {
18707 Self {
18708 abstract_boat: AbstractBoatEntityData::new(),
18709 }
18710 }
18711 #[doc = "Returns the `AbstractBoatEntityData` layer."]
18712 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
18713 &self.abstract_boat
18714 }
18715 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
18716 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
18717 &mut self.abstract_boat
18718 }
18719 #[doc = "Returns the `VehicleEntityData` layer."]
18720 pub fn vehicle_entity(&self) -> &VehicleEntityData {
18721 &self.abstract_boat.vehicle_entity
18722 }
18723 #[doc = "Returns the mutable `VehicleEntityData` layer."]
18724 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
18725 &mut self.abstract_boat.vehicle_entity
18726 }
18727 #[doc = "Returns the `BaseEntityData` layer."]
18728 pub fn base(&self) -> &BaseEntityData {
18729 &self.abstract_boat.vehicle_entity.base
18730 }
18731 #[doc = "Returns the mutable `BaseEntityData` layer."]
18732 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18733 &mut self.abstract_boat.vehicle_entity.base
18734 }
18735 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18736 #[doc = r" Returns `None` if no values are dirty."]
18737 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18738 self.abstract_boat.pack_dirty()
18739 }
18740 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18741 pub fn pack_all(&self) -> Vec<DataValue> {
18742 self.abstract_boat.pack_all()
18743 }
18744 #[doc = r" Returns `true` if any field has been modified."]
18745 pub fn is_dirty(&self) -> bool {
18746 self.abstract_boat.is_dirty()
18747 }
18748}
18749impl Default for PaleOakChestBoatEntityData {
18750 fn default() -> Self {
18751 Self::new()
18752 }
18753}
18754impl VanillaEntityData for PaleOakChestBoatEntityData {
18755 fn base(&self) -> &BaseEntityData {
18756 PaleOakChestBoatEntityData::base(self)
18757 }
18758 fn base_mut(&mut self) -> &mut BaseEntityData {
18759 PaleOakChestBoatEntityData::base_mut(self)
18760 }
18761 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18762 PaleOakChestBoatEntityData::pack_dirty(self)
18763 }
18764 fn pack_all(&self) -> Vec<DataValue> {
18765 PaleOakChestBoatEntityData::pack_all(self)
18766 }
18767 fn is_dirty(&self) -> bool {
18768 PaleOakChestBoatEntityData::is_dirty(self)
18769 }
18770}
18771#[doc = "Concrete synchronized entity data for vanilla entity `parched`."]
18772#[derive(Debug, Clone)]
18773pub struct ParchedEntityData {
18774 pub mob: MobEntityData,
18775}
18776impl ParchedEntityData {
18777 #[doc = r" Create new entity data with default values."]
18778 pub fn new() -> Self {
18779 Self {
18780 mob: MobEntityData::new(),
18781 }
18782 }
18783 #[doc = "Returns the `MobEntityData` layer."]
18784 pub fn mob(&self) -> &MobEntityData {
18785 &self.mob
18786 }
18787 #[doc = "Returns the mutable `MobEntityData` layer."]
18788 pub fn mob_mut(&mut self) -> &mut MobEntityData {
18789 &mut self.mob
18790 }
18791 #[doc = "Returns the `LivingEntityData` layer."]
18792 pub fn living_entity(&self) -> &LivingEntityData {
18793 &self.mob.living_entity
18794 }
18795 #[doc = "Returns the mutable `LivingEntityData` layer."]
18796 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
18797 &mut self.mob.living_entity
18798 }
18799 #[doc = "Returns the `BaseEntityData` layer."]
18800 pub fn base(&self) -> &BaseEntityData {
18801 &self.mob.living_entity.base
18802 }
18803 #[doc = "Returns the mutable `BaseEntityData` layer."]
18804 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18805 &mut self.mob.living_entity.base
18806 }
18807 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18808 #[doc = r" Returns `None` if no values are dirty."]
18809 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18810 self.mob.pack_dirty()
18811 }
18812 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18813 pub fn pack_all(&self) -> Vec<DataValue> {
18814 self.mob.pack_all()
18815 }
18816 #[doc = r" Returns `true` if any field has been modified."]
18817 pub fn is_dirty(&self) -> bool {
18818 self.mob.is_dirty()
18819 }
18820}
18821impl Default for ParchedEntityData {
18822 fn default() -> Self {
18823 Self::new()
18824 }
18825}
18826impl VanillaEntityData for ParchedEntityData {
18827 fn base(&self) -> &BaseEntityData {
18828 ParchedEntityData::base(self)
18829 }
18830 fn base_mut(&mut self) -> &mut BaseEntityData {
18831 ParchedEntityData::base_mut(self)
18832 }
18833 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18834 ParchedEntityData::pack_dirty(self)
18835 }
18836 fn pack_all(&self) -> Vec<DataValue> {
18837 ParchedEntityData::pack_all(self)
18838 }
18839 fn is_dirty(&self) -> bool {
18840 ParchedEntityData::is_dirty(self)
18841 }
18842}
18843impl VanillaLivingEntityData for ParchedEntityData {
18844 fn living_entity(&self) -> &LivingEntityData {
18845 ParchedEntityData::living_entity(self)
18846 }
18847 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
18848 ParchedEntityData::living_entity_mut(self)
18849 }
18850}
18851#[doc = "Concrete synchronized entity data for vanilla entity `piglin_brute`."]
18852#[derive(Debug, Clone)]
18853pub struct PiglinBruteEntityData {
18854 pub abstract_piglin: AbstractPiglinEntityData,
18855}
18856impl PiglinBruteEntityData {
18857 #[doc = r" Create new entity data with default values."]
18858 pub fn new() -> Self {
18859 Self {
18860 abstract_piglin: AbstractPiglinEntityData::new(),
18861 }
18862 }
18863 #[doc = "Returns the `AbstractPiglinEntityData` layer."]
18864 pub fn abstract_piglin(&self) -> &AbstractPiglinEntityData {
18865 &self.abstract_piglin
18866 }
18867 #[doc = "Returns the mutable `AbstractPiglinEntityData` layer."]
18868 pub fn abstract_piglin_mut(&mut self) -> &mut AbstractPiglinEntityData {
18869 &mut self.abstract_piglin
18870 }
18871 #[doc = "Returns the `MobEntityData` layer."]
18872 pub fn mob(&self) -> &MobEntityData {
18873 &self.abstract_piglin.mob
18874 }
18875 #[doc = "Returns the mutable `MobEntityData` layer."]
18876 pub fn mob_mut(&mut self) -> &mut MobEntityData {
18877 &mut self.abstract_piglin.mob
18878 }
18879 #[doc = "Returns the `LivingEntityData` layer."]
18880 pub fn living_entity(&self) -> &LivingEntityData {
18881 &self.abstract_piglin.mob.living_entity
18882 }
18883 #[doc = "Returns the mutable `LivingEntityData` layer."]
18884 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
18885 &mut self.abstract_piglin.mob.living_entity
18886 }
18887 #[doc = "Returns the `BaseEntityData` layer."]
18888 pub fn base(&self) -> &BaseEntityData {
18889 &self.abstract_piglin.mob.living_entity.base
18890 }
18891 #[doc = "Returns the mutable `BaseEntityData` layer."]
18892 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18893 &mut self.abstract_piglin.mob.living_entity.base
18894 }
18895 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18896 #[doc = r" Returns `None` if no values are dirty."]
18897 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18898 self.abstract_piglin.pack_dirty()
18899 }
18900 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18901 pub fn pack_all(&self) -> Vec<DataValue> {
18902 self.abstract_piglin.pack_all()
18903 }
18904 #[doc = r" Returns `true` if any field has been modified."]
18905 pub fn is_dirty(&self) -> bool {
18906 self.abstract_piglin.is_dirty()
18907 }
18908}
18909impl Default for PiglinBruteEntityData {
18910 fn default() -> Self {
18911 Self::new()
18912 }
18913}
18914impl VanillaEntityData for PiglinBruteEntityData {
18915 fn base(&self) -> &BaseEntityData {
18916 PiglinBruteEntityData::base(self)
18917 }
18918 fn base_mut(&mut self) -> &mut BaseEntityData {
18919 PiglinBruteEntityData::base_mut(self)
18920 }
18921 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18922 PiglinBruteEntityData::pack_dirty(self)
18923 }
18924 fn pack_all(&self) -> Vec<DataValue> {
18925 PiglinBruteEntityData::pack_all(self)
18926 }
18927 fn is_dirty(&self) -> bool {
18928 PiglinBruteEntityData::is_dirty(self)
18929 }
18930}
18931impl VanillaLivingEntityData for PiglinBruteEntityData {
18932 fn living_entity(&self) -> &LivingEntityData {
18933 PiglinBruteEntityData::living_entity(self)
18934 }
18935 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
18936 PiglinBruteEntityData::living_entity_mut(self)
18937 }
18938}
18939#[doc = "Concrete synchronized entity data for vanilla entity `splash_potion`."]
18940#[derive(Debug, Clone)]
18941pub struct SplashPotionEntityData {
18942 pub throwable_item_projectile: ThrowableItemProjectileEntityData,
18943}
18944impl SplashPotionEntityData {
18945 #[doc = r" Create new entity data with default values."]
18946 pub fn new() -> Self {
18947 let mut data = ThrowableItemProjectileEntityData::new();
18948 data.item_stack = SyncedValue::new(ItemStack::with_count(
18949 &crate::vanilla_items::ITEMS.splash_potion,
18950 1i32,
18951 ));
18952 Self {
18953 throwable_item_projectile: data,
18954 }
18955 }
18956 #[doc = "Returns the `ThrowableItemProjectileEntityData` layer."]
18957 pub fn throwable_item_projectile(&self) -> &ThrowableItemProjectileEntityData {
18958 &self.throwable_item_projectile
18959 }
18960 #[doc = "Returns the mutable `ThrowableItemProjectileEntityData` layer."]
18961 pub fn throwable_item_projectile_mut(&mut self) -> &mut ThrowableItemProjectileEntityData {
18962 &mut self.throwable_item_projectile
18963 }
18964 #[doc = "Returns the `BaseEntityData` layer."]
18965 pub fn base(&self) -> &BaseEntityData {
18966 &self.throwable_item_projectile.base
18967 }
18968 #[doc = "Returns the mutable `BaseEntityData` layer."]
18969 pub fn base_mut(&mut self) -> &mut BaseEntityData {
18970 &mut self.throwable_item_projectile.base
18971 }
18972 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
18973 #[doc = r" Returns `None` if no values are dirty."]
18974 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18975 self.throwable_item_projectile.pack_dirty()
18976 }
18977 #[doc = r" Pack all non-default values (for initial entity spawn)."]
18978 pub fn pack_all(&self) -> Vec<DataValue> {
18979 self.throwable_item_projectile.pack_all()
18980 }
18981 #[doc = r" Returns `true` if any field has been modified."]
18982 pub fn is_dirty(&self) -> bool {
18983 self.throwable_item_projectile.is_dirty()
18984 }
18985}
18986impl Default for SplashPotionEntityData {
18987 fn default() -> Self {
18988 Self::new()
18989 }
18990}
18991impl VanillaEntityData for SplashPotionEntityData {
18992 fn base(&self) -> &BaseEntityData {
18993 SplashPotionEntityData::base(self)
18994 }
18995 fn base_mut(&mut self) -> &mut BaseEntityData {
18996 SplashPotionEntityData::base_mut(self)
18997 }
18998 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
18999 SplashPotionEntityData::pack_dirty(self)
19000 }
19001 fn pack_all(&self) -> Vec<DataValue> {
19002 SplashPotionEntityData::pack_all(self)
19003 }
19004 fn is_dirty(&self) -> bool {
19005 SplashPotionEntityData::is_dirty(self)
19006 }
19007}
19008#[doc = "Concrete synchronized entity data for vanilla entity `lingering_potion`."]
19009#[derive(Debug, Clone)]
19010pub struct LingeringPotionEntityData {
19011 pub throwable_item_projectile: ThrowableItemProjectileEntityData,
19012}
19013impl LingeringPotionEntityData {
19014 #[doc = r" Create new entity data with default values."]
19015 pub fn new() -> Self {
19016 let mut data = ThrowableItemProjectileEntityData::new();
19017 data.item_stack = SyncedValue::new(ItemStack::with_count(
19018 &crate::vanilla_items::ITEMS.lingering_potion,
19019 1i32,
19020 ));
19021 Self {
19022 throwable_item_projectile: data,
19023 }
19024 }
19025 #[doc = "Returns the `ThrowableItemProjectileEntityData` layer."]
19026 pub fn throwable_item_projectile(&self) -> &ThrowableItemProjectileEntityData {
19027 &self.throwable_item_projectile
19028 }
19029 #[doc = "Returns the mutable `ThrowableItemProjectileEntityData` layer."]
19030 pub fn throwable_item_projectile_mut(&mut self) -> &mut ThrowableItemProjectileEntityData {
19031 &mut self.throwable_item_projectile
19032 }
19033 #[doc = "Returns the `BaseEntityData` layer."]
19034 pub fn base(&self) -> &BaseEntityData {
19035 &self.throwable_item_projectile.base
19036 }
19037 #[doc = "Returns the mutable `BaseEntityData` layer."]
19038 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19039 &mut self.throwable_item_projectile.base
19040 }
19041 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19042 #[doc = r" Returns `None` if no values are dirty."]
19043 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19044 self.throwable_item_projectile.pack_dirty()
19045 }
19046 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19047 pub fn pack_all(&self) -> Vec<DataValue> {
19048 self.throwable_item_projectile.pack_all()
19049 }
19050 #[doc = r" Returns `true` if any field has been modified."]
19051 pub fn is_dirty(&self) -> bool {
19052 self.throwable_item_projectile.is_dirty()
19053 }
19054}
19055impl Default for LingeringPotionEntityData {
19056 fn default() -> Self {
19057 Self::new()
19058 }
19059}
19060impl VanillaEntityData for LingeringPotionEntityData {
19061 fn base(&self) -> &BaseEntityData {
19062 LingeringPotionEntityData::base(self)
19063 }
19064 fn base_mut(&mut self) -> &mut BaseEntityData {
19065 LingeringPotionEntityData::base_mut(self)
19066 }
19067 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19068 LingeringPotionEntityData::pack_dirty(self)
19069 }
19070 fn pack_all(&self) -> Vec<DataValue> {
19071 LingeringPotionEntityData::pack_all(self)
19072 }
19073 fn is_dirty(&self) -> bool {
19074 LingeringPotionEntityData::is_dirty(self)
19075 }
19076}
19077#[doc = "Concrete synchronized entity data for vanilla entity `ravager`."]
19078#[derive(Debug, Clone)]
19079pub struct RavagerEntityData {
19080 pub raider: RaiderEntityData,
19081}
19082impl RavagerEntityData {
19083 #[doc = r" Create new entity data with default values."]
19084 pub fn new() -> Self {
19085 Self {
19086 raider: RaiderEntityData::new(),
19087 }
19088 }
19089 #[doc = "Returns the `RaiderEntityData` layer."]
19090 pub fn raider(&self) -> &RaiderEntityData {
19091 &self.raider
19092 }
19093 #[doc = "Returns the mutable `RaiderEntityData` layer."]
19094 pub fn raider_mut(&mut self) -> &mut RaiderEntityData {
19095 &mut self.raider
19096 }
19097 #[doc = "Returns the `MobEntityData` layer."]
19098 pub fn mob(&self) -> &MobEntityData {
19099 &self.raider.mob
19100 }
19101 #[doc = "Returns the mutable `MobEntityData` layer."]
19102 pub fn mob_mut(&mut self) -> &mut MobEntityData {
19103 &mut self.raider.mob
19104 }
19105 #[doc = "Returns the `LivingEntityData` layer."]
19106 pub fn living_entity(&self) -> &LivingEntityData {
19107 &self.raider.mob.living_entity
19108 }
19109 #[doc = "Returns the mutable `LivingEntityData` layer."]
19110 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
19111 &mut self.raider.mob.living_entity
19112 }
19113 #[doc = "Returns the `BaseEntityData` layer."]
19114 pub fn base(&self) -> &BaseEntityData {
19115 &self.raider.mob.living_entity.base
19116 }
19117 #[doc = "Returns the mutable `BaseEntityData` layer."]
19118 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19119 &mut self.raider.mob.living_entity.base
19120 }
19121 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19122 #[doc = r" Returns `None` if no values are dirty."]
19123 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19124 self.raider.pack_dirty()
19125 }
19126 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19127 pub fn pack_all(&self) -> Vec<DataValue> {
19128 self.raider.pack_all()
19129 }
19130 #[doc = r" Returns `true` if any field has been modified."]
19131 pub fn is_dirty(&self) -> bool {
19132 self.raider.is_dirty()
19133 }
19134}
19135impl Default for RavagerEntityData {
19136 fn default() -> Self {
19137 Self::new()
19138 }
19139}
19140impl VanillaEntityData for RavagerEntityData {
19141 fn base(&self) -> &BaseEntityData {
19142 RavagerEntityData::base(self)
19143 }
19144 fn base_mut(&mut self) -> &mut BaseEntityData {
19145 RavagerEntityData::base_mut(self)
19146 }
19147 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19148 RavagerEntityData::pack_dirty(self)
19149 }
19150 fn pack_all(&self) -> Vec<DataValue> {
19151 RavagerEntityData::pack_all(self)
19152 }
19153 fn is_dirty(&self) -> bool {
19154 RavagerEntityData::is_dirty(self)
19155 }
19156}
19157impl VanillaLivingEntityData for RavagerEntityData {
19158 fn living_entity(&self) -> &LivingEntityData {
19159 RavagerEntityData::living_entity(self)
19160 }
19161 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
19162 RavagerEntityData::living_entity_mut(self)
19163 }
19164}
19165#[doc = "Concrete synchronized entity data for vanilla entity `shulker_bullet`."]
19166#[derive(Debug, Clone)]
19167pub struct ShulkerBulletEntityData {
19168 pub base: BaseEntityData,
19169}
19170impl ShulkerBulletEntityData {
19171 #[doc = r" Create new entity data with default values."]
19172 pub fn new() -> Self {
19173 Self {
19174 base: BaseEntityData::new(),
19175 }
19176 }
19177 #[doc = "Returns the `BaseEntityData` layer."]
19178 pub fn base(&self) -> &BaseEntityData {
19179 &self.base
19180 }
19181 #[doc = "Returns the mutable `BaseEntityData` layer."]
19182 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19183 &mut self.base
19184 }
19185 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19186 #[doc = r" Returns `None` if no values are dirty."]
19187 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19188 self.base.pack_dirty()
19189 }
19190 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19191 pub fn pack_all(&self) -> Vec<DataValue> {
19192 self.base.pack_all()
19193 }
19194 #[doc = r" Returns `true` if any field has been modified."]
19195 pub fn is_dirty(&self) -> bool {
19196 self.base.is_dirty()
19197 }
19198}
19199impl Default for ShulkerBulletEntityData {
19200 fn default() -> Self {
19201 Self::new()
19202 }
19203}
19204impl VanillaEntityData for ShulkerBulletEntityData {
19205 fn base(&self) -> &BaseEntityData {
19206 ShulkerBulletEntityData::base(self)
19207 }
19208 fn base_mut(&mut self) -> &mut BaseEntityData {
19209 ShulkerBulletEntityData::base_mut(self)
19210 }
19211 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19212 ShulkerBulletEntityData::pack_dirty(self)
19213 }
19214 fn pack_all(&self) -> Vec<DataValue> {
19215 ShulkerBulletEntityData::pack_all(self)
19216 }
19217 fn is_dirty(&self) -> bool {
19218 ShulkerBulletEntityData::is_dirty(self)
19219 }
19220}
19221#[doc = "Concrete synchronized entity data for vanilla entity `silverfish`."]
19222#[derive(Debug, Clone)]
19223pub struct SilverfishEntityData {
19224 pub mob: MobEntityData,
19225}
19226impl SilverfishEntityData {
19227 #[doc = r" Create new entity data with default values."]
19228 pub fn new() -> Self {
19229 Self {
19230 mob: MobEntityData::new(),
19231 }
19232 }
19233 #[doc = "Returns the `MobEntityData` layer."]
19234 pub fn mob(&self) -> &MobEntityData {
19235 &self.mob
19236 }
19237 #[doc = "Returns the mutable `MobEntityData` layer."]
19238 pub fn mob_mut(&mut self) -> &mut MobEntityData {
19239 &mut self.mob
19240 }
19241 #[doc = "Returns the `LivingEntityData` layer."]
19242 pub fn living_entity(&self) -> &LivingEntityData {
19243 &self.mob.living_entity
19244 }
19245 #[doc = "Returns the mutable `LivingEntityData` layer."]
19246 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
19247 &mut self.mob.living_entity
19248 }
19249 #[doc = "Returns the `BaseEntityData` layer."]
19250 pub fn base(&self) -> &BaseEntityData {
19251 &self.mob.living_entity.base
19252 }
19253 #[doc = "Returns the mutable `BaseEntityData` layer."]
19254 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19255 &mut self.mob.living_entity.base
19256 }
19257 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19258 #[doc = r" Returns `None` if no values are dirty."]
19259 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19260 self.mob.pack_dirty()
19261 }
19262 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19263 pub fn pack_all(&self) -> Vec<DataValue> {
19264 self.mob.pack_all()
19265 }
19266 #[doc = r" Returns `true` if any field has been modified."]
19267 pub fn is_dirty(&self) -> bool {
19268 self.mob.is_dirty()
19269 }
19270}
19271impl Default for SilverfishEntityData {
19272 fn default() -> Self {
19273 Self::new()
19274 }
19275}
19276impl VanillaEntityData for SilverfishEntityData {
19277 fn base(&self) -> &BaseEntityData {
19278 SilverfishEntityData::base(self)
19279 }
19280 fn base_mut(&mut self) -> &mut BaseEntityData {
19281 SilverfishEntityData::base_mut(self)
19282 }
19283 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19284 SilverfishEntityData::pack_dirty(self)
19285 }
19286 fn pack_all(&self) -> Vec<DataValue> {
19287 SilverfishEntityData::pack_all(self)
19288 }
19289 fn is_dirty(&self) -> bool {
19290 SilverfishEntityData::is_dirty(self)
19291 }
19292}
19293impl VanillaLivingEntityData for SilverfishEntityData {
19294 fn living_entity(&self) -> &LivingEntityData {
19295 SilverfishEntityData::living_entity(self)
19296 }
19297 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
19298 SilverfishEntityData::living_entity_mut(self)
19299 }
19300}
19301#[doc = "Concrete synchronized entity data for vanilla entity `skeleton_horse`."]
19302#[derive(Debug, Clone)]
19303pub struct SkeletonHorseEntityData {
19304 pub abstract_horse: AbstractHorseEntityData,
19305}
19306impl SkeletonHorseEntityData {
19307 #[doc = r" Create new entity data with default values."]
19308 pub fn new() -> Self {
19309 Self {
19310 abstract_horse: AbstractHorseEntityData::new(),
19311 }
19312 }
19313 #[doc = "Returns the `AbstractHorseEntityData` layer."]
19314 pub fn abstract_horse(&self) -> &AbstractHorseEntityData {
19315 &self.abstract_horse
19316 }
19317 #[doc = "Returns the mutable `AbstractHorseEntityData` layer."]
19318 pub fn abstract_horse_mut(&mut self) -> &mut AbstractHorseEntityData {
19319 &mut self.abstract_horse
19320 }
19321 #[doc = "Returns the `AgeableMobEntityData` layer."]
19322 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
19323 &self.abstract_horse.ageable_mob
19324 }
19325 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
19326 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
19327 &mut self.abstract_horse.ageable_mob
19328 }
19329 #[doc = "Returns the `MobEntityData` layer."]
19330 pub fn mob(&self) -> &MobEntityData {
19331 &self.abstract_horse.ageable_mob.mob
19332 }
19333 #[doc = "Returns the mutable `MobEntityData` layer."]
19334 pub fn mob_mut(&mut self) -> &mut MobEntityData {
19335 &mut self.abstract_horse.ageable_mob.mob
19336 }
19337 #[doc = "Returns the `LivingEntityData` layer."]
19338 pub fn living_entity(&self) -> &LivingEntityData {
19339 &self.abstract_horse.ageable_mob.mob.living_entity
19340 }
19341 #[doc = "Returns the mutable `LivingEntityData` layer."]
19342 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
19343 &mut self.abstract_horse.ageable_mob.mob.living_entity
19344 }
19345 #[doc = "Returns the `BaseEntityData` layer."]
19346 pub fn base(&self) -> &BaseEntityData {
19347 &self.abstract_horse.ageable_mob.mob.living_entity.base
19348 }
19349 #[doc = "Returns the mutable `BaseEntityData` layer."]
19350 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19351 &mut self.abstract_horse.ageable_mob.mob.living_entity.base
19352 }
19353 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19354 #[doc = r" Returns `None` if no values are dirty."]
19355 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19356 self.abstract_horse.pack_dirty()
19357 }
19358 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19359 pub fn pack_all(&self) -> Vec<DataValue> {
19360 self.abstract_horse.pack_all()
19361 }
19362 #[doc = r" Returns `true` if any field has been modified."]
19363 pub fn is_dirty(&self) -> bool {
19364 self.abstract_horse.is_dirty()
19365 }
19366}
19367impl Default for SkeletonHorseEntityData {
19368 fn default() -> Self {
19369 Self::new()
19370 }
19371}
19372impl VanillaEntityData for SkeletonHorseEntityData {
19373 fn base(&self) -> &BaseEntityData {
19374 SkeletonHorseEntityData::base(self)
19375 }
19376 fn base_mut(&mut self) -> &mut BaseEntityData {
19377 SkeletonHorseEntityData::base_mut(self)
19378 }
19379 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19380 SkeletonHorseEntityData::pack_dirty(self)
19381 }
19382 fn pack_all(&self) -> Vec<DataValue> {
19383 SkeletonHorseEntityData::pack_all(self)
19384 }
19385 fn is_dirty(&self) -> bool {
19386 SkeletonHorseEntityData::is_dirty(self)
19387 }
19388}
19389impl VanillaLivingEntityData for SkeletonHorseEntityData {
19390 fn living_entity(&self) -> &LivingEntityData {
19391 SkeletonHorseEntityData::living_entity(self)
19392 }
19393 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
19394 SkeletonHorseEntityData::living_entity_mut(self)
19395 }
19396}
19397#[doc = "Concrete synchronized entity data for vanilla entity `small_fireball`."]
19398#[derive(Debug, Clone)]
19399pub struct SmallFireballEntityData {
19400 pub fireball: FireballEntityData,
19401}
19402impl SmallFireballEntityData {
19403 #[doc = r" Create new entity data with default values."]
19404 pub fn new() -> Self {
19405 Self {
19406 fireball: FireballEntityData::new(),
19407 }
19408 }
19409 #[doc = "Returns the `FireballEntityData` layer."]
19410 pub fn fireball(&self) -> &FireballEntityData {
19411 &self.fireball
19412 }
19413 #[doc = "Returns the mutable `FireballEntityData` layer."]
19414 pub fn fireball_mut(&mut self) -> &mut FireballEntityData {
19415 &mut self.fireball
19416 }
19417 #[doc = "Returns the `BaseEntityData` layer."]
19418 pub fn base(&self) -> &BaseEntityData {
19419 &self.fireball.base
19420 }
19421 #[doc = "Returns the mutable `BaseEntityData` layer."]
19422 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19423 &mut self.fireball.base
19424 }
19425 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19426 #[doc = r" Returns `None` if no values are dirty."]
19427 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19428 self.fireball.pack_dirty()
19429 }
19430 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19431 pub fn pack_all(&self) -> Vec<DataValue> {
19432 self.fireball.pack_all()
19433 }
19434 #[doc = r" Returns `true` if any field has been modified."]
19435 pub fn is_dirty(&self) -> bool {
19436 self.fireball.is_dirty()
19437 }
19438}
19439impl Default for SmallFireballEntityData {
19440 fn default() -> Self {
19441 Self::new()
19442 }
19443}
19444impl VanillaEntityData for SmallFireballEntityData {
19445 fn base(&self) -> &BaseEntityData {
19446 SmallFireballEntityData::base(self)
19447 }
19448 fn base_mut(&mut self) -> &mut BaseEntityData {
19449 SmallFireballEntityData::base_mut(self)
19450 }
19451 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19452 SmallFireballEntityData::pack_dirty(self)
19453 }
19454 fn pack_all(&self) -> Vec<DataValue> {
19455 SmallFireballEntityData::pack_all(self)
19456 }
19457 fn is_dirty(&self) -> bool {
19458 SmallFireballEntityData::is_dirty(self)
19459 }
19460}
19461#[doc = "Concrete synchronized entity data for vanilla entity `snowball`."]
19462#[derive(Debug, Clone)]
19463pub struct SnowballEntityData {
19464 pub throwable_item_projectile: ThrowableItemProjectileEntityData,
19465}
19466impl SnowballEntityData {
19467 #[doc = r" Create new entity data with default values."]
19468 pub fn new() -> Self {
19469 let mut data = ThrowableItemProjectileEntityData::new();
19470 data.item_stack = SyncedValue::new(ItemStack::with_count(
19471 &crate::vanilla_items::ITEMS.snowball,
19472 1i32,
19473 ));
19474 Self {
19475 throwable_item_projectile: data,
19476 }
19477 }
19478 #[doc = "Returns the `ThrowableItemProjectileEntityData` layer."]
19479 pub fn throwable_item_projectile(&self) -> &ThrowableItemProjectileEntityData {
19480 &self.throwable_item_projectile
19481 }
19482 #[doc = "Returns the mutable `ThrowableItemProjectileEntityData` layer."]
19483 pub fn throwable_item_projectile_mut(&mut self) -> &mut ThrowableItemProjectileEntityData {
19484 &mut self.throwable_item_projectile
19485 }
19486 #[doc = "Returns the `BaseEntityData` layer."]
19487 pub fn base(&self) -> &BaseEntityData {
19488 &self.throwable_item_projectile.base
19489 }
19490 #[doc = "Returns the mutable `BaseEntityData` layer."]
19491 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19492 &mut self.throwable_item_projectile.base
19493 }
19494 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19495 #[doc = r" Returns `None` if no values are dirty."]
19496 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19497 self.throwable_item_projectile.pack_dirty()
19498 }
19499 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19500 pub fn pack_all(&self) -> Vec<DataValue> {
19501 self.throwable_item_projectile.pack_all()
19502 }
19503 #[doc = r" Returns `true` if any field has been modified."]
19504 pub fn is_dirty(&self) -> bool {
19505 self.throwable_item_projectile.is_dirty()
19506 }
19507}
19508impl Default for SnowballEntityData {
19509 fn default() -> Self {
19510 Self::new()
19511 }
19512}
19513impl VanillaEntityData for SnowballEntityData {
19514 fn base(&self) -> &BaseEntityData {
19515 SnowballEntityData::base(self)
19516 }
19517 fn base_mut(&mut self) -> &mut BaseEntityData {
19518 SnowballEntityData::base_mut(self)
19519 }
19520 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19521 SnowballEntityData::pack_dirty(self)
19522 }
19523 fn pack_all(&self) -> Vec<DataValue> {
19524 SnowballEntityData::pack_all(self)
19525 }
19526 fn is_dirty(&self) -> bool {
19527 SnowballEntityData::is_dirty(self)
19528 }
19529}
19530#[doc = "Concrete synchronized entity data for vanilla entity `spawner_minecart`."]
19531#[derive(Debug, Clone)]
19532pub struct SpawnerMinecartEntityData {
19533 pub abstract_minecart: AbstractMinecartEntityData,
19534}
19535impl SpawnerMinecartEntityData {
19536 #[doc = r" Create new entity data with default values."]
19537 pub fn new() -> Self {
19538 let mut data = AbstractMinecartEntityData::new();
19539 data.id_display_offset = SyncedValue::new(6i32);
19540 Self {
19541 abstract_minecart: data,
19542 }
19543 }
19544 #[doc = "Returns the `AbstractMinecartEntityData` layer."]
19545 pub fn abstract_minecart(&self) -> &AbstractMinecartEntityData {
19546 &self.abstract_minecart
19547 }
19548 #[doc = "Returns the mutable `AbstractMinecartEntityData` layer."]
19549 pub fn abstract_minecart_mut(&mut self) -> &mut AbstractMinecartEntityData {
19550 &mut self.abstract_minecart
19551 }
19552 #[doc = "Returns the `VehicleEntityData` layer."]
19553 pub fn vehicle_entity(&self) -> &VehicleEntityData {
19554 &self.abstract_minecart.vehicle_entity
19555 }
19556 #[doc = "Returns the mutable `VehicleEntityData` layer."]
19557 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
19558 &mut self.abstract_minecart.vehicle_entity
19559 }
19560 #[doc = "Returns the `BaseEntityData` layer."]
19561 pub fn base(&self) -> &BaseEntityData {
19562 &self.abstract_minecart.vehicle_entity.base
19563 }
19564 #[doc = "Returns the mutable `BaseEntityData` layer."]
19565 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19566 &mut self.abstract_minecart.vehicle_entity.base
19567 }
19568 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19569 #[doc = r" Returns `None` if no values are dirty."]
19570 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19571 self.abstract_minecart.pack_dirty()
19572 }
19573 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19574 pub fn pack_all(&self) -> Vec<DataValue> {
19575 self.abstract_minecart.pack_all()
19576 }
19577 #[doc = r" Returns `true` if any field has been modified."]
19578 pub fn is_dirty(&self) -> bool {
19579 self.abstract_minecart.is_dirty()
19580 }
19581}
19582impl Default for SpawnerMinecartEntityData {
19583 fn default() -> Self {
19584 Self::new()
19585 }
19586}
19587impl VanillaEntityData for SpawnerMinecartEntityData {
19588 fn base(&self) -> &BaseEntityData {
19589 SpawnerMinecartEntityData::base(self)
19590 }
19591 fn base_mut(&mut self) -> &mut BaseEntityData {
19592 SpawnerMinecartEntityData::base_mut(self)
19593 }
19594 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19595 SpawnerMinecartEntityData::pack_dirty(self)
19596 }
19597 fn pack_all(&self) -> Vec<DataValue> {
19598 SpawnerMinecartEntityData::pack_all(self)
19599 }
19600 fn is_dirty(&self) -> bool {
19601 SpawnerMinecartEntityData::is_dirty(self)
19602 }
19603}
19604#[doc = "Concrete synchronized entity data for vanilla entity `spectral_arrow`."]
19605#[derive(Debug, Clone)]
19606pub struct SpectralArrowEntityData {
19607 pub abstract_arrow: AbstractArrowEntityData,
19608}
19609impl SpectralArrowEntityData {
19610 #[doc = r" Create new entity data with default values."]
19611 pub fn new() -> Self {
19612 Self {
19613 abstract_arrow: AbstractArrowEntityData::new(),
19614 }
19615 }
19616 #[doc = "Returns the `AbstractArrowEntityData` layer."]
19617 pub fn abstract_arrow(&self) -> &AbstractArrowEntityData {
19618 &self.abstract_arrow
19619 }
19620 #[doc = "Returns the mutable `AbstractArrowEntityData` layer."]
19621 pub fn abstract_arrow_mut(&mut self) -> &mut AbstractArrowEntityData {
19622 &mut self.abstract_arrow
19623 }
19624 #[doc = "Returns the `BaseEntityData` layer."]
19625 pub fn base(&self) -> &BaseEntityData {
19626 &self.abstract_arrow.base
19627 }
19628 #[doc = "Returns the mutable `BaseEntityData` layer."]
19629 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19630 &mut self.abstract_arrow.base
19631 }
19632 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19633 #[doc = r" Returns `None` if no values are dirty."]
19634 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19635 self.abstract_arrow.pack_dirty()
19636 }
19637 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19638 pub fn pack_all(&self) -> Vec<DataValue> {
19639 self.abstract_arrow.pack_all()
19640 }
19641 #[doc = r" Returns `true` if any field has been modified."]
19642 pub fn is_dirty(&self) -> bool {
19643 self.abstract_arrow.is_dirty()
19644 }
19645}
19646impl Default for SpectralArrowEntityData {
19647 fn default() -> Self {
19648 Self::new()
19649 }
19650}
19651impl VanillaEntityData for SpectralArrowEntityData {
19652 fn base(&self) -> &BaseEntityData {
19653 SpectralArrowEntityData::base(self)
19654 }
19655 fn base_mut(&mut self) -> &mut BaseEntityData {
19656 SpectralArrowEntityData::base_mut(self)
19657 }
19658 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19659 SpectralArrowEntityData::pack_dirty(self)
19660 }
19661 fn pack_all(&self) -> Vec<DataValue> {
19662 SpectralArrowEntityData::pack_all(self)
19663 }
19664 fn is_dirty(&self) -> bool {
19665 SpectralArrowEntityData::is_dirty(self)
19666 }
19667}
19668#[doc = "Concrete synchronized entity data for vanilla entity `spruce_boat`."]
19669#[derive(Debug, Clone)]
19670pub struct SpruceBoatEntityData {
19671 pub abstract_boat: AbstractBoatEntityData,
19672}
19673impl SpruceBoatEntityData {
19674 #[doc = r" Create new entity data with default values."]
19675 pub fn new() -> Self {
19676 Self {
19677 abstract_boat: AbstractBoatEntityData::new(),
19678 }
19679 }
19680 #[doc = "Returns the `AbstractBoatEntityData` layer."]
19681 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
19682 &self.abstract_boat
19683 }
19684 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
19685 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
19686 &mut self.abstract_boat
19687 }
19688 #[doc = "Returns the `VehicleEntityData` layer."]
19689 pub fn vehicle_entity(&self) -> &VehicleEntityData {
19690 &self.abstract_boat.vehicle_entity
19691 }
19692 #[doc = "Returns the mutable `VehicleEntityData` layer."]
19693 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
19694 &mut self.abstract_boat.vehicle_entity
19695 }
19696 #[doc = "Returns the `BaseEntityData` layer."]
19697 pub fn base(&self) -> &BaseEntityData {
19698 &self.abstract_boat.vehicle_entity.base
19699 }
19700 #[doc = "Returns the mutable `BaseEntityData` layer."]
19701 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19702 &mut self.abstract_boat.vehicle_entity.base
19703 }
19704 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19705 #[doc = r" Returns `None` if no values are dirty."]
19706 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19707 self.abstract_boat.pack_dirty()
19708 }
19709 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19710 pub fn pack_all(&self) -> Vec<DataValue> {
19711 self.abstract_boat.pack_all()
19712 }
19713 #[doc = r" Returns `true` if any field has been modified."]
19714 pub fn is_dirty(&self) -> bool {
19715 self.abstract_boat.is_dirty()
19716 }
19717}
19718impl Default for SpruceBoatEntityData {
19719 fn default() -> Self {
19720 Self::new()
19721 }
19722}
19723impl VanillaEntityData for SpruceBoatEntityData {
19724 fn base(&self) -> &BaseEntityData {
19725 SpruceBoatEntityData::base(self)
19726 }
19727 fn base_mut(&mut self) -> &mut BaseEntityData {
19728 SpruceBoatEntityData::base_mut(self)
19729 }
19730 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19731 SpruceBoatEntityData::pack_dirty(self)
19732 }
19733 fn pack_all(&self) -> Vec<DataValue> {
19734 SpruceBoatEntityData::pack_all(self)
19735 }
19736 fn is_dirty(&self) -> bool {
19737 SpruceBoatEntityData::is_dirty(self)
19738 }
19739}
19740#[doc = "Concrete synchronized entity data for vanilla entity `spruce_chest_boat`."]
19741#[derive(Debug, Clone)]
19742pub struct SpruceChestBoatEntityData {
19743 pub abstract_boat: AbstractBoatEntityData,
19744}
19745impl SpruceChestBoatEntityData {
19746 #[doc = r" Create new entity data with default values."]
19747 pub fn new() -> Self {
19748 Self {
19749 abstract_boat: AbstractBoatEntityData::new(),
19750 }
19751 }
19752 #[doc = "Returns the `AbstractBoatEntityData` layer."]
19753 pub fn abstract_boat(&self) -> &AbstractBoatEntityData {
19754 &self.abstract_boat
19755 }
19756 #[doc = "Returns the mutable `AbstractBoatEntityData` layer."]
19757 pub fn abstract_boat_mut(&mut self) -> &mut AbstractBoatEntityData {
19758 &mut self.abstract_boat
19759 }
19760 #[doc = "Returns the `VehicleEntityData` layer."]
19761 pub fn vehicle_entity(&self) -> &VehicleEntityData {
19762 &self.abstract_boat.vehicle_entity
19763 }
19764 #[doc = "Returns the mutable `VehicleEntityData` layer."]
19765 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
19766 &mut self.abstract_boat.vehicle_entity
19767 }
19768 #[doc = "Returns the `BaseEntityData` layer."]
19769 pub fn base(&self) -> &BaseEntityData {
19770 &self.abstract_boat.vehicle_entity.base
19771 }
19772 #[doc = "Returns the mutable `BaseEntityData` layer."]
19773 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19774 &mut self.abstract_boat.vehicle_entity.base
19775 }
19776 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19777 #[doc = r" Returns `None` if no values are dirty."]
19778 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19779 self.abstract_boat.pack_dirty()
19780 }
19781 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19782 pub fn pack_all(&self) -> Vec<DataValue> {
19783 self.abstract_boat.pack_all()
19784 }
19785 #[doc = r" Returns `true` if any field has been modified."]
19786 pub fn is_dirty(&self) -> bool {
19787 self.abstract_boat.is_dirty()
19788 }
19789}
19790impl Default for SpruceChestBoatEntityData {
19791 fn default() -> Self {
19792 Self::new()
19793 }
19794}
19795impl VanillaEntityData for SpruceChestBoatEntityData {
19796 fn base(&self) -> &BaseEntityData {
19797 SpruceChestBoatEntityData::base(self)
19798 }
19799 fn base_mut(&mut self) -> &mut BaseEntityData {
19800 SpruceChestBoatEntityData::base_mut(self)
19801 }
19802 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19803 SpruceChestBoatEntityData::pack_dirty(self)
19804 }
19805 fn pack_all(&self) -> Vec<DataValue> {
19806 SpruceChestBoatEntityData::pack_all(self)
19807 }
19808 fn is_dirty(&self) -> bool {
19809 SpruceChestBoatEntityData::is_dirty(self)
19810 }
19811}
19812#[doc = "Concrete synchronized entity data for vanilla entity `squid`."]
19813#[derive(Debug, Clone)]
19814pub struct SquidEntityData {
19815 pub ageable_mob: AgeableMobEntityData,
19816}
19817impl SquidEntityData {
19818 #[doc = r" Create new entity data with default values."]
19819 pub fn new() -> Self {
19820 Self {
19821 ageable_mob: AgeableMobEntityData::new(),
19822 }
19823 }
19824 #[doc = "Returns the `AgeableMobEntityData` layer."]
19825 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
19826 &self.ageable_mob
19827 }
19828 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
19829 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
19830 &mut self.ageable_mob
19831 }
19832 #[doc = "Returns the `MobEntityData` layer."]
19833 pub fn mob(&self) -> &MobEntityData {
19834 &self.ageable_mob.mob
19835 }
19836 #[doc = "Returns the mutable `MobEntityData` layer."]
19837 pub fn mob_mut(&mut self) -> &mut MobEntityData {
19838 &mut self.ageable_mob.mob
19839 }
19840 #[doc = "Returns the `LivingEntityData` layer."]
19841 pub fn living_entity(&self) -> &LivingEntityData {
19842 &self.ageable_mob.mob.living_entity
19843 }
19844 #[doc = "Returns the mutable `LivingEntityData` layer."]
19845 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
19846 &mut self.ageable_mob.mob.living_entity
19847 }
19848 #[doc = "Returns the `BaseEntityData` layer."]
19849 pub fn base(&self) -> &BaseEntityData {
19850 &self.ageable_mob.mob.living_entity.base
19851 }
19852 #[doc = "Returns the mutable `BaseEntityData` layer."]
19853 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19854 &mut self.ageable_mob.mob.living_entity.base
19855 }
19856 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19857 #[doc = r" Returns `None` if no values are dirty."]
19858 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19859 self.ageable_mob.pack_dirty()
19860 }
19861 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19862 pub fn pack_all(&self) -> Vec<DataValue> {
19863 self.ageable_mob.pack_all()
19864 }
19865 #[doc = r" Returns `true` if any field has been modified."]
19866 pub fn is_dirty(&self) -> bool {
19867 self.ageable_mob.is_dirty()
19868 }
19869}
19870impl Default for SquidEntityData {
19871 fn default() -> Self {
19872 Self::new()
19873 }
19874}
19875impl VanillaEntityData for SquidEntityData {
19876 fn base(&self) -> &BaseEntityData {
19877 SquidEntityData::base(self)
19878 }
19879 fn base_mut(&mut self) -> &mut BaseEntityData {
19880 SquidEntityData::base_mut(self)
19881 }
19882 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19883 SquidEntityData::pack_dirty(self)
19884 }
19885 fn pack_all(&self) -> Vec<DataValue> {
19886 SquidEntityData::pack_all(self)
19887 }
19888 fn is_dirty(&self) -> bool {
19889 SquidEntityData::is_dirty(self)
19890 }
19891}
19892impl VanillaLivingEntityData for SquidEntityData {
19893 fn living_entity(&self) -> &LivingEntityData {
19894 SquidEntityData::living_entity(self)
19895 }
19896 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
19897 SquidEntityData::living_entity_mut(self)
19898 }
19899}
19900#[doc = "Concrete synchronized entity data for vanilla entity `stray`."]
19901#[derive(Debug, Clone)]
19902pub struct StrayEntityData {
19903 pub mob: MobEntityData,
19904}
19905impl StrayEntityData {
19906 #[doc = r" Create new entity data with default values."]
19907 pub fn new() -> Self {
19908 Self {
19909 mob: MobEntityData::new(),
19910 }
19911 }
19912 #[doc = "Returns the `MobEntityData` layer."]
19913 pub fn mob(&self) -> &MobEntityData {
19914 &self.mob
19915 }
19916 #[doc = "Returns the mutable `MobEntityData` layer."]
19917 pub fn mob_mut(&mut self) -> &mut MobEntityData {
19918 &mut self.mob
19919 }
19920 #[doc = "Returns the `LivingEntityData` layer."]
19921 pub fn living_entity(&self) -> &LivingEntityData {
19922 &self.mob.living_entity
19923 }
19924 #[doc = "Returns the mutable `LivingEntityData` layer."]
19925 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
19926 &mut self.mob.living_entity
19927 }
19928 #[doc = "Returns the `BaseEntityData` layer."]
19929 pub fn base(&self) -> &BaseEntityData {
19930 &self.mob.living_entity.base
19931 }
19932 #[doc = "Returns the mutable `BaseEntityData` layer."]
19933 pub fn base_mut(&mut self) -> &mut BaseEntityData {
19934 &mut self.mob.living_entity.base
19935 }
19936 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
19937 #[doc = r" Returns `None` if no values are dirty."]
19938 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19939 self.mob.pack_dirty()
19940 }
19941 #[doc = r" Pack all non-default values (for initial entity spawn)."]
19942 pub fn pack_all(&self) -> Vec<DataValue> {
19943 self.mob.pack_all()
19944 }
19945 #[doc = r" Returns `true` if any field has been modified."]
19946 pub fn is_dirty(&self) -> bool {
19947 self.mob.is_dirty()
19948 }
19949}
19950impl Default for StrayEntityData {
19951 fn default() -> Self {
19952 Self::new()
19953 }
19954}
19955impl VanillaEntityData for StrayEntityData {
19956 fn base(&self) -> &BaseEntityData {
19957 StrayEntityData::base(self)
19958 }
19959 fn base_mut(&mut self) -> &mut BaseEntityData {
19960 StrayEntityData::base_mut(self)
19961 }
19962 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
19963 StrayEntityData::pack_dirty(self)
19964 }
19965 fn pack_all(&self) -> Vec<DataValue> {
19966 StrayEntityData::pack_all(self)
19967 }
19968 fn is_dirty(&self) -> bool {
19969 StrayEntityData::is_dirty(self)
19970 }
19971}
19972impl VanillaLivingEntityData for StrayEntityData {
19973 fn living_entity(&self) -> &LivingEntityData {
19974 StrayEntityData::living_entity(self)
19975 }
19976 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
19977 StrayEntityData::living_entity_mut(self)
19978 }
19979}
19980#[doc = "Concrete synchronized entity data for vanilla entity `tnt`."]
19981#[derive(Debug, Clone)]
19982pub struct TntEntityData {
19983 pub primed_tnt: PrimedTntEntityData,
19984}
19985impl TntEntityData {
19986 #[doc = r" Create new entity data with default values."]
19987 pub fn new() -> Self {
19988 Self {
19989 primed_tnt: PrimedTntEntityData::new(),
19990 }
19991 }
19992 #[doc = "Returns the `PrimedTntEntityData` layer."]
19993 pub fn primed_tnt(&self) -> &PrimedTntEntityData {
19994 &self.primed_tnt
19995 }
19996 #[doc = "Returns the mutable `PrimedTntEntityData` layer."]
19997 pub fn primed_tnt_mut(&mut self) -> &mut PrimedTntEntityData {
19998 &mut self.primed_tnt
19999 }
20000 #[doc = "Returns the `BaseEntityData` layer."]
20001 pub fn base(&self) -> &BaseEntityData {
20002 &self.primed_tnt.base
20003 }
20004 #[doc = "Returns the mutable `BaseEntityData` layer."]
20005 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20006 &mut self.primed_tnt.base
20007 }
20008 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20009 #[doc = r" Returns `None` if no values are dirty."]
20010 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20011 self.primed_tnt.pack_dirty()
20012 }
20013 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20014 pub fn pack_all(&self) -> Vec<DataValue> {
20015 self.primed_tnt.pack_all()
20016 }
20017 #[doc = r" Returns `true` if any field has been modified."]
20018 pub fn is_dirty(&self) -> bool {
20019 self.primed_tnt.is_dirty()
20020 }
20021}
20022impl Default for TntEntityData {
20023 fn default() -> Self {
20024 Self::new()
20025 }
20026}
20027impl VanillaEntityData for TntEntityData {
20028 fn base(&self) -> &BaseEntityData {
20029 TntEntityData::base(self)
20030 }
20031 fn base_mut(&mut self) -> &mut BaseEntityData {
20032 TntEntityData::base_mut(self)
20033 }
20034 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20035 TntEntityData::pack_dirty(self)
20036 }
20037 fn pack_all(&self) -> Vec<DataValue> {
20038 TntEntityData::pack_all(self)
20039 }
20040 fn is_dirty(&self) -> bool {
20041 TntEntityData::is_dirty(self)
20042 }
20043}
20044#[doc = "Concrete synchronized entity data for vanilla entity `tnt_minecart`."]
20045#[derive(Debug, Clone)]
20046pub struct TntMinecartEntityData {
20047 pub abstract_minecart: AbstractMinecartEntityData,
20048}
20049impl TntMinecartEntityData {
20050 #[doc = r" Create new entity data with default values."]
20051 pub fn new() -> Self {
20052 let mut data = AbstractMinecartEntityData::new();
20053 data.id_display_offset = SyncedValue::new(6i32);
20054 Self {
20055 abstract_minecart: data,
20056 }
20057 }
20058 #[doc = "Returns the `AbstractMinecartEntityData` layer."]
20059 pub fn abstract_minecart(&self) -> &AbstractMinecartEntityData {
20060 &self.abstract_minecart
20061 }
20062 #[doc = "Returns the mutable `AbstractMinecartEntityData` layer."]
20063 pub fn abstract_minecart_mut(&mut self) -> &mut AbstractMinecartEntityData {
20064 &mut self.abstract_minecart
20065 }
20066 #[doc = "Returns the `VehicleEntityData` layer."]
20067 pub fn vehicle_entity(&self) -> &VehicleEntityData {
20068 &self.abstract_minecart.vehicle_entity
20069 }
20070 #[doc = "Returns the mutable `VehicleEntityData` layer."]
20071 pub fn vehicle_entity_mut(&mut self) -> &mut VehicleEntityData {
20072 &mut self.abstract_minecart.vehicle_entity
20073 }
20074 #[doc = "Returns the `BaseEntityData` layer."]
20075 pub fn base(&self) -> &BaseEntityData {
20076 &self.abstract_minecart.vehicle_entity.base
20077 }
20078 #[doc = "Returns the mutable `BaseEntityData` layer."]
20079 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20080 &mut self.abstract_minecart.vehicle_entity.base
20081 }
20082 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20083 #[doc = r" Returns `None` if no values are dirty."]
20084 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20085 self.abstract_minecart.pack_dirty()
20086 }
20087 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20088 pub fn pack_all(&self) -> Vec<DataValue> {
20089 self.abstract_minecart.pack_all()
20090 }
20091 #[doc = r" Returns `true` if any field has been modified."]
20092 pub fn is_dirty(&self) -> bool {
20093 self.abstract_minecart.is_dirty()
20094 }
20095}
20096impl Default for TntMinecartEntityData {
20097 fn default() -> Self {
20098 Self::new()
20099 }
20100}
20101impl VanillaEntityData for TntMinecartEntityData {
20102 fn base(&self) -> &BaseEntityData {
20103 TntMinecartEntityData::base(self)
20104 }
20105 fn base_mut(&mut self) -> &mut BaseEntityData {
20106 TntMinecartEntityData::base_mut(self)
20107 }
20108 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20109 TntMinecartEntityData::pack_dirty(self)
20110 }
20111 fn pack_all(&self) -> Vec<DataValue> {
20112 TntMinecartEntityData::pack_all(self)
20113 }
20114 fn is_dirty(&self) -> bool {
20115 TntMinecartEntityData::is_dirty(self)
20116 }
20117}
20118#[doc = "Concrete synchronized entity data for vanilla entity `trader_llama`."]
20119#[derive(Debug, Clone)]
20120pub struct TraderLlamaEntityData {
20121 pub llama: LlamaEntityData,
20122}
20123impl TraderLlamaEntityData {
20124 #[doc = r" Create new entity data with default values."]
20125 pub fn new() -> Self {
20126 Self {
20127 llama: LlamaEntityData::new(),
20128 }
20129 }
20130 #[doc = "Returns the `LlamaEntityData` layer."]
20131 pub fn llama(&self) -> &LlamaEntityData {
20132 &self.llama
20133 }
20134 #[doc = "Returns the mutable `LlamaEntityData` layer."]
20135 pub fn llama_mut(&mut self) -> &mut LlamaEntityData {
20136 &mut self.llama
20137 }
20138 #[doc = "Returns the `AbstractChestedHorseEntityData` layer."]
20139 pub fn abstract_chested_horse(&self) -> &AbstractChestedHorseEntityData {
20140 &self.llama.abstract_chested_horse
20141 }
20142 #[doc = "Returns the mutable `AbstractChestedHorseEntityData` layer."]
20143 pub fn abstract_chested_horse_mut(&mut self) -> &mut AbstractChestedHorseEntityData {
20144 &mut self.llama.abstract_chested_horse
20145 }
20146 #[doc = "Returns the `AbstractHorseEntityData` layer."]
20147 pub fn abstract_horse(&self) -> &AbstractHorseEntityData {
20148 &self.llama.abstract_chested_horse.abstract_horse
20149 }
20150 #[doc = "Returns the mutable `AbstractHorseEntityData` layer."]
20151 pub fn abstract_horse_mut(&mut self) -> &mut AbstractHorseEntityData {
20152 &mut self.llama.abstract_chested_horse.abstract_horse
20153 }
20154 #[doc = "Returns the `AgeableMobEntityData` layer."]
20155 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
20156 &self.llama.abstract_chested_horse.abstract_horse.ageable_mob
20157 }
20158 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
20159 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
20160 &mut self.llama.abstract_chested_horse.abstract_horse.ageable_mob
20161 }
20162 #[doc = "Returns the `MobEntityData` layer."]
20163 pub fn mob(&self) -> &MobEntityData {
20164 &self
20165 .llama
20166 .abstract_chested_horse
20167 .abstract_horse
20168 .ageable_mob
20169 .mob
20170 }
20171 #[doc = "Returns the mutable `MobEntityData` layer."]
20172 pub fn mob_mut(&mut self) -> &mut MobEntityData {
20173 &mut self
20174 .llama
20175 .abstract_chested_horse
20176 .abstract_horse
20177 .ageable_mob
20178 .mob
20179 }
20180 #[doc = "Returns the `LivingEntityData` layer."]
20181 pub fn living_entity(&self) -> &LivingEntityData {
20182 &self
20183 .llama
20184 .abstract_chested_horse
20185 .abstract_horse
20186 .ageable_mob
20187 .mob
20188 .living_entity
20189 }
20190 #[doc = "Returns the mutable `LivingEntityData` layer."]
20191 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20192 &mut self
20193 .llama
20194 .abstract_chested_horse
20195 .abstract_horse
20196 .ageable_mob
20197 .mob
20198 .living_entity
20199 }
20200 #[doc = "Returns the `BaseEntityData` layer."]
20201 pub fn base(&self) -> &BaseEntityData {
20202 &self
20203 .llama
20204 .abstract_chested_horse
20205 .abstract_horse
20206 .ageable_mob
20207 .mob
20208 .living_entity
20209 .base
20210 }
20211 #[doc = "Returns the mutable `BaseEntityData` layer."]
20212 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20213 &mut self
20214 .llama
20215 .abstract_chested_horse
20216 .abstract_horse
20217 .ageable_mob
20218 .mob
20219 .living_entity
20220 .base
20221 }
20222 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20223 #[doc = r" Returns `None` if no values are dirty."]
20224 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20225 self.llama.pack_dirty()
20226 }
20227 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20228 pub fn pack_all(&self) -> Vec<DataValue> {
20229 self.llama.pack_all()
20230 }
20231 #[doc = r" Returns `true` if any field has been modified."]
20232 pub fn is_dirty(&self) -> bool {
20233 self.llama.is_dirty()
20234 }
20235}
20236impl Default for TraderLlamaEntityData {
20237 fn default() -> Self {
20238 Self::new()
20239 }
20240}
20241impl VanillaEntityData for TraderLlamaEntityData {
20242 fn base(&self) -> &BaseEntityData {
20243 TraderLlamaEntityData::base(self)
20244 }
20245 fn base_mut(&mut self) -> &mut BaseEntityData {
20246 TraderLlamaEntityData::base_mut(self)
20247 }
20248 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20249 TraderLlamaEntityData::pack_dirty(self)
20250 }
20251 fn pack_all(&self) -> Vec<DataValue> {
20252 TraderLlamaEntityData::pack_all(self)
20253 }
20254 fn is_dirty(&self) -> bool {
20255 TraderLlamaEntityData::is_dirty(self)
20256 }
20257}
20258impl VanillaLivingEntityData for TraderLlamaEntityData {
20259 fn living_entity(&self) -> &LivingEntityData {
20260 TraderLlamaEntityData::living_entity(self)
20261 }
20262 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20263 TraderLlamaEntityData::living_entity_mut(self)
20264 }
20265}
20266#[doc = "Concrete synchronized entity data for vanilla entity `trident`."]
20267#[derive(Debug, Clone)]
20268pub struct TridentEntityData {
20269 pub thrown_trident: ThrownTridentEntityData,
20270}
20271impl TridentEntityData {
20272 #[doc = r" Create new entity data with default values."]
20273 pub fn new() -> Self {
20274 Self {
20275 thrown_trident: ThrownTridentEntityData::new(),
20276 }
20277 }
20278 #[doc = "Returns the `ThrownTridentEntityData` layer."]
20279 pub fn thrown_trident(&self) -> &ThrownTridentEntityData {
20280 &self.thrown_trident
20281 }
20282 #[doc = "Returns the mutable `ThrownTridentEntityData` layer."]
20283 pub fn thrown_trident_mut(&mut self) -> &mut ThrownTridentEntityData {
20284 &mut self.thrown_trident
20285 }
20286 #[doc = "Returns the `AbstractArrowEntityData` layer."]
20287 pub fn abstract_arrow(&self) -> &AbstractArrowEntityData {
20288 &self.thrown_trident.abstract_arrow
20289 }
20290 #[doc = "Returns the mutable `AbstractArrowEntityData` layer."]
20291 pub fn abstract_arrow_mut(&mut self) -> &mut AbstractArrowEntityData {
20292 &mut self.thrown_trident.abstract_arrow
20293 }
20294 #[doc = "Returns the `BaseEntityData` layer."]
20295 pub fn base(&self) -> &BaseEntityData {
20296 &self.thrown_trident.abstract_arrow.base
20297 }
20298 #[doc = "Returns the mutable `BaseEntityData` layer."]
20299 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20300 &mut self.thrown_trident.abstract_arrow.base
20301 }
20302 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20303 #[doc = r" Returns `None` if no values are dirty."]
20304 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20305 self.thrown_trident.pack_dirty()
20306 }
20307 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20308 pub fn pack_all(&self) -> Vec<DataValue> {
20309 self.thrown_trident.pack_all()
20310 }
20311 #[doc = r" Returns `true` if any field has been modified."]
20312 pub fn is_dirty(&self) -> bool {
20313 self.thrown_trident.is_dirty()
20314 }
20315}
20316impl Default for TridentEntityData {
20317 fn default() -> Self {
20318 Self::new()
20319 }
20320}
20321impl VanillaEntityData for TridentEntityData {
20322 fn base(&self) -> &BaseEntityData {
20323 TridentEntityData::base(self)
20324 }
20325 fn base_mut(&mut self) -> &mut BaseEntityData {
20326 TridentEntityData::base_mut(self)
20327 }
20328 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20329 TridentEntityData::pack_dirty(self)
20330 }
20331 fn pack_all(&self) -> Vec<DataValue> {
20332 TridentEntityData::pack_all(self)
20333 }
20334 fn is_dirty(&self) -> bool {
20335 TridentEntityData::is_dirty(self)
20336 }
20337}
20338#[doc = "Concrete synchronized entity data for vanilla entity `vindicator`."]
20339#[derive(Debug, Clone)]
20340pub struct VindicatorEntityData {
20341 pub raider: RaiderEntityData,
20342}
20343impl VindicatorEntityData {
20344 #[doc = r" Create new entity data with default values."]
20345 pub fn new() -> Self {
20346 Self {
20347 raider: RaiderEntityData::new(),
20348 }
20349 }
20350 #[doc = "Returns the `RaiderEntityData` layer."]
20351 pub fn raider(&self) -> &RaiderEntityData {
20352 &self.raider
20353 }
20354 #[doc = "Returns the mutable `RaiderEntityData` layer."]
20355 pub fn raider_mut(&mut self) -> &mut RaiderEntityData {
20356 &mut self.raider
20357 }
20358 #[doc = "Returns the `MobEntityData` layer."]
20359 pub fn mob(&self) -> &MobEntityData {
20360 &self.raider.mob
20361 }
20362 #[doc = "Returns the mutable `MobEntityData` layer."]
20363 pub fn mob_mut(&mut self) -> &mut MobEntityData {
20364 &mut self.raider.mob
20365 }
20366 #[doc = "Returns the `LivingEntityData` layer."]
20367 pub fn living_entity(&self) -> &LivingEntityData {
20368 &self.raider.mob.living_entity
20369 }
20370 #[doc = "Returns the mutable `LivingEntityData` layer."]
20371 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20372 &mut self.raider.mob.living_entity
20373 }
20374 #[doc = "Returns the `BaseEntityData` layer."]
20375 pub fn base(&self) -> &BaseEntityData {
20376 &self.raider.mob.living_entity.base
20377 }
20378 #[doc = "Returns the mutable `BaseEntityData` layer."]
20379 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20380 &mut self.raider.mob.living_entity.base
20381 }
20382 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20383 #[doc = r" Returns `None` if no values are dirty."]
20384 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20385 self.raider.pack_dirty()
20386 }
20387 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20388 pub fn pack_all(&self) -> Vec<DataValue> {
20389 self.raider.pack_all()
20390 }
20391 #[doc = r" Returns `true` if any field has been modified."]
20392 pub fn is_dirty(&self) -> bool {
20393 self.raider.is_dirty()
20394 }
20395}
20396impl Default for VindicatorEntityData {
20397 fn default() -> Self {
20398 Self::new()
20399 }
20400}
20401impl VanillaEntityData for VindicatorEntityData {
20402 fn base(&self) -> &BaseEntityData {
20403 VindicatorEntityData::base(self)
20404 }
20405 fn base_mut(&mut self) -> &mut BaseEntityData {
20406 VindicatorEntityData::base_mut(self)
20407 }
20408 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20409 VindicatorEntityData::pack_dirty(self)
20410 }
20411 fn pack_all(&self) -> Vec<DataValue> {
20412 VindicatorEntityData::pack_all(self)
20413 }
20414 fn is_dirty(&self) -> bool {
20415 VindicatorEntityData::is_dirty(self)
20416 }
20417}
20418impl VanillaLivingEntityData for VindicatorEntityData {
20419 fn living_entity(&self) -> &LivingEntityData {
20420 VindicatorEntityData::living_entity(self)
20421 }
20422 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20423 VindicatorEntityData::living_entity_mut(self)
20424 }
20425}
20426#[doc = "Concrete synchronized entity data for vanilla entity `wandering_trader`."]
20427#[derive(Debug, Clone)]
20428pub struct WanderingTraderEntityData {
20429 pub abstract_villager: AbstractVillagerEntityData,
20430}
20431impl WanderingTraderEntityData {
20432 #[doc = r" Create new entity data with default values."]
20433 pub fn new() -> Self {
20434 Self {
20435 abstract_villager: AbstractVillagerEntityData::new(),
20436 }
20437 }
20438 #[doc = "Returns the `AbstractVillagerEntityData` layer."]
20439 pub fn abstract_villager(&self) -> &AbstractVillagerEntityData {
20440 &self.abstract_villager
20441 }
20442 #[doc = "Returns the mutable `AbstractVillagerEntityData` layer."]
20443 pub fn abstract_villager_mut(&mut self) -> &mut AbstractVillagerEntityData {
20444 &mut self.abstract_villager
20445 }
20446 #[doc = "Returns the `AgeableMobEntityData` layer."]
20447 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
20448 &self.abstract_villager.ageable_mob
20449 }
20450 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
20451 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
20452 &mut self.abstract_villager.ageable_mob
20453 }
20454 #[doc = "Returns the `MobEntityData` layer."]
20455 pub fn mob(&self) -> &MobEntityData {
20456 &self.abstract_villager.ageable_mob.mob
20457 }
20458 #[doc = "Returns the mutable `MobEntityData` layer."]
20459 pub fn mob_mut(&mut self) -> &mut MobEntityData {
20460 &mut self.abstract_villager.ageable_mob.mob
20461 }
20462 #[doc = "Returns the `LivingEntityData` layer."]
20463 pub fn living_entity(&self) -> &LivingEntityData {
20464 &self.abstract_villager.ageable_mob.mob.living_entity
20465 }
20466 #[doc = "Returns the mutable `LivingEntityData` layer."]
20467 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20468 &mut self.abstract_villager.ageable_mob.mob.living_entity
20469 }
20470 #[doc = "Returns the `BaseEntityData` layer."]
20471 pub fn base(&self) -> &BaseEntityData {
20472 &self.abstract_villager.ageable_mob.mob.living_entity.base
20473 }
20474 #[doc = "Returns the mutable `BaseEntityData` layer."]
20475 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20476 &mut self.abstract_villager.ageable_mob.mob.living_entity.base
20477 }
20478 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20479 #[doc = r" Returns `None` if no values are dirty."]
20480 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20481 self.abstract_villager.pack_dirty()
20482 }
20483 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20484 pub fn pack_all(&self) -> Vec<DataValue> {
20485 self.abstract_villager.pack_all()
20486 }
20487 #[doc = r" Returns `true` if any field has been modified."]
20488 pub fn is_dirty(&self) -> bool {
20489 self.abstract_villager.is_dirty()
20490 }
20491}
20492impl Default for WanderingTraderEntityData {
20493 fn default() -> Self {
20494 Self::new()
20495 }
20496}
20497impl VanillaEntityData for WanderingTraderEntityData {
20498 fn base(&self) -> &BaseEntityData {
20499 WanderingTraderEntityData::base(self)
20500 }
20501 fn base_mut(&mut self) -> &mut BaseEntityData {
20502 WanderingTraderEntityData::base_mut(self)
20503 }
20504 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20505 WanderingTraderEntityData::pack_dirty(self)
20506 }
20507 fn pack_all(&self) -> Vec<DataValue> {
20508 WanderingTraderEntityData::pack_all(self)
20509 }
20510 fn is_dirty(&self) -> bool {
20511 WanderingTraderEntityData::is_dirty(self)
20512 }
20513}
20514impl VanillaLivingEntityData for WanderingTraderEntityData {
20515 fn living_entity(&self) -> &LivingEntityData {
20516 WanderingTraderEntityData::living_entity(self)
20517 }
20518 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20519 WanderingTraderEntityData::living_entity_mut(self)
20520 }
20521}
20522#[doc = "Concrete synchronized entity data for vanilla entity `wind_charge`."]
20523#[derive(Debug, Clone)]
20524pub struct WindChargeEntityData {
20525 pub base: BaseEntityData,
20526}
20527impl WindChargeEntityData {
20528 #[doc = r" Create new entity data with default values."]
20529 pub fn new() -> Self {
20530 Self {
20531 base: BaseEntityData::new(),
20532 }
20533 }
20534 #[doc = "Returns the `BaseEntityData` layer."]
20535 pub fn base(&self) -> &BaseEntityData {
20536 &self.base
20537 }
20538 #[doc = "Returns the mutable `BaseEntityData` layer."]
20539 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20540 &mut self.base
20541 }
20542 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20543 #[doc = r" Returns `None` if no values are dirty."]
20544 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20545 self.base.pack_dirty()
20546 }
20547 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20548 pub fn pack_all(&self) -> Vec<DataValue> {
20549 self.base.pack_all()
20550 }
20551 #[doc = r" Returns `true` if any field has been modified."]
20552 pub fn is_dirty(&self) -> bool {
20553 self.base.is_dirty()
20554 }
20555}
20556impl Default for WindChargeEntityData {
20557 fn default() -> Self {
20558 Self::new()
20559 }
20560}
20561impl VanillaEntityData for WindChargeEntityData {
20562 fn base(&self) -> &BaseEntityData {
20563 WindChargeEntityData::base(self)
20564 }
20565 fn base_mut(&mut self) -> &mut BaseEntityData {
20566 WindChargeEntityData::base_mut(self)
20567 }
20568 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20569 WindChargeEntityData::pack_dirty(self)
20570 }
20571 fn pack_all(&self) -> Vec<DataValue> {
20572 WindChargeEntityData::pack_all(self)
20573 }
20574 fn is_dirty(&self) -> bool {
20575 WindChargeEntityData::is_dirty(self)
20576 }
20577}
20578#[doc = "Concrete synchronized entity data for vanilla entity `wither`."]
20579#[derive(Debug, Clone)]
20580pub struct WitherEntityData {
20581 pub wither_boss: WitherBossEntityData,
20582}
20583impl WitherEntityData {
20584 #[doc = r" Create new entity data with default values."]
20585 pub fn new() -> Self {
20586 Self {
20587 wither_boss: WitherBossEntityData::new(),
20588 }
20589 }
20590 #[doc = "Returns the `WitherBossEntityData` layer."]
20591 pub fn wither_boss(&self) -> &WitherBossEntityData {
20592 &self.wither_boss
20593 }
20594 #[doc = "Returns the mutable `WitherBossEntityData` layer."]
20595 pub fn wither_boss_mut(&mut self) -> &mut WitherBossEntityData {
20596 &mut self.wither_boss
20597 }
20598 #[doc = "Returns the `MobEntityData` layer."]
20599 pub fn mob(&self) -> &MobEntityData {
20600 &self.wither_boss.mob
20601 }
20602 #[doc = "Returns the mutable `MobEntityData` layer."]
20603 pub fn mob_mut(&mut self) -> &mut MobEntityData {
20604 &mut self.wither_boss.mob
20605 }
20606 #[doc = "Returns the `LivingEntityData` layer."]
20607 pub fn living_entity(&self) -> &LivingEntityData {
20608 &self.wither_boss.mob.living_entity
20609 }
20610 #[doc = "Returns the mutable `LivingEntityData` layer."]
20611 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20612 &mut self.wither_boss.mob.living_entity
20613 }
20614 #[doc = "Returns the `BaseEntityData` layer."]
20615 pub fn base(&self) -> &BaseEntityData {
20616 &self.wither_boss.mob.living_entity.base
20617 }
20618 #[doc = "Returns the mutable `BaseEntityData` layer."]
20619 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20620 &mut self.wither_boss.mob.living_entity.base
20621 }
20622 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20623 #[doc = r" Returns `None` if no values are dirty."]
20624 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20625 self.wither_boss.pack_dirty()
20626 }
20627 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20628 pub fn pack_all(&self) -> Vec<DataValue> {
20629 self.wither_boss.pack_all()
20630 }
20631 #[doc = r" Returns `true` if any field has been modified."]
20632 pub fn is_dirty(&self) -> bool {
20633 self.wither_boss.is_dirty()
20634 }
20635}
20636impl Default for WitherEntityData {
20637 fn default() -> Self {
20638 Self::new()
20639 }
20640}
20641impl VanillaEntityData for WitherEntityData {
20642 fn base(&self) -> &BaseEntityData {
20643 WitherEntityData::base(self)
20644 }
20645 fn base_mut(&mut self) -> &mut BaseEntityData {
20646 WitherEntityData::base_mut(self)
20647 }
20648 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20649 WitherEntityData::pack_dirty(self)
20650 }
20651 fn pack_all(&self) -> Vec<DataValue> {
20652 WitherEntityData::pack_all(self)
20653 }
20654 fn is_dirty(&self) -> bool {
20655 WitherEntityData::is_dirty(self)
20656 }
20657}
20658impl VanillaLivingEntityData for WitherEntityData {
20659 fn living_entity(&self) -> &LivingEntityData {
20660 WitherEntityData::living_entity(self)
20661 }
20662 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20663 WitherEntityData::living_entity_mut(self)
20664 }
20665}
20666#[doc = "Concrete synchronized entity data for vanilla entity `wither_skeleton`."]
20667#[derive(Debug, Clone)]
20668pub struct WitherSkeletonEntityData {
20669 pub mob: MobEntityData,
20670}
20671impl WitherSkeletonEntityData {
20672 #[doc = r" Create new entity data with default values."]
20673 pub fn new() -> Self {
20674 Self {
20675 mob: MobEntityData::new(),
20676 }
20677 }
20678 #[doc = "Returns the `MobEntityData` layer."]
20679 pub fn mob(&self) -> &MobEntityData {
20680 &self.mob
20681 }
20682 #[doc = "Returns the mutable `MobEntityData` layer."]
20683 pub fn mob_mut(&mut self) -> &mut MobEntityData {
20684 &mut self.mob
20685 }
20686 #[doc = "Returns the `LivingEntityData` layer."]
20687 pub fn living_entity(&self) -> &LivingEntityData {
20688 &self.mob.living_entity
20689 }
20690 #[doc = "Returns the mutable `LivingEntityData` layer."]
20691 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20692 &mut self.mob.living_entity
20693 }
20694 #[doc = "Returns the `BaseEntityData` layer."]
20695 pub fn base(&self) -> &BaseEntityData {
20696 &self.mob.living_entity.base
20697 }
20698 #[doc = "Returns the mutable `BaseEntityData` layer."]
20699 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20700 &mut self.mob.living_entity.base
20701 }
20702 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20703 #[doc = r" Returns `None` if no values are dirty."]
20704 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20705 self.mob.pack_dirty()
20706 }
20707 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20708 pub fn pack_all(&self) -> Vec<DataValue> {
20709 self.mob.pack_all()
20710 }
20711 #[doc = r" Returns `true` if any field has been modified."]
20712 pub fn is_dirty(&self) -> bool {
20713 self.mob.is_dirty()
20714 }
20715}
20716impl Default for WitherSkeletonEntityData {
20717 fn default() -> Self {
20718 Self::new()
20719 }
20720}
20721impl VanillaEntityData for WitherSkeletonEntityData {
20722 fn base(&self) -> &BaseEntityData {
20723 WitherSkeletonEntityData::base(self)
20724 }
20725 fn base_mut(&mut self) -> &mut BaseEntityData {
20726 WitherSkeletonEntityData::base_mut(self)
20727 }
20728 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20729 WitherSkeletonEntityData::pack_dirty(self)
20730 }
20731 fn pack_all(&self) -> Vec<DataValue> {
20732 WitherSkeletonEntityData::pack_all(self)
20733 }
20734 fn is_dirty(&self) -> bool {
20735 WitherSkeletonEntityData::is_dirty(self)
20736 }
20737}
20738impl VanillaLivingEntityData for WitherSkeletonEntityData {
20739 fn living_entity(&self) -> &LivingEntityData {
20740 WitherSkeletonEntityData::living_entity(self)
20741 }
20742 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20743 WitherSkeletonEntityData::living_entity_mut(self)
20744 }
20745}
20746#[doc = "Concrete synchronized entity data for vanilla entity `zombie_horse`."]
20747#[derive(Debug, Clone)]
20748pub struct ZombieHorseEntityData {
20749 pub abstract_horse: AbstractHorseEntityData,
20750}
20751impl ZombieHorseEntityData {
20752 #[doc = r" Create new entity data with default values."]
20753 pub fn new() -> Self {
20754 Self {
20755 abstract_horse: AbstractHorseEntityData::new(),
20756 }
20757 }
20758 #[doc = "Returns the `AbstractHorseEntityData` layer."]
20759 pub fn abstract_horse(&self) -> &AbstractHorseEntityData {
20760 &self.abstract_horse
20761 }
20762 #[doc = "Returns the mutable `AbstractHorseEntityData` layer."]
20763 pub fn abstract_horse_mut(&mut self) -> &mut AbstractHorseEntityData {
20764 &mut self.abstract_horse
20765 }
20766 #[doc = "Returns the `AgeableMobEntityData` layer."]
20767 pub fn ageable_mob(&self) -> &AgeableMobEntityData {
20768 &self.abstract_horse.ageable_mob
20769 }
20770 #[doc = "Returns the mutable `AgeableMobEntityData` layer."]
20771 pub fn ageable_mob_mut(&mut self) -> &mut AgeableMobEntityData {
20772 &mut self.abstract_horse.ageable_mob
20773 }
20774 #[doc = "Returns the `MobEntityData` layer."]
20775 pub fn mob(&self) -> &MobEntityData {
20776 &self.abstract_horse.ageable_mob.mob
20777 }
20778 #[doc = "Returns the mutable `MobEntityData` layer."]
20779 pub fn mob_mut(&mut self) -> &mut MobEntityData {
20780 &mut self.abstract_horse.ageable_mob.mob
20781 }
20782 #[doc = "Returns the `LivingEntityData` layer."]
20783 pub fn living_entity(&self) -> &LivingEntityData {
20784 &self.abstract_horse.ageable_mob.mob.living_entity
20785 }
20786 #[doc = "Returns the mutable `LivingEntityData` layer."]
20787 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20788 &mut self.abstract_horse.ageable_mob.mob.living_entity
20789 }
20790 #[doc = "Returns the `BaseEntityData` layer."]
20791 pub fn base(&self) -> &BaseEntityData {
20792 &self.abstract_horse.ageable_mob.mob.living_entity.base
20793 }
20794 #[doc = "Returns the mutable `BaseEntityData` layer."]
20795 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20796 &mut self.abstract_horse.ageable_mob.mob.living_entity.base
20797 }
20798 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20799 #[doc = r" Returns `None` if no values are dirty."]
20800 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20801 self.abstract_horse.pack_dirty()
20802 }
20803 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20804 pub fn pack_all(&self) -> Vec<DataValue> {
20805 self.abstract_horse.pack_all()
20806 }
20807 #[doc = r" Returns `true` if any field has been modified."]
20808 pub fn is_dirty(&self) -> bool {
20809 self.abstract_horse.is_dirty()
20810 }
20811}
20812impl Default for ZombieHorseEntityData {
20813 fn default() -> Self {
20814 Self::new()
20815 }
20816}
20817impl VanillaEntityData for ZombieHorseEntityData {
20818 fn base(&self) -> &BaseEntityData {
20819 ZombieHorseEntityData::base(self)
20820 }
20821 fn base_mut(&mut self) -> &mut BaseEntityData {
20822 ZombieHorseEntityData::base_mut(self)
20823 }
20824 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20825 ZombieHorseEntityData::pack_dirty(self)
20826 }
20827 fn pack_all(&self) -> Vec<DataValue> {
20828 ZombieHorseEntityData::pack_all(self)
20829 }
20830 fn is_dirty(&self) -> bool {
20831 ZombieHorseEntityData::is_dirty(self)
20832 }
20833}
20834impl VanillaLivingEntityData for ZombieHorseEntityData {
20835 fn living_entity(&self) -> &LivingEntityData {
20836 ZombieHorseEntityData::living_entity(self)
20837 }
20838 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20839 ZombieHorseEntityData::living_entity_mut(self)
20840 }
20841}
20842#[doc = "Concrete synchronized entity data for vanilla entity `zombified_piglin`."]
20843#[derive(Debug, Clone)]
20844pub struct ZombifiedPiglinEntityData {
20845 pub zombie: ZombieEntityData,
20846}
20847impl ZombifiedPiglinEntityData {
20848 #[doc = r" Create new entity data with default values."]
20849 pub fn new() -> Self {
20850 Self {
20851 zombie: ZombieEntityData::new(),
20852 }
20853 }
20854 #[doc = "Returns the `ZombieEntityData` layer."]
20855 pub fn zombie(&self) -> &ZombieEntityData {
20856 &self.zombie
20857 }
20858 #[doc = "Returns the mutable `ZombieEntityData` layer."]
20859 pub fn zombie_mut(&mut self) -> &mut ZombieEntityData {
20860 &mut self.zombie
20861 }
20862 #[doc = "Returns the `MobEntityData` layer."]
20863 pub fn mob(&self) -> &MobEntityData {
20864 &self.zombie.mob
20865 }
20866 #[doc = "Returns the mutable `MobEntityData` layer."]
20867 pub fn mob_mut(&mut self) -> &mut MobEntityData {
20868 &mut self.zombie.mob
20869 }
20870 #[doc = "Returns the `LivingEntityData` layer."]
20871 pub fn living_entity(&self) -> &LivingEntityData {
20872 &self.zombie.mob.living_entity
20873 }
20874 #[doc = "Returns the mutable `LivingEntityData` layer."]
20875 pub fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20876 &mut self.zombie.mob.living_entity
20877 }
20878 #[doc = "Returns the `BaseEntityData` layer."]
20879 pub fn base(&self) -> &BaseEntityData {
20880 &self.zombie.mob.living_entity.base
20881 }
20882 #[doc = "Returns the mutable `BaseEntityData` layer."]
20883 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20884 &mut self.zombie.mob.living_entity.base
20885 }
20886 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20887 #[doc = r" Returns `None` if no values are dirty."]
20888 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20889 self.zombie.pack_dirty()
20890 }
20891 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20892 pub fn pack_all(&self) -> Vec<DataValue> {
20893 self.zombie.pack_all()
20894 }
20895 #[doc = r" Returns `true` if any field has been modified."]
20896 pub fn is_dirty(&self) -> bool {
20897 self.zombie.is_dirty()
20898 }
20899}
20900impl Default for ZombifiedPiglinEntityData {
20901 fn default() -> Self {
20902 Self::new()
20903 }
20904}
20905impl VanillaEntityData for ZombifiedPiglinEntityData {
20906 fn base(&self) -> &BaseEntityData {
20907 ZombifiedPiglinEntityData::base(self)
20908 }
20909 fn base_mut(&mut self) -> &mut BaseEntityData {
20910 ZombifiedPiglinEntityData::base_mut(self)
20911 }
20912 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20913 ZombifiedPiglinEntityData::pack_dirty(self)
20914 }
20915 fn pack_all(&self) -> Vec<DataValue> {
20916 ZombifiedPiglinEntityData::pack_all(self)
20917 }
20918 fn is_dirty(&self) -> bool {
20919 ZombifiedPiglinEntityData::is_dirty(self)
20920 }
20921}
20922impl VanillaLivingEntityData for ZombifiedPiglinEntityData {
20923 fn living_entity(&self) -> &LivingEntityData {
20924 ZombifiedPiglinEntityData::living_entity(self)
20925 }
20926 fn living_entity_mut(&mut self) -> &mut LivingEntityData {
20927 ZombifiedPiglinEntityData::living_entity_mut(self)
20928 }
20929}
20930#[doc = "Concrete synchronized entity data for vanilla entity `fishing_bobber`."]
20931#[derive(Debug, Clone)]
20932pub struct FishingBobberEntityData {
20933 pub fishing_hook: FishingHookEntityData,
20934}
20935impl FishingBobberEntityData {
20936 #[doc = r" Create new entity data with default values."]
20937 pub fn new() -> Self {
20938 Self {
20939 fishing_hook: FishingHookEntityData::new(),
20940 }
20941 }
20942 #[doc = "Returns the `FishingHookEntityData` layer."]
20943 pub fn fishing_hook(&self) -> &FishingHookEntityData {
20944 &self.fishing_hook
20945 }
20946 #[doc = "Returns the mutable `FishingHookEntityData` layer."]
20947 pub fn fishing_hook_mut(&mut self) -> &mut FishingHookEntityData {
20948 &mut self.fishing_hook
20949 }
20950 #[doc = "Returns the `BaseEntityData` layer."]
20951 pub fn base(&self) -> &BaseEntityData {
20952 &self.fishing_hook.base
20953 }
20954 #[doc = "Returns the mutable `BaseEntityData` layer."]
20955 pub fn base_mut(&mut self) -> &mut BaseEntityData {
20956 &mut self.fishing_hook.base
20957 }
20958 #[doc = r" Pack all dirty values for network sync, clearing dirty flags."]
20959 #[doc = r" Returns `None` if no values are dirty."]
20960 pub fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20961 self.fishing_hook.pack_dirty()
20962 }
20963 #[doc = r" Pack all non-default values (for initial entity spawn)."]
20964 pub fn pack_all(&self) -> Vec<DataValue> {
20965 self.fishing_hook.pack_all()
20966 }
20967 #[doc = r" Returns `true` if any field has been modified."]
20968 pub fn is_dirty(&self) -> bool {
20969 self.fishing_hook.is_dirty()
20970 }
20971}
20972impl Default for FishingBobberEntityData {
20973 fn default() -> Self {
20974 Self::new()
20975 }
20976}
20977impl VanillaEntityData for FishingBobberEntityData {
20978 fn base(&self) -> &BaseEntityData {
20979 FishingBobberEntityData::base(self)
20980 }
20981 fn base_mut(&mut self) -> &mut BaseEntityData {
20982 FishingBobberEntityData::base_mut(self)
20983 }
20984 fn pack_dirty(&mut self) -> Option<Vec<DataValue>> {
20985 FishingBobberEntityData::pack_dirty(self)
20986 }
20987 fn pack_all(&self) -> Vec<DataValue> {
20988 FishingBobberEntityData::pack_all(self)
20989 }
20990 fn is_dirty(&self) -> bool {
20991 FishingBobberEntityData::is_dirty(self)
20992 }
20993}