1#![allow(clippy::single_match)]
2
3use azalea_chat::FormattedText;
7use azalea_core::{
8 direction::Direction,
9 position::{BlockPos, Vec3},
10};
11use azalea_inventory::ItemStack;
12use azalea_registry::DataRegistry;
13use bevy_ecs::{bundle::Bundle, component::Component};
14use derive_more::{Deref, DerefMut};
15use thiserror::Error;
16use uuid::Uuid;
17
18use super::{
19 ArmadilloStateKind, EntityDataItem, EntityDataValue, OptionalUnsignedInt, Pose, Quaternion,
20 Rotations, SnifferStateKind, VillagerData,
21};
22use crate::particle::Particle;
23
24#[derive(Error, Debug)]
25pub enum UpdateMetadataError {
26 #[error("Wrong type ({0:?})")]
27 WrongType(EntityDataValue),
28}
29impl From<EntityDataValue> for UpdateMetadataError {
30 fn from(value: EntityDataValue) -> Self {
31 Self::WrongType(value)
32 }
33}
34
35#[derive(Component, Deref, DerefMut, Clone, Copy)]
36pub struct OnFire(pub bool);
37#[derive(Component, Deref, DerefMut, Clone, Copy)]
38pub struct ShiftKeyDown(pub bool);
39#[derive(Component, Deref, DerefMut, Clone, Copy)]
40pub struct Sprinting(pub bool);
41#[derive(Component, Deref, DerefMut, Clone, Copy)]
42pub struct Swimming(pub bool);
43#[derive(Component, Deref, DerefMut, Clone, Copy)]
44pub struct CurrentlyGlowing(pub bool);
45#[derive(Component, Deref, DerefMut, Clone, Copy)]
46pub struct Invisible(pub bool);
47#[derive(Component, Deref, DerefMut, Clone, Copy)]
48pub struct FallFlying(pub bool);
49#[derive(Component, Deref, DerefMut, Clone)]
50pub struct AirSupply(pub i32);
51#[derive(Component, Deref, DerefMut, Clone)]
52pub struct CustomName(pub Option<FormattedText>);
53#[derive(Component, Deref, DerefMut, Clone)]
54pub struct CustomNameVisible(pub bool);
55#[derive(Component, Deref, DerefMut, Clone)]
56pub struct Silent(pub bool);
57#[derive(Component, Deref, DerefMut, Clone)]
58pub struct NoGravity(pub bool);
59#[derive(Component, Deref, DerefMut, Clone)]
60pub struct TicksFrozen(pub i32);
61#[derive(Component, Deref, DerefMut, Clone)]
62pub struct Hurt(pub i32);
63#[derive(Component, Deref, DerefMut, Clone)]
64pub struct Hurtdir(pub i32);
65#[derive(Component, Deref, DerefMut, Clone)]
66pub struct Damage(pub f32);
67#[derive(Component, Deref, DerefMut, Clone)]
68pub struct PaddleLeft(pub bool);
69#[derive(Component, Deref, DerefMut, Clone)]
70pub struct PaddleRight(pub bool);
71#[derive(Component, Deref, DerefMut, Clone)]
72pub struct BubbleTime(pub i32);
73#[derive(Component)]
74pub struct AcaciaBoat;
75impl AcaciaBoat {
76 pub fn apply_metadata(
77 entity: &mut bevy_ecs::system::EntityCommands,
78 d: EntityDataItem,
79 ) -> Result<(), UpdateMetadataError> {
80 match d.index {
81 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
82 _ => {}
83 }
84 Ok(())
85 }
86}
87
88#[derive(Bundle)]
89pub struct AcaciaBoatMetadataBundle {
90 _marker: AcaciaBoat,
91 parent: AbstractBoatMetadataBundle,
92}
93impl Default for AcaciaBoatMetadataBundle {
94 fn default() -> Self {
95 Self {
96 _marker: AcaciaBoat,
97 parent: AbstractBoatMetadataBundle {
98 _marker: AbstractBoat,
99 parent: AbstractVehicleMetadataBundle {
100 _marker: AbstractVehicle,
101 parent: AbstractEntityMetadataBundle {
102 _marker: AbstractEntity,
103 on_fire: OnFire(false),
104 shift_key_down: ShiftKeyDown(false),
105 sprinting: Sprinting(false),
106 swimming: Swimming(false),
107 currently_glowing: CurrentlyGlowing(false),
108 invisible: Invisible(false),
109 fall_flying: FallFlying(false),
110 air_supply: AirSupply(Default::default()),
111 custom_name: CustomName(Default::default()),
112 custom_name_visible: CustomNameVisible(Default::default()),
113 silent: Silent(Default::default()),
114 no_gravity: NoGravity(Default::default()),
115 pose: Pose::default(),
116 ticks_frozen: TicksFrozen(Default::default()),
117 },
118 hurt: Hurt(0),
119 hurtdir: Hurtdir(1),
120 damage: Damage(0.0),
121 },
122 paddle_left: PaddleLeft(false),
123 paddle_right: PaddleRight(false),
124 bubble_time: BubbleTime(0),
125 },
126 }
127 }
128}
129
130#[derive(Component)]
131pub struct AcaciaChestBoat;
132impl AcaciaChestBoat {
133 pub fn apply_metadata(
134 entity: &mut bevy_ecs::system::EntityCommands,
135 d: EntityDataItem,
136 ) -> Result<(), UpdateMetadataError> {
137 match d.index {
138 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
139 _ => {}
140 }
141 Ok(())
142 }
143}
144
145#[derive(Bundle)]
146pub struct AcaciaChestBoatMetadataBundle {
147 _marker: AcaciaChestBoat,
148 parent: AbstractBoatMetadataBundle,
149}
150impl Default for AcaciaChestBoatMetadataBundle {
151 fn default() -> Self {
152 Self {
153 _marker: AcaciaChestBoat,
154 parent: AbstractBoatMetadataBundle {
155 _marker: AbstractBoat,
156 parent: AbstractVehicleMetadataBundle {
157 _marker: AbstractVehicle,
158 parent: AbstractEntityMetadataBundle {
159 _marker: AbstractEntity,
160 on_fire: OnFire(false),
161 shift_key_down: ShiftKeyDown(false),
162 sprinting: Sprinting(false),
163 swimming: Swimming(false),
164 currently_glowing: CurrentlyGlowing(false),
165 invisible: Invisible(false),
166 fall_flying: FallFlying(false),
167 air_supply: AirSupply(Default::default()),
168 custom_name: CustomName(Default::default()),
169 custom_name_visible: CustomNameVisible(Default::default()),
170 silent: Silent(Default::default()),
171 no_gravity: NoGravity(Default::default()),
172 pose: Pose::default(),
173 ticks_frozen: TicksFrozen(Default::default()),
174 },
175 hurt: Hurt(0),
176 hurtdir: Hurtdir(1),
177 damage: Damage(0.0),
178 },
179 paddle_left: PaddleLeft(false),
180 paddle_right: PaddleRight(false),
181 bubble_time: BubbleTime(0),
182 },
183 }
184 }
185}
186
187#[derive(Component, Deref, DerefMut, Clone, Copy)]
188pub struct AutoSpinAttack(pub bool);
189#[derive(Component, Deref, DerefMut, Clone, Copy)]
190pub struct AbstractLivingUsingItem(pub bool);
191#[derive(Component, Deref, DerefMut, Clone)]
192pub struct Health(pub f32);
193#[derive(Component, Deref, DerefMut, Clone)]
194pub struct EffectParticles(pub Vec<Particle>);
195#[derive(Component, Deref, DerefMut, Clone)]
196pub struct EffectAmbience(pub bool);
197#[derive(Component, Deref, DerefMut, Clone)]
198pub struct ArrowCount(pub i32);
199#[derive(Component, Deref, DerefMut, Clone)]
200pub struct StingerCount(pub i32);
201#[derive(Component, Deref, DerefMut, Clone)]
202pub struct SleepingPos(pub Option<BlockPos>);
203#[derive(Component, Deref, DerefMut, Clone, Copy)]
204pub struct NoAi(pub bool);
205#[derive(Component, Deref, DerefMut, Clone, Copy)]
206pub struct LeftHanded(pub bool);
207#[derive(Component, Deref, DerefMut, Clone, Copy)]
208pub struct Aggressive(pub bool);
209#[derive(Component, Deref, DerefMut, Clone)]
210pub struct Dancing(pub bool);
211#[derive(Component, Deref, DerefMut, Clone)]
212pub struct CanDuplicate(pub bool);
213#[derive(Component)]
214pub struct Allay;
215impl Allay {
216 pub fn apply_metadata(
217 entity: &mut bevy_ecs::system::EntityCommands,
218 d: EntityDataItem,
219 ) -> Result<(), UpdateMetadataError> {
220 match d.index {
221 0..=15 => AbstractCreature::apply_metadata(entity, d)?,
222 16 => {
223 entity.insert(Dancing(d.value.into_boolean()?));
224 }
225 17 => {
226 entity.insert(CanDuplicate(d.value.into_boolean()?));
227 }
228 _ => {}
229 }
230 Ok(())
231 }
232}
233
234#[derive(Bundle)]
235pub struct AllayMetadataBundle {
236 _marker: Allay,
237 parent: AbstractCreatureMetadataBundle,
238 dancing: Dancing,
239 can_duplicate: CanDuplicate,
240}
241impl Default for AllayMetadataBundle {
242 fn default() -> Self {
243 Self {
244 _marker: Allay,
245 parent: AbstractCreatureMetadataBundle {
246 _marker: AbstractCreature,
247 parent: AbstractInsentientMetadataBundle {
248 _marker: AbstractInsentient,
249 parent: AbstractLivingMetadataBundle {
250 _marker: AbstractLiving,
251 parent: AbstractEntityMetadataBundle {
252 _marker: AbstractEntity,
253 on_fire: OnFire(false),
254 shift_key_down: ShiftKeyDown(false),
255 sprinting: Sprinting(false),
256 swimming: Swimming(false),
257 currently_glowing: CurrentlyGlowing(false),
258 invisible: Invisible(false),
259 fall_flying: FallFlying(false),
260 air_supply: AirSupply(Default::default()),
261 custom_name: CustomName(Default::default()),
262 custom_name_visible: CustomNameVisible(Default::default()),
263 silent: Silent(Default::default()),
264 no_gravity: NoGravity(Default::default()),
265 pose: Pose::default(),
266 ticks_frozen: TicksFrozen(Default::default()),
267 },
268 auto_spin_attack: AutoSpinAttack(false),
269 abstract_living_using_item: AbstractLivingUsingItem(false),
270 health: Health(1.0),
271 effect_particles: EffectParticles(Default::default()),
272 effect_ambience: EffectAmbience(false),
273 arrow_count: ArrowCount(0),
274 stinger_count: StingerCount(0),
275 sleeping_pos: SleepingPos(None),
276 },
277 no_ai: NoAi(false),
278 left_handed: LeftHanded(false),
279 aggressive: Aggressive(false),
280 },
281 },
282 dancing: Dancing(false),
283 can_duplicate: CanDuplicate(true),
284 }
285 }
286}
287
288#[derive(Component, Deref, DerefMut, Clone)]
289pub struct Radius(pub f32);
290#[derive(Component, Deref, DerefMut, Clone)]
291pub struct Waiting(pub bool);
292#[derive(Component)]
293pub struct AreaEffectCloud;
294impl AreaEffectCloud {
295 pub fn apply_metadata(
296 entity: &mut bevy_ecs::system::EntityCommands,
297 d: EntityDataItem,
298 ) -> Result<(), UpdateMetadataError> {
299 match d.index {
300 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
301 8 => {
302 entity.insert(Radius(d.value.into_float()?));
303 }
304 9 => {
305 entity.insert(Waiting(d.value.into_boolean()?));
306 }
307 10 => {
308 entity.insert(d.value.into_particle()?);
309 }
310 _ => {}
311 }
312 Ok(())
313 }
314}
315
316#[derive(Bundle)]
317pub struct AreaEffectCloudMetadataBundle {
318 _marker: AreaEffectCloud,
319 parent: AbstractEntityMetadataBundle,
320 radius: Radius,
321 waiting: Waiting,
322 particle: Particle,
323}
324impl Default for AreaEffectCloudMetadataBundle {
325 fn default() -> Self {
326 Self {
327 _marker: AreaEffectCloud,
328 parent: AbstractEntityMetadataBundle {
329 _marker: AbstractEntity,
330 on_fire: OnFire(false),
331 shift_key_down: ShiftKeyDown(false),
332 sprinting: Sprinting(false),
333 swimming: Swimming(false),
334 currently_glowing: CurrentlyGlowing(false),
335 invisible: Invisible(false),
336 fall_flying: FallFlying(false),
337 air_supply: AirSupply(Default::default()),
338 custom_name: CustomName(Default::default()),
339 custom_name_visible: CustomNameVisible(Default::default()),
340 silent: Silent(Default::default()),
341 no_gravity: NoGravity(Default::default()),
342 pose: Pose::default(),
343 ticks_frozen: TicksFrozen(Default::default()),
344 },
345 radius: Radius(3.0),
346 waiting: Waiting(false),
347 particle: Particle::default(),
348 }
349 }
350}
351
352#[derive(Component, Deref, DerefMut, Clone)]
353pub struct AbstractAgeableBaby(pub bool);
354#[derive(Component, Deref, DerefMut, Clone)]
355pub struct ArmadilloState(pub ArmadilloStateKind);
356#[derive(Component)]
357pub struct Armadillo;
358impl Armadillo {
359 pub fn apply_metadata(
360 entity: &mut bevy_ecs::system::EntityCommands,
361 d: EntityDataItem,
362 ) -> Result<(), UpdateMetadataError> {
363 match d.index {
364 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
365 17 => {
366 entity.insert(ArmadilloState(d.value.into_armadillo_state()?));
367 }
368 _ => {}
369 }
370 Ok(())
371 }
372}
373
374#[derive(Bundle)]
375pub struct ArmadilloMetadataBundle {
376 _marker: Armadillo,
377 parent: AbstractAnimalMetadataBundle,
378 armadillo_state: ArmadilloState,
379}
380impl Default for ArmadilloMetadataBundle {
381 fn default() -> Self {
382 Self {
383 _marker: Armadillo,
384 parent: AbstractAnimalMetadataBundle {
385 _marker: AbstractAnimal,
386 parent: AbstractAgeableMetadataBundle {
387 _marker: AbstractAgeable,
388 parent: AbstractCreatureMetadataBundle {
389 _marker: AbstractCreature,
390 parent: AbstractInsentientMetadataBundle {
391 _marker: AbstractInsentient,
392 parent: AbstractLivingMetadataBundle {
393 _marker: AbstractLiving,
394 parent: AbstractEntityMetadataBundle {
395 _marker: AbstractEntity,
396 on_fire: OnFire(false),
397 shift_key_down: ShiftKeyDown(false),
398 sprinting: Sprinting(false),
399 swimming: Swimming(false),
400 currently_glowing: CurrentlyGlowing(false),
401 invisible: Invisible(false),
402 fall_flying: FallFlying(false),
403 air_supply: AirSupply(Default::default()),
404 custom_name: CustomName(Default::default()),
405 custom_name_visible: CustomNameVisible(Default::default()),
406 silent: Silent(Default::default()),
407 no_gravity: NoGravity(Default::default()),
408 pose: Pose::default(),
409 ticks_frozen: TicksFrozen(Default::default()),
410 },
411 auto_spin_attack: AutoSpinAttack(false),
412 abstract_living_using_item: AbstractLivingUsingItem(false),
413 health: Health(1.0),
414 effect_particles: EffectParticles(Default::default()),
415 effect_ambience: EffectAmbience(false),
416 arrow_count: ArrowCount(0),
417 stinger_count: StingerCount(0),
418 sleeping_pos: SleepingPos(None),
419 },
420 no_ai: NoAi(false),
421 left_handed: LeftHanded(false),
422 aggressive: Aggressive(false),
423 },
424 },
425 abstract_ageable_baby: AbstractAgeableBaby(false),
426 },
427 },
428 armadillo_state: ArmadilloState(Default::default()),
429 }
430 }
431}
432
433#[derive(Component, Deref, DerefMut, Clone, Copy)]
434pub struct Small(pub bool);
435#[derive(Component, Deref, DerefMut, Clone, Copy)]
436pub struct ShowArms(pub bool);
437#[derive(Component, Deref, DerefMut, Clone, Copy)]
438pub struct ShowBasePlate(pub bool);
439#[derive(Component, Deref, DerefMut, Clone, Copy)]
440pub struct ArmorStandMarker(pub bool);
441#[derive(Component, Deref, DerefMut, Clone)]
442pub struct HeadPose(pub Rotations);
443#[derive(Component, Deref, DerefMut, Clone)]
444pub struct BodyPose(pub Rotations);
445#[derive(Component, Deref, DerefMut, Clone)]
446pub struct LeftArmPose(pub Rotations);
447#[derive(Component, Deref, DerefMut, Clone)]
448pub struct RightArmPose(pub Rotations);
449#[derive(Component, Deref, DerefMut, Clone)]
450pub struct LeftLegPose(pub Rotations);
451#[derive(Component, Deref, DerefMut, Clone)]
452pub struct RightLegPose(pub Rotations);
453#[derive(Component)]
454pub struct ArmorStand;
455impl ArmorStand {
456 pub fn apply_metadata(
457 entity: &mut bevy_ecs::system::EntityCommands,
458 d: EntityDataItem,
459 ) -> Result<(), UpdateMetadataError> {
460 match d.index {
461 0..=14 => AbstractLiving::apply_metadata(entity, d)?,
462 15 => {
463 let bitfield = d.value.into_byte()?;
464 entity.insert(Small(bitfield & 0x1 != 0));
465 entity.insert(ShowArms(bitfield & 0x4 != 0));
466 entity.insert(ShowBasePlate(bitfield & 0x8 != 0));
467 entity.insert(ArmorStandMarker(bitfield & 0x10 != 0));
468 }
469 16 => {
470 entity.insert(HeadPose(d.value.into_rotations()?));
471 }
472 17 => {
473 entity.insert(BodyPose(d.value.into_rotations()?));
474 }
475 18 => {
476 entity.insert(LeftArmPose(d.value.into_rotations()?));
477 }
478 19 => {
479 entity.insert(RightArmPose(d.value.into_rotations()?));
480 }
481 20 => {
482 entity.insert(LeftLegPose(d.value.into_rotations()?));
483 }
484 21 => {
485 entity.insert(RightLegPose(d.value.into_rotations()?));
486 }
487 _ => {}
488 }
489 Ok(())
490 }
491}
492
493#[derive(Bundle)]
494pub struct ArmorStandMetadataBundle {
495 _marker: ArmorStand,
496 parent: AbstractLivingMetadataBundle,
497 small: Small,
498 show_arms: ShowArms,
499 show_base_plate: ShowBasePlate,
500 armor_stand_marker: ArmorStandMarker,
501 head_pose: HeadPose,
502 body_pose: BodyPose,
503 left_arm_pose: LeftArmPose,
504 right_arm_pose: RightArmPose,
505 left_leg_pose: LeftLegPose,
506 right_leg_pose: RightLegPose,
507}
508impl Default for ArmorStandMetadataBundle {
509 fn default() -> Self {
510 Self {
511 _marker: ArmorStand,
512 parent: AbstractLivingMetadataBundle {
513 _marker: AbstractLiving,
514 parent: AbstractEntityMetadataBundle {
515 _marker: AbstractEntity,
516 on_fire: OnFire(false),
517 shift_key_down: ShiftKeyDown(false),
518 sprinting: Sprinting(false),
519 swimming: Swimming(false),
520 currently_glowing: CurrentlyGlowing(false),
521 invisible: Invisible(false),
522 fall_flying: FallFlying(false),
523 air_supply: AirSupply(Default::default()),
524 custom_name: CustomName(Default::default()),
525 custom_name_visible: CustomNameVisible(Default::default()),
526 silent: Silent(Default::default()),
527 no_gravity: NoGravity(Default::default()),
528 pose: Pose::default(),
529 ticks_frozen: TicksFrozen(Default::default()),
530 },
531 auto_spin_attack: AutoSpinAttack(false),
532 abstract_living_using_item: AbstractLivingUsingItem(false),
533 health: Health(1.0),
534 effect_particles: EffectParticles(Default::default()),
535 effect_ambience: EffectAmbience(false),
536 arrow_count: ArrowCount(0),
537 stinger_count: StingerCount(0),
538 sleeping_pos: SleepingPos(None),
539 },
540 small: Small(false),
541 show_arms: ShowArms(false),
542 show_base_plate: ShowBasePlate(false),
543 armor_stand_marker: ArmorStandMarker(false),
544 head_pose: HeadPose(Default::default()),
545 body_pose: BodyPose(Default::default()),
546 left_arm_pose: LeftArmPose(Default::default()),
547 right_arm_pose: RightArmPose(Default::default()),
548 left_leg_pose: LeftLegPose(Default::default()),
549 right_leg_pose: RightLegPose(Default::default()),
550 }
551 }
552}
553
554#[derive(Component, Deref, DerefMut, Clone, Copy)]
555pub struct CritArrow(pub bool);
556#[derive(Component, Deref, DerefMut, Clone, Copy)]
557pub struct NoPhysics(pub bool);
558#[derive(Component, Deref, DerefMut, Clone)]
559pub struct PierceLevel(pub u8);
560#[derive(Component, Deref, DerefMut, Clone)]
561pub struct InGround(pub bool);
562#[derive(Component, Deref, DerefMut, Clone)]
563pub struct EffectColor(pub i32);
564#[derive(Component)]
565pub struct Arrow;
566impl Arrow {
567 pub fn apply_metadata(
568 entity: &mut bevy_ecs::system::EntityCommands,
569 d: EntityDataItem,
570 ) -> Result<(), UpdateMetadataError> {
571 match d.index {
572 0..=10 => AbstractArrow::apply_metadata(entity, d)?,
573 11 => {
574 entity.insert(EffectColor(d.value.into_int()?));
575 }
576 _ => {}
577 }
578 Ok(())
579 }
580}
581
582#[derive(Bundle)]
583pub struct ArrowMetadataBundle {
584 _marker: Arrow,
585 parent: AbstractArrowMetadataBundle,
586 effect_color: EffectColor,
587}
588impl Default for ArrowMetadataBundle {
589 fn default() -> Self {
590 Self {
591 _marker: Arrow,
592 parent: AbstractArrowMetadataBundle {
593 _marker: AbstractArrow,
594 parent: AbstractEntityMetadataBundle {
595 _marker: AbstractEntity,
596 on_fire: OnFire(false),
597 shift_key_down: ShiftKeyDown(false),
598 sprinting: Sprinting(false),
599 swimming: Swimming(false),
600 currently_glowing: CurrentlyGlowing(false),
601 invisible: Invisible(false),
602 fall_flying: FallFlying(false),
603 air_supply: AirSupply(Default::default()),
604 custom_name: CustomName(Default::default()),
605 custom_name_visible: CustomNameVisible(Default::default()),
606 silent: Silent(Default::default()),
607 no_gravity: NoGravity(Default::default()),
608 pose: Pose::default(),
609 ticks_frozen: TicksFrozen(Default::default()),
610 },
611 crit_arrow: CritArrow(false),
612 no_physics: NoPhysics(false),
613 pierce_level: PierceLevel(0),
614 in_ground: InGround(false),
615 },
616 effect_color: EffectColor(-1),
617 }
618 }
619}
620
621#[derive(Component, Deref, DerefMut, Clone)]
622pub struct AxolotlVariant(pub i32);
623#[derive(Component, Deref, DerefMut, Clone)]
624pub struct PlayingDead(pub bool);
625#[derive(Component, Deref, DerefMut, Clone)]
626pub struct AxolotlFromBucket(pub bool);
627#[derive(Component)]
628pub struct Axolotl;
629impl Axolotl {
630 pub fn apply_metadata(
631 entity: &mut bevy_ecs::system::EntityCommands,
632 d: EntityDataItem,
633 ) -> Result<(), UpdateMetadataError> {
634 match d.index {
635 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
636 17 => {
637 entity.insert(AxolotlVariant(d.value.into_int()?));
638 }
639 18 => {
640 entity.insert(PlayingDead(d.value.into_boolean()?));
641 }
642 19 => {
643 entity.insert(AxolotlFromBucket(d.value.into_boolean()?));
644 }
645 _ => {}
646 }
647 Ok(())
648 }
649}
650
651#[derive(Bundle)]
652pub struct AxolotlMetadataBundle {
653 _marker: Axolotl,
654 parent: AbstractAnimalMetadataBundle,
655 axolotl_variant: AxolotlVariant,
656 playing_dead: PlayingDead,
657 axolotl_from_bucket: AxolotlFromBucket,
658}
659impl Default for AxolotlMetadataBundle {
660 fn default() -> Self {
661 Self {
662 _marker: Axolotl,
663 parent: AbstractAnimalMetadataBundle {
664 _marker: AbstractAnimal,
665 parent: AbstractAgeableMetadataBundle {
666 _marker: AbstractAgeable,
667 parent: AbstractCreatureMetadataBundle {
668 _marker: AbstractCreature,
669 parent: AbstractInsentientMetadataBundle {
670 _marker: AbstractInsentient,
671 parent: AbstractLivingMetadataBundle {
672 _marker: AbstractLiving,
673 parent: AbstractEntityMetadataBundle {
674 _marker: AbstractEntity,
675 on_fire: OnFire(false),
676 shift_key_down: ShiftKeyDown(false),
677 sprinting: Sprinting(false),
678 swimming: Swimming(false),
679 currently_glowing: CurrentlyGlowing(false),
680 invisible: Invisible(false),
681 fall_flying: FallFlying(false),
682 air_supply: AirSupply(Default::default()),
683 custom_name: CustomName(Default::default()),
684 custom_name_visible: CustomNameVisible(Default::default()),
685 silent: Silent(Default::default()),
686 no_gravity: NoGravity(Default::default()),
687 pose: Pose::default(),
688 ticks_frozen: TicksFrozen(Default::default()),
689 },
690 auto_spin_attack: AutoSpinAttack(false),
691 abstract_living_using_item: AbstractLivingUsingItem(false),
692 health: Health(1.0),
693 effect_particles: EffectParticles(Default::default()),
694 effect_ambience: EffectAmbience(false),
695 arrow_count: ArrowCount(0),
696 stinger_count: StingerCount(0),
697 sleeping_pos: SleepingPos(None),
698 },
699 no_ai: NoAi(false),
700 left_handed: LeftHanded(false),
701 aggressive: Aggressive(false),
702 },
703 },
704 abstract_ageable_baby: AbstractAgeableBaby(false),
705 },
706 },
707 axolotl_variant: AxolotlVariant(0),
708 playing_dead: PlayingDead(false),
709 axolotl_from_bucket: AxolotlFromBucket(false),
710 }
711 }
712}
713
714#[derive(Component)]
715pub struct BambooChestRaft;
716impl BambooChestRaft {
717 pub fn apply_metadata(
718 entity: &mut bevy_ecs::system::EntityCommands,
719 d: EntityDataItem,
720 ) -> Result<(), UpdateMetadataError> {
721 match d.index {
722 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
723 _ => {}
724 }
725 Ok(())
726 }
727}
728
729#[derive(Bundle)]
730pub struct BambooChestRaftMetadataBundle {
731 _marker: BambooChestRaft,
732 parent: AbstractBoatMetadataBundle,
733}
734impl Default for BambooChestRaftMetadataBundle {
735 fn default() -> Self {
736 Self {
737 _marker: BambooChestRaft,
738 parent: AbstractBoatMetadataBundle {
739 _marker: AbstractBoat,
740 parent: AbstractVehicleMetadataBundle {
741 _marker: AbstractVehicle,
742 parent: AbstractEntityMetadataBundle {
743 _marker: AbstractEntity,
744 on_fire: OnFire(false),
745 shift_key_down: ShiftKeyDown(false),
746 sprinting: Sprinting(false),
747 swimming: Swimming(false),
748 currently_glowing: CurrentlyGlowing(false),
749 invisible: Invisible(false),
750 fall_flying: FallFlying(false),
751 air_supply: AirSupply(Default::default()),
752 custom_name: CustomName(Default::default()),
753 custom_name_visible: CustomNameVisible(Default::default()),
754 silent: Silent(Default::default()),
755 no_gravity: NoGravity(Default::default()),
756 pose: Pose::default(),
757 ticks_frozen: TicksFrozen(Default::default()),
758 },
759 hurt: Hurt(0),
760 hurtdir: Hurtdir(1),
761 damage: Damage(0.0),
762 },
763 paddle_left: PaddleLeft(false),
764 paddle_right: PaddleRight(false),
765 bubble_time: BubbleTime(0),
766 },
767 }
768 }
769}
770
771#[derive(Component)]
772pub struct BambooRaft;
773impl BambooRaft {
774 pub fn apply_metadata(
775 entity: &mut bevy_ecs::system::EntityCommands,
776 d: EntityDataItem,
777 ) -> Result<(), UpdateMetadataError> {
778 match d.index {
779 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
780 _ => {}
781 }
782 Ok(())
783 }
784}
785
786#[derive(Bundle)]
787pub struct BambooRaftMetadataBundle {
788 _marker: BambooRaft,
789 parent: AbstractBoatMetadataBundle,
790}
791impl Default for BambooRaftMetadataBundle {
792 fn default() -> Self {
793 Self {
794 _marker: BambooRaft,
795 parent: AbstractBoatMetadataBundle {
796 _marker: AbstractBoat,
797 parent: AbstractVehicleMetadataBundle {
798 _marker: AbstractVehicle,
799 parent: AbstractEntityMetadataBundle {
800 _marker: AbstractEntity,
801 on_fire: OnFire(false),
802 shift_key_down: ShiftKeyDown(false),
803 sprinting: Sprinting(false),
804 swimming: Swimming(false),
805 currently_glowing: CurrentlyGlowing(false),
806 invisible: Invisible(false),
807 fall_flying: FallFlying(false),
808 air_supply: AirSupply(Default::default()),
809 custom_name: CustomName(Default::default()),
810 custom_name_visible: CustomNameVisible(Default::default()),
811 silent: Silent(Default::default()),
812 no_gravity: NoGravity(Default::default()),
813 pose: Pose::default(),
814 ticks_frozen: TicksFrozen(Default::default()),
815 },
816 hurt: Hurt(0),
817 hurtdir: Hurtdir(1),
818 damage: Damage(0.0),
819 },
820 paddle_left: PaddleLeft(false),
821 paddle_right: PaddleRight(false),
822 bubble_time: BubbleTime(0),
823 },
824 }
825 }
826}
827
828#[derive(Component, Deref, DerefMut, Clone, Copy)]
829pub struct Resting(pub bool);
830#[derive(Component)]
831pub struct Bat;
832impl Bat {
833 pub fn apply_metadata(
834 entity: &mut bevy_ecs::system::EntityCommands,
835 d: EntityDataItem,
836 ) -> Result<(), UpdateMetadataError> {
837 match d.index {
838 0..=15 => AbstractInsentient::apply_metadata(entity, d)?,
839 16 => {
840 let bitfield = d.value.into_byte()?;
841 entity.insert(Resting(bitfield & 0x1 != 0));
842 }
843 _ => {}
844 }
845 Ok(())
846 }
847}
848
849#[derive(Bundle)]
850pub struct BatMetadataBundle {
851 _marker: Bat,
852 parent: AbstractInsentientMetadataBundle,
853 resting: Resting,
854}
855impl Default for BatMetadataBundle {
856 fn default() -> Self {
857 Self {
858 _marker: Bat,
859 parent: AbstractInsentientMetadataBundle {
860 _marker: AbstractInsentient,
861 parent: AbstractLivingMetadataBundle {
862 _marker: AbstractLiving,
863 parent: AbstractEntityMetadataBundle {
864 _marker: AbstractEntity,
865 on_fire: OnFire(false),
866 shift_key_down: ShiftKeyDown(false),
867 sprinting: Sprinting(false),
868 swimming: Swimming(false),
869 currently_glowing: CurrentlyGlowing(false),
870 invisible: Invisible(false),
871 fall_flying: FallFlying(false),
872 air_supply: AirSupply(Default::default()),
873 custom_name: CustomName(Default::default()),
874 custom_name_visible: CustomNameVisible(Default::default()),
875 silent: Silent(Default::default()),
876 no_gravity: NoGravity(Default::default()),
877 pose: Pose::default(),
878 ticks_frozen: TicksFrozen(Default::default()),
879 },
880 auto_spin_attack: AutoSpinAttack(false),
881 abstract_living_using_item: AbstractLivingUsingItem(false),
882 health: Health(1.0),
883 effect_particles: EffectParticles(Default::default()),
884 effect_ambience: EffectAmbience(false),
885 arrow_count: ArrowCount(0),
886 stinger_count: StingerCount(0),
887 sleeping_pos: SleepingPos(None),
888 },
889 no_ai: NoAi(false),
890 left_handed: LeftHanded(false),
891 aggressive: Aggressive(false),
892 },
893 resting: Resting(false),
894 }
895 }
896}
897
898#[derive(Component, Deref, DerefMut, Clone, Copy)]
899pub struct HasNectar(pub bool);
900#[derive(Component, Deref, DerefMut, Clone, Copy)]
901pub struct HasStung(pub bool);
902#[derive(Component, Deref, DerefMut, Clone, Copy)]
903pub struct BeeRolling(pub bool);
904#[derive(Component, Deref, DerefMut, Clone)]
905pub struct BeeRemainingAngerTime(pub i32);
906#[derive(Component)]
907pub struct Bee;
908impl Bee {
909 pub fn apply_metadata(
910 entity: &mut bevy_ecs::system::EntityCommands,
911 d: EntityDataItem,
912 ) -> Result<(), UpdateMetadataError> {
913 match d.index {
914 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
915 17 => {
916 let bitfield = d.value.into_byte()?;
917 entity.insert(HasNectar(bitfield & 0x8 != 0));
918 entity.insert(HasStung(bitfield & 0x4 != 0));
919 entity.insert(BeeRolling(bitfield & 0x2 != 0));
920 }
921 18 => {
922 entity.insert(BeeRemainingAngerTime(d.value.into_int()?));
923 }
924 _ => {}
925 }
926 Ok(())
927 }
928}
929
930#[derive(Bundle)]
931pub struct BeeMetadataBundle {
932 _marker: Bee,
933 parent: AbstractAnimalMetadataBundle,
934 has_nectar: HasNectar,
935 has_stung: HasStung,
936 bee_rolling: BeeRolling,
937 bee_remaining_anger_time: BeeRemainingAngerTime,
938}
939impl Default for BeeMetadataBundle {
940 fn default() -> Self {
941 Self {
942 _marker: Bee,
943 parent: AbstractAnimalMetadataBundle {
944 _marker: AbstractAnimal,
945 parent: AbstractAgeableMetadataBundle {
946 _marker: AbstractAgeable,
947 parent: AbstractCreatureMetadataBundle {
948 _marker: AbstractCreature,
949 parent: AbstractInsentientMetadataBundle {
950 _marker: AbstractInsentient,
951 parent: AbstractLivingMetadataBundle {
952 _marker: AbstractLiving,
953 parent: AbstractEntityMetadataBundle {
954 _marker: AbstractEntity,
955 on_fire: OnFire(false),
956 shift_key_down: ShiftKeyDown(false),
957 sprinting: Sprinting(false),
958 swimming: Swimming(false),
959 currently_glowing: CurrentlyGlowing(false),
960 invisible: Invisible(false),
961 fall_flying: FallFlying(false),
962 air_supply: AirSupply(Default::default()),
963 custom_name: CustomName(Default::default()),
964 custom_name_visible: CustomNameVisible(Default::default()),
965 silent: Silent(Default::default()),
966 no_gravity: NoGravity(Default::default()),
967 pose: Pose::default(),
968 ticks_frozen: TicksFrozen(Default::default()),
969 },
970 auto_spin_attack: AutoSpinAttack(false),
971 abstract_living_using_item: AbstractLivingUsingItem(false),
972 health: Health(1.0),
973 effect_particles: EffectParticles(Default::default()),
974 effect_ambience: EffectAmbience(false),
975 arrow_count: ArrowCount(0),
976 stinger_count: StingerCount(0),
977 sleeping_pos: SleepingPos(None),
978 },
979 no_ai: NoAi(false),
980 left_handed: LeftHanded(false),
981 aggressive: Aggressive(false),
982 },
983 },
984 abstract_ageable_baby: AbstractAgeableBaby(false),
985 },
986 },
987 has_nectar: HasNectar(false),
988 has_stung: HasStung(false),
989 bee_rolling: BeeRolling(false),
990 bee_remaining_anger_time: BeeRemainingAngerTime(0),
991 }
992 }
993}
994
995#[derive(Component)]
996pub struct BirchBoat;
997impl BirchBoat {
998 pub fn apply_metadata(
999 entity: &mut bevy_ecs::system::EntityCommands,
1000 d: EntityDataItem,
1001 ) -> Result<(), UpdateMetadataError> {
1002 match d.index {
1003 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
1004 _ => {}
1005 }
1006 Ok(())
1007 }
1008}
1009
1010#[derive(Bundle)]
1011pub struct BirchBoatMetadataBundle {
1012 _marker: BirchBoat,
1013 parent: AbstractBoatMetadataBundle,
1014}
1015impl Default for BirchBoatMetadataBundle {
1016 fn default() -> Self {
1017 Self {
1018 _marker: BirchBoat,
1019 parent: AbstractBoatMetadataBundle {
1020 _marker: AbstractBoat,
1021 parent: AbstractVehicleMetadataBundle {
1022 _marker: AbstractVehicle,
1023 parent: AbstractEntityMetadataBundle {
1024 _marker: AbstractEntity,
1025 on_fire: OnFire(false),
1026 shift_key_down: ShiftKeyDown(false),
1027 sprinting: Sprinting(false),
1028 swimming: Swimming(false),
1029 currently_glowing: CurrentlyGlowing(false),
1030 invisible: Invisible(false),
1031 fall_flying: FallFlying(false),
1032 air_supply: AirSupply(Default::default()),
1033 custom_name: CustomName(Default::default()),
1034 custom_name_visible: CustomNameVisible(Default::default()),
1035 silent: Silent(Default::default()),
1036 no_gravity: NoGravity(Default::default()),
1037 pose: Pose::default(),
1038 ticks_frozen: TicksFrozen(Default::default()),
1039 },
1040 hurt: Hurt(0),
1041 hurtdir: Hurtdir(1),
1042 damage: Damage(0.0),
1043 },
1044 paddle_left: PaddleLeft(false),
1045 paddle_right: PaddleRight(false),
1046 bubble_time: BubbleTime(0),
1047 },
1048 }
1049 }
1050}
1051
1052#[derive(Component)]
1053pub struct BirchChestBoat;
1054impl BirchChestBoat {
1055 pub fn apply_metadata(
1056 entity: &mut bevy_ecs::system::EntityCommands,
1057 d: EntityDataItem,
1058 ) -> Result<(), UpdateMetadataError> {
1059 match d.index {
1060 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
1061 _ => {}
1062 }
1063 Ok(())
1064 }
1065}
1066
1067#[derive(Bundle)]
1068pub struct BirchChestBoatMetadataBundle {
1069 _marker: BirchChestBoat,
1070 parent: AbstractBoatMetadataBundle,
1071}
1072impl Default for BirchChestBoatMetadataBundle {
1073 fn default() -> Self {
1074 Self {
1075 _marker: BirchChestBoat,
1076 parent: AbstractBoatMetadataBundle {
1077 _marker: AbstractBoat,
1078 parent: AbstractVehicleMetadataBundle {
1079 _marker: AbstractVehicle,
1080 parent: AbstractEntityMetadataBundle {
1081 _marker: AbstractEntity,
1082 on_fire: OnFire(false),
1083 shift_key_down: ShiftKeyDown(false),
1084 sprinting: Sprinting(false),
1085 swimming: Swimming(false),
1086 currently_glowing: CurrentlyGlowing(false),
1087 invisible: Invisible(false),
1088 fall_flying: FallFlying(false),
1089 air_supply: AirSupply(Default::default()),
1090 custom_name: CustomName(Default::default()),
1091 custom_name_visible: CustomNameVisible(Default::default()),
1092 silent: Silent(Default::default()),
1093 no_gravity: NoGravity(Default::default()),
1094 pose: Pose::default(),
1095 ticks_frozen: TicksFrozen(Default::default()),
1096 },
1097 hurt: Hurt(0),
1098 hurtdir: Hurtdir(1),
1099 damage: Damage(0.0),
1100 },
1101 paddle_left: PaddleLeft(false),
1102 paddle_right: PaddleRight(false),
1103 bubble_time: BubbleTime(0),
1104 },
1105 }
1106 }
1107}
1108
1109#[derive(Component, Deref, DerefMut, Clone, Copy)]
1110pub struct Charged(pub bool);
1111#[derive(Component)]
1112pub struct Blaze;
1113impl Blaze {
1114 pub fn apply_metadata(
1115 entity: &mut bevy_ecs::system::EntityCommands,
1116 d: EntityDataItem,
1117 ) -> Result<(), UpdateMetadataError> {
1118 match d.index {
1119 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
1120 16 => {
1121 let bitfield = d.value.into_byte()?;
1122 entity.insert(Charged(bitfield & 0x1 != 0));
1123 }
1124 _ => {}
1125 }
1126 Ok(())
1127 }
1128}
1129
1130#[derive(Bundle)]
1131pub struct BlazeMetadataBundle {
1132 _marker: Blaze,
1133 parent: AbstractMonsterMetadataBundle,
1134 charged: Charged,
1135}
1136impl Default for BlazeMetadataBundle {
1137 fn default() -> Self {
1138 Self {
1139 _marker: Blaze,
1140 parent: AbstractMonsterMetadataBundle {
1141 _marker: AbstractMonster,
1142 parent: AbstractCreatureMetadataBundle {
1143 _marker: AbstractCreature,
1144 parent: AbstractInsentientMetadataBundle {
1145 _marker: AbstractInsentient,
1146 parent: AbstractLivingMetadataBundle {
1147 _marker: AbstractLiving,
1148 parent: AbstractEntityMetadataBundle {
1149 _marker: AbstractEntity,
1150 on_fire: OnFire(false),
1151 shift_key_down: ShiftKeyDown(false),
1152 sprinting: Sprinting(false),
1153 swimming: Swimming(false),
1154 currently_glowing: CurrentlyGlowing(false),
1155 invisible: Invisible(false),
1156 fall_flying: FallFlying(false),
1157 air_supply: AirSupply(Default::default()),
1158 custom_name: CustomName(Default::default()),
1159 custom_name_visible: CustomNameVisible(Default::default()),
1160 silent: Silent(Default::default()),
1161 no_gravity: NoGravity(Default::default()),
1162 pose: Pose::default(),
1163 ticks_frozen: TicksFrozen(Default::default()),
1164 },
1165 auto_spin_attack: AutoSpinAttack(false),
1166 abstract_living_using_item: AbstractLivingUsingItem(false),
1167 health: Health(1.0),
1168 effect_particles: EffectParticles(Default::default()),
1169 effect_ambience: EffectAmbience(false),
1170 arrow_count: ArrowCount(0),
1171 stinger_count: StingerCount(0),
1172 sleeping_pos: SleepingPos(None),
1173 },
1174 no_ai: NoAi(false),
1175 left_handed: LeftHanded(false),
1176 aggressive: Aggressive(false),
1177 },
1178 },
1179 },
1180 charged: Charged(false),
1181 }
1182 }
1183}
1184
1185#[derive(Component, Deref, DerefMut, Clone)]
1186pub struct TransformationInterpolationStartDeltaTicks(pub i32);
1187#[derive(Component, Deref, DerefMut, Clone)]
1188pub struct TransformationInterpolationDuration(pub i32);
1189#[derive(Component, Deref, DerefMut, Clone)]
1190pub struct PosRotInterpolationDuration(pub i32);
1191#[derive(Component, Deref, DerefMut, Clone)]
1192pub struct Translation(pub Vec3);
1193#[derive(Component, Deref, DerefMut, Clone)]
1194pub struct Scale(pub Vec3);
1195#[derive(Component, Deref, DerefMut, Clone)]
1196pub struct LeftRotation(pub Quaternion);
1197#[derive(Component, Deref, DerefMut, Clone)]
1198pub struct RightRotation(pub Quaternion);
1199#[derive(Component, Deref, DerefMut, Clone)]
1200pub struct BillboardRenderConstraints(pub u8);
1201#[derive(Component, Deref, DerefMut, Clone)]
1202pub struct BrightnessOverride(pub i32);
1203#[derive(Component, Deref, DerefMut, Clone)]
1204pub struct ViewRange(pub f32);
1205#[derive(Component, Deref, DerefMut, Clone)]
1206pub struct ShadowRadius(pub f32);
1207#[derive(Component, Deref, DerefMut, Clone)]
1208pub struct ShadowStrength(pub f32);
1209#[derive(Component, Deref, DerefMut, Clone)]
1210pub struct AbstractDisplayWidth(pub f32);
1211#[derive(Component, Deref, DerefMut, Clone)]
1212pub struct AbstractDisplayHeight(pub f32);
1213#[derive(Component, Deref, DerefMut, Clone)]
1214pub struct GlowColorOverride(pub i32);
1215#[derive(Component, Deref, DerefMut, Clone)]
1216pub struct BlockDisplayBlockState(pub azalea_block::BlockState);
1217#[derive(Component)]
1218pub struct BlockDisplay;
1219impl BlockDisplay {
1220 pub fn apply_metadata(
1221 entity: &mut bevy_ecs::system::EntityCommands,
1222 d: EntityDataItem,
1223 ) -> Result<(), UpdateMetadataError> {
1224 match d.index {
1225 0..=22 => AbstractDisplay::apply_metadata(entity, d)?,
1226 23 => {
1227 entity.insert(BlockDisplayBlockState(d.value.into_block_state()?));
1228 }
1229 _ => {}
1230 }
1231 Ok(())
1232 }
1233}
1234
1235#[derive(Bundle)]
1236pub struct BlockDisplayMetadataBundle {
1237 _marker: BlockDisplay,
1238 parent: AbstractDisplayMetadataBundle,
1239 block_display_block_state: BlockDisplayBlockState,
1240}
1241impl Default for BlockDisplayMetadataBundle {
1242 fn default() -> Self {
1243 Self {
1244 _marker: BlockDisplay,
1245 parent: AbstractDisplayMetadataBundle {
1246 _marker: AbstractDisplay,
1247 parent: AbstractEntityMetadataBundle {
1248 _marker: AbstractEntity,
1249 on_fire: OnFire(false),
1250 shift_key_down: ShiftKeyDown(false),
1251 sprinting: Sprinting(false),
1252 swimming: Swimming(false),
1253 currently_glowing: CurrentlyGlowing(false),
1254 invisible: Invisible(false),
1255 fall_flying: FallFlying(false),
1256 air_supply: AirSupply(Default::default()),
1257 custom_name: CustomName(Default::default()),
1258 custom_name_visible: CustomNameVisible(Default::default()),
1259 silent: Silent(Default::default()),
1260 no_gravity: NoGravity(Default::default()),
1261 pose: Pose::default(),
1262 ticks_frozen: TicksFrozen(Default::default()),
1263 },
1264 transformation_interpolation_start_delta_ticks:
1265 TransformationInterpolationStartDeltaTicks(0),
1266 transformation_interpolation_duration: TransformationInterpolationDuration(0),
1267 pos_rot_interpolation_duration: PosRotInterpolationDuration(0),
1268 translation: Translation(Vec3 {
1269 x: 0.0,
1270 y: 0.0,
1271 z: 0.0,
1272 }),
1273 scale: Scale(Vec3 {
1274 x: 1.0,
1275 y: 1.0,
1276 z: 1.0,
1277 }),
1278 left_rotation: LeftRotation(Quaternion {
1279 x: 0.0,
1280 y: 0.0,
1281 z: 0.0,
1282 w: 1.0,
1283 }),
1284 right_rotation: RightRotation(Quaternion {
1285 x: 0.0,
1286 y: 0.0,
1287 z: 0.0,
1288 w: 1.0,
1289 }),
1290 billboard_render_constraints: BillboardRenderConstraints(Default::default()),
1291 brightness_override: BrightnessOverride(-1),
1292 view_range: ViewRange(1.0),
1293 shadow_radius: ShadowRadius(0.0),
1294 shadow_strength: ShadowStrength(1.0),
1295 abstract_display_width: AbstractDisplayWidth(0.0),
1296 abstract_display_height: AbstractDisplayHeight(0.0),
1297 glow_color_override: GlowColorOverride(-1),
1298 },
1299 block_display_block_state: BlockDisplayBlockState(Default::default()),
1300 }
1301 }
1302}
1303
1304#[derive(Component, Deref, DerefMut, Clone)]
1305pub struct BoggedSheared(pub bool);
1306#[derive(Component)]
1307pub struct Bogged;
1308impl Bogged {
1309 pub fn apply_metadata(
1310 entity: &mut bevy_ecs::system::EntityCommands,
1311 d: EntityDataItem,
1312 ) -> Result<(), UpdateMetadataError> {
1313 match d.index {
1314 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
1315 16 => {
1316 entity.insert(BoggedSheared(d.value.into_boolean()?));
1317 }
1318 _ => {}
1319 }
1320 Ok(())
1321 }
1322}
1323
1324#[derive(Bundle)]
1325pub struct BoggedMetadataBundle {
1326 _marker: Bogged,
1327 parent: AbstractMonsterMetadataBundle,
1328 bogged_sheared: BoggedSheared,
1329}
1330impl Default for BoggedMetadataBundle {
1331 fn default() -> Self {
1332 Self {
1333 _marker: Bogged,
1334 parent: AbstractMonsterMetadataBundle {
1335 _marker: AbstractMonster,
1336 parent: AbstractCreatureMetadataBundle {
1337 _marker: AbstractCreature,
1338 parent: AbstractInsentientMetadataBundle {
1339 _marker: AbstractInsentient,
1340 parent: AbstractLivingMetadataBundle {
1341 _marker: AbstractLiving,
1342 parent: AbstractEntityMetadataBundle {
1343 _marker: AbstractEntity,
1344 on_fire: OnFire(false),
1345 shift_key_down: ShiftKeyDown(false),
1346 sprinting: Sprinting(false),
1347 swimming: Swimming(false),
1348 currently_glowing: CurrentlyGlowing(false),
1349 invisible: Invisible(false),
1350 fall_flying: FallFlying(false),
1351 air_supply: AirSupply(Default::default()),
1352 custom_name: CustomName(Default::default()),
1353 custom_name_visible: CustomNameVisible(Default::default()),
1354 silent: Silent(Default::default()),
1355 no_gravity: NoGravity(Default::default()),
1356 pose: Pose::default(),
1357 ticks_frozen: TicksFrozen(Default::default()),
1358 },
1359 auto_spin_attack: AutoSpinAttack(false),
1360 abstract_living_using_item: AbstractLivingUsingItem(false),
1361 health: Health(1.0),
1362 effect_particles: EffectParticles(Default::default()),
1363 effect_ambience: EffectAmbience(false),
1364 arrow_count: ArrowCount(0),
1365 stinger_count: StingerCount(0),
1366 sleeping_pos: SleepingPos(None),
1367 },
1368 no_ai: NoAi(false),
1369 left_handed: LeftHanded(false),
1370 aggressive: Aggressive(false),
1371 },
1372 },
1373 },
1374 bogged_sheared: BoggedSheared(false),
1375 }
1376 }
1377}
1378
1379#[derive(Component)]
1380pub struct Breeze;
1381impl Breeze {
1382 pub fn apply_metadata(
1383 entity: &mut bevy_ecs::system::EntityCommands,
1384 d: EntityDataItem,
1385 ) -> Result<(), UpdateMetadataError> {
1386 match d.index {
1387 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
1388 _ => {}
1389 }
1390 Ok(())
1391 }
1392}
1393
1394#[derive(Bundle)]
1395pub struct BreezeMetadataBundle {
1396 _marker: Breeze,
1397 parent: AbstractMonsterMetadataBundle,
1398}
1399impl Default for BreezeMetadataBundle {
1400 fn default() -> Self {
1401 Self {
1402 _marker: Breeze,
1403 parent: AbstractMonsterMetadataBundle {
1404 _marker: AbstractMonster,
1405 parent: AbstractCreatureMetadataBundle {
1406 _marker: AbstractCreature,
1407 parent: AbstractInsentientMetadataBundle {
1408 _marker: AbstractInsentient,
1409 parent: AbstractLivingMetadataBundle {
1410 _marker: AbstractLiving,
1411 parent: AbstractEntityMetadataBundle {
1412 _marker: AbstractEntity,
1413 on_fire: OnFire(false),
1414 shift_key_down: ShiftKeyDown(false),
1415 sprinting: Sprinting(false),
1416 swimming: Swimming(false),
1417 currently_glowing: CurrentlyGlowing(false),
1418 invisible: Invisible(false),
1419 fall_flying: FallFlying(false),
1420 air_supply: AirSupply(Default::default()),
1421 custom_name: CustomName(Default::default()),
1422 custom_name_visible: CustomNameVisible(Default::default()),
1423 silent: Silent(Default::default()),
1424 no_gravity: NoGravity(Default::default()),
1425 pose: Pose::default(),
1426 ticks_frozen: TicksFrozen(Default::default()),
1427 },
1428 auto_spin_attack: AutoSpinAttack(false),
1429 abstract_living_using_item: AbstractLivingUsingItem(false),
1430 health: Health(1.0),
1431 effect_particles: EffectParticles(Default::default()),
1432 effect_ambience: EffectAmbience(false),
1433 arrow_count: ArrowCount(0),
1434 stinger_count: StingerCount(0),
1435 sleeping_pos: SleepingPos(None),
1436 },
1437 no_ai: NoAi(false),
1438 left_handed: LeftHanded(false),
1439 aggressive: Aggressive(false),
1440 },
1441 },
1442 },
1443 }
1444 }
1445}
1446
1447#[derive(Component)]
1448pub struct BreezeWindCharge;
1449impl BreezeWindCharge {
1450 pub fn apply_metadata(
1451 entity: &mut bevy_ecs::system::EntityCommands,
1452 d: EntityDataItem,
1453 ) -> Result<(), UpdateMetadataError> {
1454 match d.index {
1455 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
1456 _ => {}
1457 }
1458 Ok(())
1459 }
1460}
1461
1462#[derive(Bundle)]
1463pub struct BreezeWindChargeMetadataBundle {
1464 _marker: BreezeWindCharge,
1465 parent: AbstractEntityMetadataBundle,
1466}
1467impl Default for BreezeWindChargeMetadataBundle {
1468 fn default() -> Self {
1469 Self {
1470 _marker: BreezeWindCharge,
1471 parent: AbstractEntityMetadataBundle {
1472 _marker: AbstractEntity,
1473 on_fire: OnFire(false),
1474 shift_key_down: ShiftKeyDown(false),
1475 sprinting: Sprinting(false),
1476 swimming: Swimming(false),
1477 currently_glowing: CurrentlyGlowing(false),
1478 invisible: Invisible(false),
1479 fall_flying: FallFlying(false),
1480 air_supply: AirSupply(Default::default()),
1481 custom_name: CustomName(Default::default()),
1482 custom_name_visible: CustomNameVisible(Default::default()),
1483 silent: Silent(Default::default()),
1484 no_gravity: NoGravity(Default::default()),
1485 pose: Pose::default(),
1486 ticks_frozen: TicksFrozen(Default::default()),
1487 },
1488 }
1489 }
1490}
1491
1492#[derive(Component, Deref, DerefMut, Clone, Copy)]
1493pub struct Tamed(pub bool);
1494#[derive(Component, Deref, DerefMut, Clone, Copy)]
1495pub struct Eating(pub bool);
1496#[derive(Component, Deref, DerefMut, Clone, Copy)]
1497pub struct AbstractHorseStanding(pub bool);
1498#[derive(Component, Deref, DerefMut, Clone, Copy)]
1499pub struct Bred(pub bool);
1500#[derive(Component, Deref, DerefMut, Clone)]
1501pub struct Dash(pub bool);
1502#[derive(Component, Deref, DerefMut, Clone)]
1503pub struct LastPoseChangeTick(pub i64);
1504#[derive(Component)]
1505pub struct Camel;
1506impl Camel {
1507 pub fn apply_metadata(
1508 entity: &mut bevy_ecs::system::EntityCommands,
1509 d: EntityDataItem,
1510 ) -> Result<(), UpdateMetadataError> {
1511 match d.index {
1512 0..=17 => AbstractHorse::apply_metadata(entity, d)?,
1513 18 => {
1514 entity.insert(Dash(d.value.into_boolean()?));
1515 }
1516 19 => {
1517 entity.insert(LastPoseChangeTick(d.value.into_long()?));
1518 }
1519 _ => {}
1520 }
1521 Ok(())
1522 }
1523}
1524
1525#[derive(Bundle)]
1526pub struct CamelMetadataBundle {
1527 _marker: Camel,
1528 parent: AbstractHorseMetadataBundle,
1529 dash: Dash,
1530 last_pose_change_tick: LastPoseChangeTick,
1531}
1532impl Default for CamelMetadataBundle {
1533 fn default() -> Self {
1534 Self {
1535 _marker: Camel,
1536 parent: AbstractHorseMetadataBundle {
1537 _marker: AbstractHorse,
1538 parent: AbstractAnimalMetadataBundle {
1539 _marker: AbstractAnimal,
1540 parent: AbstractAgeableMetadataBundle {
1541 _marker: AbstractAgeable,
1542 parent: AbstractCreatureMetadataBundle {
1543 _marker: AbstractCreature,
1544 parent: AbstractInsentientMetadataBundle {
1545 _marker: AbstractInsentient,
1546 parent: AbstractLivingMetadataBundle {
1547 _marker: AbstractLiving,
1548 parent: AbstractEntityMetadataBundle {
1549 _marker: AbstractEntity,
1550 on_fire: OnFire(false),
1551 shift_key_down: ShiftKeyDown(false),
1552 sprinting: Sprinting(false),
1553 swimming: Swimming(false),
1554 currently_glowing: CurrentlyGlowing(false),
1555 invisible: Invisible(false),
1556 fall_flying: FallFlying(false),
1557 air_supply: AirSupply(Default::default()),
1558 custom_name: CustomName(Default::default()),
1559 custom_name_visible: CustomNameVisible(Default::default()),
1560 silent: Silent(Default::default()),
1561 no_gravity: NoGravity(Default::default()),
1562 pose: Pose::default(),
1563 ticks_frozen: TicksFrozen(Default::default()),
1564 },
1565 auto_spin_attack: AutoSpinAttack(false),
1566 abstract_living_using_item: AbstractLivingUsingItem(false),
1567 health: Health(1.0),
1568 effect_particles: EffectParticles(Default::default()),
1569 effect_ambience: EffectAmbience(false),
1570 arrow_count: ArrowCount(0),
1571 stinger_count: StingerCount(0),
1572 sleeping_pos: SleepingPos(None),
1573 },
1574 no_ai: NoAi(false),
1575 left_handed: LeftHanded(false),
1576 aggressive: Aggressive(false),
1577 },
1578 },
1579 abstract_ageable_baby: AbstractAgeableBaby(false),
1580 },
1581 },
1582 tamed: Tamed(false),
1583 eating: Eating(false),
1584 abstract_horse_standing: AbstractHorseStanding(false),
1585 bred: Bred(false),
1586 },
1587 dash: Dash(false),
1588 last_pose_change_tick: LastPoseChangeTick(0),
1589 }
1590 }
1591}
1592
1593#[derive(Component, Deref, DerefMut, Clone, Copy)]
1594pub struct Tame(pub bool);
1595#[derive(Component, Deref, DerefMut, Clone, Copy)]
1596pub struct InSittingPose(pub bool);
1597#[derive(Component, Deref, DerefMut, Clone)]
1598pub struct Owneruuid(pub Option<Uuid>);
1599#[derive(Component, Deref, DerefMut, Clone)]
1600pub struct CatVariant(pub azalea_registry::CatVariant);
1601#[derive(Component, Deref, DerefMut, Clone)]
1602pub struct IsLying(pub bool);
1603#[derive(Component, Deref, DerefMut, Clone)]
1604pub struct RelaxStateOne(pub bool);
1605#[derive(Component, Deref, DerefMut, Clone)]
1606pub struct CatCollarColor(pub i32);
1607#[derive(Component)]
1608pub struct Cat;
1609impl Cat {
1610 pub fn apply_metadata(
1611 entity: &mut bevy_ecs::system::EntityCommands,
1612 d: EntityDataItem,
1613 ) -> Result<(), UpdateMetadataError> {
1614 match d.index {
1615 0..=18 => AbstractTameable::apply_metadata(entity, d)?,
1616 19 => {
1617 entity.insert(CatVariant(d.value.into_cat_variant()?));
1618 }
1619 20 => {
1620 entity.insert(IsLying(d.value.into_boolean()?));
1621 }
1622 21 => {
1623 entity.insert(RelaxStateOne(d.value.into_boolean()?));
1624 }
1625 22 => {
1626 entity.insert(CatCollarColor(d.value.into_int()?));
1627 }
1628 _ => {}
1629 }
1630 Ok(())
1631 }
1632}
1633
1634#[derive(Bundle)]
1635pub struct CatMetadataBundle {
1636 _marker: Cat,
1637 parent: AbstractTameableMetadataBundle,
1638 cat_variant: CatVariant,
1639 is_lying: IsLying,
1640 relax_state_one: RelaxStateOne,
1641 cat_collar_color: CatCollarColor,
1642}
1643impl Default for CatMetadataBundle {
1644 fn default() -> Self {
1645 Self {
1646 _marker: Cat,
1647 parent: AbstractTameableMetadataBundle {
1648 _marker: AbstractTameable,
1649 parent: AbstractAnimalMetadataBundle {
1650 _marker: AbstractAnimal,
1651 parent: AbstractAgeableMetadataBundle {
1652 _marker: AbstractAgeable,
1653 parent: AbstractCreatureMetadataBundle {
1654 _marker: AbstractCreature,
1655 parent: AbstractInsentientMetadataBundle {
1656 _marker: AbstractInsentient,
1657 parent: AbstractLivingMetadataBundle {
1658 _marker: AbstractLiving,
1659 parent: AbstractEntityMetadataBundle {
1660 _marker: AbstractEntity,
1661 on_fire: OnFire(false),
1662 shift_key_down: ShiftKeyDown(false),
1663 sprinting: Sprinting(false),
1664 swimming: Swimming(false),
1665 currently_glowing: CurrentlyGlowing(false),
1666 invisible: Invisible(false),
1667 fall_flying: FallFlying(false),
1668 air_supply: AirSupply(Default::default()),
1669 custom_name: CustomName(Default::default()),
1670 custom_name_visible: CustomNameVisible(Default::default()),
1671 silent: Silent(Default::default()),
1672 no_gravity: NoGravity(Default::default()),
1673 pose: Pose::default(),
1674 ticks_frozen: TicksFrozen(Default::default()),
1675 },
1676 auto_spin_attack: AutoSpinAttack(false),
1677 abstract_living_using_item: AbstractLivingUsingItem(false),
1678 health: Health(1.0),
1679 effect_particles: EffectParticles(Default::default()),
1680 effect_ambience: EffectAmbience(false),
1681 arrow_count: ArrowCount(0),
1682 stinger_count: StingerCount(0),
1683 sleeping_pos: SleepingPos(None),
1684 },
1685 no_ai: NoAi(false),
1686 left_handed: LeftHanded(false),
1687 aggressive: Aggressive(false),
1688 },
1689 },
1690 abstract_ageable_baby: AbstractAgeableBaby(false),
1691 },
1692 },
1693 tame: Tame(false),
1694 in_sitting_pose: InSittingPose(false),
1695 owneruuid: Owneruuid(None),
1696 },
1697 cat_variant: CatVariant(azalea_registry::CatVariant::new_raw(0)),
1698 is_lying: IsLying(false),
1699 relax_state_one: RelaxStateOne(false),
1700 cat_collar_color: CatCollarColor(Default::default()),
1701 }
1702 }
1703}
1704
1705#[derive(Component, Deref, DerefMut, Clone, Copy)]
1706pub struct Climbing(pub bool);
1707#[derive(Component)]
1708pub struct CaveSpider;
1709impl CaveSpider {
1710 pub fn apply_metadata(
1711 entity: &mut bevy_ecs::system::EntityCommands,
1712 d: EntityDataItem,
1713 ) -> Result<(), UpdateMetadataError> {
1714 match d.index {
1715 0..=16 => Spider::apply_metadata(entity, d)?,
1716 _ => {}
1717 }
1718 Ok(())
1719 }
1720}
1721
1722#[derive(Bundle)]
1723pub struct CaveSpiderMetadataBundle {
1724 _marker: CaveSpider,
1725 parent: SpiderMetadataBundle,
1726}
1727impl Default for CaveSpiderMetadataBundle {
1728 fn default() -> Self {
1729 Self {
1730 _marker: CaveSpider,
1731 parent: SpiderMetadataBundle {
1732 _marker: Spider,
1733 parent: AbstractMonsterMetadataBundle {
1734 _marker: AbstractMonster,
1735 parent: AbstractCreatureMetadataBundle {
1736 _marker: AbstractCreature,
1737 parent: AbstractInsentientMetadataBundle {
1738 _marker: AbstractInsentient,
1739 parent: AbstractLivingMetadataBundle {
1740 _marker: AbstractLiving,
1741 parent: AbstractEntityMetadataBundle {
1742 _marker: AbstractEntity,
1743 on_fire: OnFire(false),
1744 shift_key_down: ShiftKeyDown(false),
1745 sprinting: Sprinting(false),
1746 swimming: Swimming(false),
1747 currently_glowing: CurrentlyGlowing(false),
1748 invisible: Invisible(false),
1749 fall_flying: FallFlying(false),
1750 air_supply: AirSupply(Default::default()),
1751 custom_name: CustomName(Default::default()),
1752 custom_name_visible: CustomNameVisible(Default::default()),
1753 silent: Silent(Default::default()),
1754 no_gravity: NoGravity(Default::default()),
1755 pose: Pose::default(),
1756 ticks_frozen: TicksFrozen(Default::default()),
1757 },
1758 auto_spin_attack: AutoSpinAttack(false),
1759 abstract_living_using_item: AbstractLivingUsingItem(false),
1760 health: Health(1.0),
1761 effect_particles: EffectParticles(Default::default()),
1762 effect_ambience: EffectAmbience(false),
1763 arrow_count: ArrowCount(0),
1764 stinger_count: StingerCount(0),
1765 sleeping_pos: SleepingPos(None),
1766 },
1767 no_ai: NoAi(false),
1768 left_handed: LeftHanded(false),
1769 aggressive: Aggressive(false),
1770 },
1771 },
1772 },
1773 climbing: Climbing(false),
1774 },
1775 }
1776 }
1777}
1778
1779#[derive(Component)]
1780pub struct CherryBoat;
1781impl CherryBoat {
1782 pub fn apply_metadata(
1783 entity: &mut bevy_ecs::system::EntityCommands,
1784 d: EntityDataItem,
1785 ) -> Result<(), UpdateMetadataError> {
1786 match d.index {
1787 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
1788 _ => {}
1789 }
1790 Ok(())
1791 }
1792}
1793
1794#[derive(Bundle)]
1795pub struct CherryBoatMetadataBundle {
1796 _marker: CherryBoat,
1797 parent: AbstractBoatMetadataBundle,
1798}
1799impl Default for CherryBoatMetadataBundle {
1800 fn default() -> Self {
1801 Self {
1802 _marker: CherryBoat,
1803 parent: AbstractBoatMetadataBundle {
1804 _marker: AbstractBoat,
1805 parent: AbstractVehicleMetadataBundle {
1806 _marker: AbstractVehicle,
1807 parent: AbstractEntityMetadataBundle {
1808 _marker: AbstractEntity,
1809 on_fire: OnFire(false),
1810 shift_key_down: ShiftKeyDown(false),
1811 sprinting: Sprinting(false),
1812 swimming: Swimming(false),
1813 currently_glowing: CurrentlyGlowing(false),
1814 invisible: Invisible(false),
1815 fall_flying: FallFlying(false),
1816 air_supply: AirSupply(Default::default()),
1817 custom_name: CustomName(Default::default()),
1818 custom_name_visible: CustomNameVisible(Default::default()),
1819 silent: Silent(Default::default()),
1820 no_gravity: NoGravity(Default::default()),
1821 pose: Pose::default(),
1822 ticks_frozen: TicksFrozen(Default::default()),
1823 },
1824 hurt: Hurt(0),
1825 hurtdir: Hurtdir(1),
1826 damage: Damage(0.0),
1827 },
1828 paddle_left: PaddleLeft(false),
1829 paddle_right: PaddleRight(false),
1830 bubble_time: BubbleTime(0),
1831 },
1832 }
1833 }
1834}
1835
1836#[derive(Component)]
1837pub struct CherryChestBoat;
1838impl CherryChestBoat {
1839 pub fn apply_metadata(
1840 entity: &mut bevy_ecs::system::EntityCommands,
1841 d: EntityDataItem,
1842 ) -> Result<(), UpdateMetadataError> {
1843 match d.index {
1844 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
1845 _ => {}
1846 }
1847 Ok(())
1848 }
1849}
1850
1851#[derive(Bundle)]
1852pub struct CherryChestBoatMetadataBundle {
1853 _marker: CherryChestBoat,
1854 parent: AbstractBoatMetadataBundle,
1855}
1856impl Default for CherryChestBoatMetadataBundle {
1857 fn default() -> Self {
1858 Self {
1859 _marker: CherryChestBoat,
1860 parent: AbstractBoatMetadataBundle {
1861 _marker: AbstractBoat,
1862 parent: AbstractVehicleMetadataBundle {
1863 _marker: AbstractVehicle,
1864 parent: AbstractEntityMetadataBundle {
1865 _marker: AbstractEntity,
1866 on_fire: OnFire(false),
1867 shift_key_down: ShiftKeyDown(false),
1868 sprinting: Sprinting(false),
1869 swimming: Swimming(false),
1870 currently_glowing: CurrentlyGlowing(false),
1871 invisible: Invisible(false),
1872 fall_flying: FallFlying(false),
1873 air_supply: AirSupply(Default::default()),
1874 custom_name: CustomName(Default::default()),
1875 custom_name_visible: CustomNameVisible(Default::default()),
1876 silent: Silent(Default::default()),
1877 no_gravity: NoGravity(Default::default()),
1878 pose: Pose::default(),
1879 ticks_frozen: TicksFrozen(Default::default()),
1880 },
1881 hurt: Hurt(0),
1882 hurtdir: Hurtdir(1),
1883 damage: Damage(0.0),
1884 },
1885 paddle_left: PaddleLeft(false),
1886 paddle_right: PaddleRight(false),
1887 bubble_time: BubbleTime(0),
1888 },
1889 }
1890 }
1891}
1892
1893#[derive(Component, Deref, DerefMut, Clone)]
1894pub struct CustomDisplayBlock(pub azalea_block::BlockState);
1895#[derive(Component, Deref, DerefMut, Clone)]
1896pub struct DisplayOffset(pub i32);
1897#[derive(Component)]
1898pub struct ChestMinecart;
1899impl ChestMinecart {
1900 pub fn apply_metadata(
1901 entity: &mut bevy_ecs::system::EntityCommands,
1902 d: EntityDataItem,
1903 ) -> Result<(), UpdateMetadataError> {
1904 match d.index {
1905 0..=12 => AbstractMinecart::apply_metadata(entity, d)?,
1906 _ => {}
1907 }
1908 Ok(())
1909 }
1910}
1911
1912#[derive(Bundle)]
1913pub struct ChestMinecartMetadataBundle {
1914 _marker: ChestMinecart,
1915 parent: AbstractMinecartMetadataBundle,
1916}
1917impl Default for ChestMinecartMetadataBundle {
1918 fn default() -> Self {
1919 Self {
1920 _marker: ChestMinecart,
1921 parent: AbstractMinecartMetadataBundle {
1922 _marker: AbstractMinecart,
1923 parent: AbstractVehicleMetadataBundle {
1924 _marker: AbstractVehicle,
1925 parent: AbstractEntityMetadataBundle {
1926 _marker: AbstractEntity,
1927 on_fire: OnFire(false),
1928 shift_key_down: ShiftKeyDown(false),
1929 sprinting: Sprinting(false),
1930 swimming: Swimming(false),
1931 currently_glowing: CurrentlyGlowing(false),
1932 invisible: Invisible(false),
1933 fall_flying: FallFlying(false),
1934 air_supply: AirSupply(Default::default()),
1935 custom_name: CustomName(Default::default()),
1936 custom_name_visible: CustomNameVisible(Default::default()),
1937 silent: Silent(Default::default()),
1938 no_gravity: NoGravity(Default::default()),
1939 pose: Pose::default(),
1940 ticks_frozen: TicksFrozen(Default::default()),
1941 },
1942 hurt: Hurt(0),
1943 hurtdir: Hurtdir(1),
1944 damage: Damage(0.0),
1945 },
1946 custom_display_block: CustomDisplayBlock(azalea_block::BlockState::AIR),
1947 display_offset: DisplayOffset(Default::default()),
1948 },
1949 }
1950 }
1951}
1952
1953#[derive(Component, Deref, DerefMut, Clone)]
1954pub struct ChickenVariant(pub azalea_registry::PigVariant);
1955#[derive(Component)]
1956pub struct Chicken;
1957impl Chicken {
1958 pub fn apply_metadata(
1959 entity: &mut bevy_ecs::system::EntityCommands,
1960 d: EntityDataItem,
1961 ) -> Result<(), UpdateMetadataError> {
1962 match d.index {
1963 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
1964 17 => {
1965 entity.insert(ChickenVariant(d.value.into_pig_variant()?));
1966 }
1967 _ => {}
1968 }
1969 Ok(())
1970 }
1971}
1972
1973#[derive(Bundle)]
1974pub struct ChickenMetadataBundle {
1975 _marker: Chicken,
1976 parent: AbstractAnimalMetadataBundle,
1977 chicken_variant: ChickenVariant,
1978}
1979impl Default for ChickenMetadataBundle {
1980 fn default() -> Self {
1981 Self {
1982 _marker: Chicken,
1983 parent: AbstractAnimalMetadataBundle {
1984 _marker: AbstractAnimal,
1985 parent: AbstractAgeableMetadataBundle {
1986 _marker: AbstractAgeable,
1987 parent: AbstractCreatureMetadataBundle {
1988 _marker: AbstractCreature,
1989 parent: AbstractInsentientMetadataBundle {
1990 _marker: AbstractInsentient,
1991 parent: AbstractLivingMetadataBundle {
1992 _marker: AbstractLiving,
1993 parent: AbstractEntityMetadataBundle {
1994 _marker: AbstractEntity,
1995 on_fire: OnFire(false),
1996 shift_key_down: ShiftKeyDown(false),
1997 sprinting: Sprinting(false),
1998 swimming: Swimming(false),
1999 currently_glowing: CurrentlyGlowing(false),
2000 invisible: Invisible(false),
2001 fall_flying: FallFlying(false),
2002 air_supply: AirSupply(Default::default()),
2003 custom_name: CustomName(Default::default()),
2004 custom_name_visible: CustomNameVisible(Default::default()),
2005 silent: Silent(Default::default()),
2006 no_gravity: NoGravity(Default::default()),
2007 pose: Pose::default(),
2008 ticks_frozen: TicksFrozen(Default::default()),
2009 },
2010 auto_spin_attack: AutoSpinAttack(false),
2011 abstract_living_using_item: AbstractLivingUsingItem(false),
2012 health: Health(1.0),
2013 effect_particles: EffectParticles(Default::default()),
2014 effect_ambience: EffectAmbience(false),
2015 arrow_count: ArrowCount(0),
2016 stinger_count: StingerCount(0),
2017 sleeping_pos: SleepingPos(None),
2018 },
2019 no_ai: NoAi(false),
2020 left_handed: LeftHanded(false),
2021 aggressive: Aggressive(false),
2022 },
2023 },
2024 abstract_ageable_baby: AbstractAgeableBaby(false),
2025 },
2026 },
2027 chicken_variant: ChickenVariant(azalea_registry::PigVariant::new_raw(0)),
2028 }
2029 }
2030}
2031
2032#[derive(Component, Deref, DerefMut, Clone)]
2033pub struct AbstractFishFromBucket(pub bool);
2034#[derive(Component)]
2035pub struct Cod;
2036impl Cod {
2037 pub fn apply_metadata(
2038 entity: &mut bevy_ecs::system::EntityCommands,
2039 d: EntityDataItem,
2040 ) -> Result<(), UpdateMetadataError> {
2041 match d.index {
2042 0..=16 => AbstractFish::apply_metadata(entity, d)?,
2043 _ => {}
2044 }
2045 Ok(())
2046 }
2047}
2048
2049#[derive(Bundle)]
2050pub struct CodMetadataBundle {
2051 _marker: Cod,
2052 parent: AbstractFishMetadataBundle,
2053}
2054impl Default for CodMetadataBundle {
2055 fn default() -> Self {
2056 Self {
2057 _marker: Cod,
2058 parent: AbstractFishMetadataBundle {
2059 _marker: AbstractFish,
2060 parent: AbstractCreatureMetadataBundle {
2061 _marker: AbstractCreature,
2062 parent: AbstractInsentientMetadataBundle {
2063 _marker: AbstractInsentient,
2064 parent: AbstractLivingMetadataBundle {
2065 _marker: AbstractLiving,
2066 parent: AbstractEntityMetadataBundle {
2067 _marker: AbstractEntity,
2068 on_fire: OnFire(false),
2069 shift_key_down: ShiftKeyDown(false),
2070 sprinting: Sprinting(false),
2071 swimming: Swimming(false),
2072 currently_glowing: CurrentlyGlowing(false),
2073 invisible: Invisible(false),
2074 fall_flying: FallFlying(false),
2075 air_supply: AirSupply(Default::default()),
2076 custom_name: CustomName(Default::default()),
2077 custom_name_visible: CustomNameVisible(Default::default()),
2078 silent: Silent(Default::default()),
2079 no_gravity: NoGravity(Default::default()),
2080 pose: Pose::default(),
2081 ticks_frozen: TicksFrozen(Default::default()),
2082 },
2083 auto_spin_attack: AutoSpinAttack(false),
2084 abstract_living_using_item: AbstractLivingUsingItem(false),
2085 health: Health(1.0),
2086 effect_particles: EffectParticles(Default::default()),
2087 effect_ambience: EffectAmbience(false),
2088 arrow_count: ArrowCount(0),
2089 stinger_count: StingerCount(0),
2090 sleeping_pos: SleepingPos(None),
2091 },
2092 no_ai: NoAi(false),
2093 left_handed: LeftHanded(false),
2094 aggressive: Aggressive(false),
2095 },
2096 },
2097 abstract_fish_from_bucket: AbstractFishFromBucket(false),
2098 },
2099 }
2100 }
2101}
2102
2103#[derive(Component, Deref, DerefMut, Clone)]
2104pub struct CommandName(pub String);
2105#[derive(Component, Deref, DerefMut, Clone)]
2106pub struct LastOutput(pub FormattedText);
2107#[derive(Component)]
2108pub struct CommandBlockMinecart;
2109impl CommandBlockMinecart {
2110 pub fn apply_metadata(
2111 entity: &mut bevy_ecs::system::EntityCommands,
2112 d: EntityDataItem,
2113 ) -> Result<(), UpdateMetadataError> {
2114 match d.index {
2115 0..=12 => AbstractMinecart::apply_metadata(entity, d)?,
2116 13 => {
2117 entity.insert(CommandName(d.value.into_string()?));
2118 }
2119 14 => {
2120 entity.insert(LastOutput(d.value.into_formatted_text()?));
2121 }
2122 _ => {}
2123 }
2124 Ok(())
2125 }
2126}
2127
2128#[derive(Bundle)]
2129pub struct CommandBlockMinecartMetadataBundle {
2130 _marker: CommandBlockMinecart,
2131 parent: AbstractMinecartMetadataBundle,
2132 command_name: CommandName,
2133 last_output: LastOutput,
2134}
2135impl Default for CommandBlockMinecartMetadataBundle {
2136 fn default() -> Self {
2137 Self {
2138 _marker: CommandBlockMinecart,
2139 parent: AbstractMinecartMetadataBundle {
2140 _marker: AbstractMinecart,
2141 parent: AbstractVehicleMetadataBundle {
2142 _marker: AbstractVehicle,
2143 parent: AbstractEntityMetadataBundle {
2144 _marker: AbstractEntity,
2145 on_fire: OnFire(false),
2146 shift_key_down: ShiftKeyDown(false),
2147 sprinting: Sprinting(false),
2148 swimming: Swimming(false),
2149 currently_glowing: CurrentlyGlowing(false),
2150 invisible: Invisible(false),
2151 fall_flying: FallFlying(false),
2152 air_supply: AirSupply(Default::default()),
2153 custom_name: CustomName(Default::default()),
2154 custom_name_visible: CustomNameVisible(Default::default()),
2155 silent: Silent(Default::default()),
2156 no_gravity: NoGravity(Default::default()),
2157 pose: Pose::default(),
2158 ticks_frozen: TicksFrozen(Default::default()),
2159 },
2160 hurt: Hurt(0),
2161 hurtdir: Hurtdir(1),
2162 damage: Damage(0.0),
2163 },
2164 custom_display_block: CustomDisplayBlock(azalea_block::BlockState::AIR),
2165 display_offset: DisplayOffset(Default::default()),
2166 },
2167 command_name: CommandName("".to_string()),
2168 last_output: LastOutput(Default::default()),
2169 }
2170 }
2171}
2172
2173#[derive(Component, Deref, DerefMut, Clone)]
2174pub struct CowVariant(pub azalea_registry::ChickenVariant);
2175#[derive(Component)]
2176pub struct Cow;
2177impl Cow {
2178 pub fn apply_metadata(
2179 entity: &mut bevy_ecs::system::EntityCommands,
2180 d: EntityDataItem,
2181 ) -> Result<(), UpdateMetadataError> {
2182 match d.index {
2183 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
2184 17 => {
2185 entity.insert(CowVariant(d.value.into_chicken_variant()?));
2186 }
2187 _ => {}
2188 }
2189 Ok(())
2190 }
2191}
2192
2193#[derive(Bundle)]
2194pub struct CowMetadataBundle {
2195 _marker: Cow,
2196 parent: AbstractAnimalMetadataBundle,
2197 cow_variant: CowVariant,
2198}
2199impl Default for CowMetadataBundle {
2200 fn default() -> Self {
2201 Self {
2202 _marker: Cow,
2203 parent: AbstractAnimalMetadataBundle {
2204 _marker: AbstractAnimal,
2205 parent: AbstractAgeableMetadataBundle {
2206 _marker: AbstractAgeable,
2207 parent: AbstractCreatureMetadataBundle {
2208 _marker: AbstractCreature,
2209 parent: AbstractInsentientMetadataBundle {
2210 _marker: AbstractInsentient,
2211 parent: AbstractLivingMetadataBundle {
2212 _marker: AbstractLiving,
2213 parent: AbstractEntityMetadataBundle {
2214 _marker: AbstractEntity,
2215 on_fire: OnFire(false),
2216 shift_key_down: ShiftKeyDown(false),
2217 sprinting: Sprinting(false),
2218 swimming: Swimming(false),
2219 currently_glowing: CurrentlyGlowing(false),
2220 invisible: Invisible(false),
2221 fall_flying: FallFlying(false),
2222 air_supply: AirSupply(Default::default()),
2223 custom_name: CustomName(Default::default()),
2224 custom_name_visible: CustomNameVisible(Default::default()),
2225 silent: Silent(Default::default()),
2226 no_gravity: NoGravity(Default::default()),
2227 pose: Pose::default(),
2228 ticks_frozen: TicksFrozen(Default::default()),
2229 },
2230 auto_spin_attack: AutoSpinAttack(false),
2231 abstract_living_using_item: AbstractLivingUsingItem(false),
2232 health: Health(1.0),
2233 effect_particles: EffectParticles(Default::default()),
2234 effect_ambience: EffectAmbience(false),
2235 arrow_count: ArrowCount(0),
2236 stinger_count: StingerCount(0),
2237 sleeping_pos: SleepingPos(None),
2238 },
2239 no_ai: NoAi(false),
2240 left_handed: LeftHanded(false),
2241 aggressive: Aggressive(false),
2242 },
2243 },
2244 abstract_ageable_baby: AbstractAgeableBaby(false),
2245 },
2246 },
2247 cow_variant: CowVariant(azalea_registry::ChickenVariant::new_raw(0)),
2248 }
2249 }
2250}
2251
2252#[derive(Component, Deref, DerefMut, Clone)]
2253pub struct CanMove(pub bool);
2254#[derive(Component, Deref, DerefMut, Clone)]
2255pub struct IsActive(pub bool);
2256#[derive(Component, Deref, DerefMut, Clone)]
2257pub struct IsTearingDown(pub bool);
2258#[derive(Component, Deref, DerefMut, Clone)]
2259pub struct HomePos(pub Option<BlockPos>);
2260#[derive(Component)]
2261pub struct Creaking;
2262impl Creaking {
2263 pub fn apply_metadata(
2264 entity: &mut bevy_ecs::system::EntityCommands,
2265 d: EntityDataItem,
2266 ) -> Result<(), UpdateMetadataError> {
2267 match d.index {
2268 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
2269 16 => {
2270 entity.insert(CanMove(d.value.into_boolean()?));
2271 }
2272 17 => {
2273 entity.insert(IsActive(d.value.into_boolean()?));
2274 }
2275 18 => {
2276 entity.insert(IsTearingDown(d.value.into_boolean()?));
2277 }
2278 19 => {
2279 entity.insert(HomePos(d.value.into_optional_block_pos()?));
2280 }
2281 _ => {}
2282 }
2283 Ok(())
2284 }
2285}
2286
2287#[derive(Bundle)]
2288pub struct CreakingMetadataBundle {
2289 _marker: Creaking,
2290 parent: AbstractMonsterMetadataBundle,
2291 can_move: CanMove,
2292 is_active: IsActive,
2293 is_tearing_down: IsTearingDown,
2294 home_pos: HomePos,
2295}
2296impl Default for CreakingMetadataBundle {
2297 fn default() -> Self {
2298 Self {
2299 _marker: Creaking,
2300 parent: AbstractMonsterMetadataBundle {
2301 _marker: AbstractMonster,
2302 parent: AbstractCreatureMetadataBundle {
2303 _marker: AbstractCreature,
2304 parent: AbstractInsentientMetadataBundle {
2305 _marker: AbstractInsentient,
2306 parent: AbstractLivingMetadataBundle {
2307 _marker: AbstractLiving,
2308 parent: AbstractEntityMetadataBundle {
2309 _marker: AbstractEntity,
2310 on_fire: OnFire(false),
2311 shift_key_down: ShiftKeyDown(false),
2312 sprinting: Sprinting(false),
2313 swimming: Swimming(false),
2314 currently_glowing: CurrentlyGlowing(false),
2315 invisible: Invisible(false),
2316 fall_flying: FallFlying(false),
2317 air_supply: AirSupply(Default::default()),
2318 custom_name: CustomName(Default::default()),
2319 custom_name_visible: CustomNameVisible(Default::default()),
2320 silent: Silent(Default::default()),
2321 no_gravity: NoGravity(Default::default()),
2322 pose: Pose::default(),
2323 ticks_frozen: TicksFrozen(Default::default()),
2324 },
2325 auto_spin_attack: AutoSpinAttack(false),
2326 abstract_living_using_item: AbstractLivingUsingItem(false),
2327 health: Health(1.0),
2328 effect_particles: EffectParticles(Default::default()),
2329 effect_ambience: EffectAmbience(false),
2330 arrow_count: ArrowCount(0),
2331 stinger_count: StingerCount(0),
2332 sleeping_pos: SleepingPos(None),
2333 },
2334 no_ai: NoAi(false),
2335 left_handed: LeftHanded(false),
2336 aggressive: Aggressive(false),
2337 },
2338 },
2339 },
2340 can_move: CanMove(true),
2341 is_active: IsActive(false),
2342 is_tearing_down: IsTearingDown(false),
2343 home_pos: HomePos(None),
2344 }
2345 }
2346}
2347
2348#[derive(Component, Deref, DerefMut, Clone)]
2349pub struct SwellDir(pub i32);
2350#[derive(Component, Deref, DerefMut, Clone)]
2351pub struct IsPowered(pub bool);
2352#[derive(Component, Deref, DerefMut, Clone)]
2353pub struct IsIgnited(pub bool);
2354#[derive(Component)]
2355pub struct Creeper;
2356impl Creeper {
2357 pub fn apply_metadata(
2358 entity: &mut bevy_ecs::system::EntityCommands,
2359 d: EntityDataItem,
2360 ) -> Result<(), UpdateMetadataError> {
2361 match d.index {
2362 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
2363 16 => {
2364 entity.insert(SwellDir(d.value.into_int()?));
2365 }
2366 17 => {
2367 entity.insert(IsPowered(d.value.into_boolean()?));
2368 }
2369 18 => {
2370 entity.insert(IsIgnited(d.value.into_boolean()?));
2371 }
2372 _ => {}
2373 }
2374 Ok(())
2375 }
2376}
2377
2378#[derive(Bundle)]
2379pub struct CreeperMetadataBundle {
2380 _marker: Creeper,
2381 parent: AbstractMonsterMetadataBundle,
2382 swell_dir: SwellDir,
2383 is_powered: IsPowered,
2384 is_ignited: IsIgnited,
2385}
2386impl Default for CreeperMetadataBundle {
2387 fn default() -> Self {
2388 Self {
2389 _marker: Creeper,
2390 parent: AbstractMonsterMetadataBundle {
2391 _marker: AbstractMonster,
2392 parent: AbstractCreatureMetadataBundle {
2393 _marker: AbstractCreature,
2394 parent: AbstractInsentientMetadataBundle {
2395 _marker: AbstractInsentient,
2396 parent: AbstractLivingMetadataBundle {
2397 _marker: AbstractLiving,
2398 parent: AbstractEntityMetadataBundle {
2399 _marker: AbstractEntity,
2400 on_fire: OnFire(false),
2401 shift_key_down: ShiftKeyDown(false),
2402 sprinting: Sprinting(false),
2403 swimming: Swimming(false),
2404 currently_glowing: CurrentlyGlowing(false),
2405 invisible: Invisible(false),
2406 fall_flying: FallFlying(false),
2407 air_supply: AirSupply(Default::default()),
2408 custom_name: CustomName(Default::default()),
2409 custom_name_visible: CustomNameVisible(Default::default()),
2410 silent: Silent(Default::default()),
2411 no_gravity: NoGravity(Default::default()),
2412 pose: Pose::default(),
2413 ticks_frozen: TicksFrozen(Default::default()),
2414 },
2415 auto_spin_attack: AutoSpinAttack(false),
2416 abstract_living_using_item: AbstractLivingUsingItem(false),
2417 health: Health(1.0),
2418 effect_particles: EffectParticles(Default::default()),
2419 effect_ambience: EffectAmbience(false),
2420 arrow_count: ArrowCount(0),
2421 stinger_count: StingerCount(0),
2422 sleeping_pos: SleepingPos(None),
2423 },
2424 no_ai: NoAi(false),
2425 left_handed: LeftHanded(false),
2426 aggressive: Aggressive(false),
2427 },
2428 },
2429 },
2430 swell_dir: SwellDir(-1),
2431 is_powered: IsPowered(false),
2432 is_ignited: IsIgnited(false),
2433 }
2434 }
2435}
2436
2437#[derive(Component)]
2438pub struct DarkOakBoat;
2439impl DarkOakBoat {
2440 pub fn apply_metadata(
2441 entity: &mut bevy_ecs::system::EntityCommands,
2442 d: EntityDataItem,
2443 ) -> Result<(), UpdateMetadataError> {
2444 match d.index {
2445 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
2446 _ => {}
2447 }
2448 Ok(())
2449 }
2450}
2451
2452#[derive(Bundle)]
2453pub struct DarkOakBoatMetadataBundle {
2454 _marker: DarkOakBoat,
2455 parent: AbstractBoatMetadataBundle,
2456}
2457impl Default for DarkOakBoatMetadataBundle {
2458 fn default() -> Self {
2459 Self {
2460 _marker: DarkOakBoat,
2461 parent: AbstractBoatMetadataBundle {
2462 _marker: AbstractBoat,
2463 parent: AbstractVehicleMetadataBundle {
2464 _marker: AbstractVehicle,
2465 parent: AbstractEntityMetadataBundle {
2466 _marker: AbstractEntity,
2467 on_fire: OnFire(false),
2468 shift_key_down: ShiftKeyDown(false),
2469 sprinting: Sprinting(false),
2470 swimming: Swimming(false),
2471 currently_glowing: CurrentlyGlowing(false),
2472 invisible: Invisible(false),
2473 fall_flying: FallFlying(false),
2474 air_supply: AirSupply(Default::default()),
2475 custom_name: CustomName(Default::default()),
2476 custom_name_visible: CustomNameVisible(Default::default()),
2477 silent: Silent(Default::default()),
2478 no_gravity: NoGravity(Default::default()),
2479 pose: Pose::default(),
2480 ticks_frozen: TicksFrozen(Default::default()),
2481 },
2482 hurt: Hurt(0),
2483 hurtdir: Hurtdir(1),
2484 damage: Damage(0.0),
2485 },
2486 paddle_left: PaddleLeft(false),
2487 paddle_right: PaddleRight(false),
2488 bubble_time: BubbleTime(0),
2489 },
2490 }
2491 }
2492}
2493
2494#[derive(Component)]
2495pub struct DarkOakChestBoat;
2496impl DarkOakChestBoat {
2497 pub fn apply_metadata(
2498 entity: &mut bevy_ecs::system::EntityCommands,
2499 d: EntityDataItem,
2500 ) -> Result<(), UpdateMetadataError> {
2501 match d.index {
2502 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
2503 _ => {}
2504 }
2505 Ok(())
2506 }
2507}
2508
2509#[derive(Bundle)]
2510pub struct DarkOakChestBoatMetadataBundle {
2511 _marker: DarkOakChestBoat,
2512 parent: AbstractBoatMetadataBundle,
2513}
2514impl Default for DarkOakChestBoatMetadataBundle {
2515 fn default() -> Self {
2516 Self {
2517 _marker: DarkOakChestBoat,
2518 parent: AbstractBoatMetadataBundle {
2519 _marker: AbstractBoat,
2520 parent: AbstractVehicleMetadataBundle {
2521 _marker: AbstractVehicle,
2522 parent: AbstractEntityMetadataBundle {
2523 _marker: AbstractEntity,
2524 on_fire: OnFire(false),
2525 shift_key_down: ShiftKeyDown(false),
2526 sprinting: Sprinting(false),
2527 swimming: Swimming(false),
2528 currently_glowing: CurrentlyGlowing(false),
2529 invisible: Invisible(false),
2530 fall_flying: FallFlying(false),
2531 air_supply: AirSupply(Default::default()),
2532 custom_name: CustomName(Default::default()),
2533 custom_name_visible: CustomNameVisible(Default::default()),
2534 silent: Silent(Default::default()),
2535 no_gravity: NoGravity(Default::default()),
2536 pose: Pose::default(),
2537 ticks_frozen: TicksFrozen(Default::default()),
2538 },
2539 hurt: Hurt(0),
2540 hurtdir: Hurtdir(1),
2541 damage: Damage(0.0),
2542 },
2543 paddle_left: PaddleLeft(false),
2544 paddle_right: PaddleRight(false),
2545 bubble_time: BubbleTime(0),
2546 },
2547 }
2548 }
2549}
2550
2551#[derive(Component, Deref, DerefMut, Clone)]
2552pub struct GotFish(pub bool);
2553#[derive(Component, Deref, DerefMut, Clone)]
2554pub struct MoistnessLevel(pub i32);
2555#[derive(Component)]
2556pub struct Dolphin;
2557impl Dolphin {
2558 pub fn apply_metadata(
2559 entity: &mut bevy_ecs::system::EntityCommands,
2560 d: EntityDataItem,
2561 ) -> Result<(), UpdateMetadataError> {
2562 match d.index {
2563 0..=16 => AbstractAgeable::apply_metadata(entity, d)?,
2564 17 => {
2565 entity.insert(GotFish(d.value.into_boolean()?));
2566 }
2567 18 => {
2568 entity.insert(MoistnessLevel(d.value.into_int()?));
2569 }
2570 _ => {}
2571 }
2572 Ok(())
2573 }
2574}
2575
2576#[derive(Bundle)]
2577pub struct DolphinMetadataBundle {
2578 _marker: Dolphin,
2579 parent: AbstractAgeableMetadataBundle,
2580 got_fish: GotFish,
2581 moistness_level: MoistnessLevel,
2582}
2583impl Default for DolphinMetadataBundle {
2584 fn default() -> Self {
2585 Self {
2586 _marker: Dolphin,
2587 parent: AbstractAgeableMetadataBundle {
2588 _marker: AbstractAgeable,
2589 parent: AbstractCreatureMetadataBundle {
2590 _marker: AbstractCreature,
2591 parent: AbstractInsentientMetadataBundle {
2592 _marker: AbstractInsentient,
2593 parent: AbstractLivingMetadataBundle {
2594 _marker: AbstractLiving,
2595 parent: AbstractEntityMetadataBundle {
2596 _marker: AbstractEntity,
2597 on_fire: OnFire(false),
2598 shift_key_down: ShiftKeyDown(false),
2599 sprinting: Sprinting(false),
2600 swimming: Swimming(false),
2601 currently_glowing: CurrentlyGlowing(false),
2602 invisible: Invisible(false),
2603 fall_flying: FallFlying(false),
2604 air_supply: AirSupply(Default::default()),
2605 custom_name: CustomName(Default::default()),
2606 custom_name_visible: CustomNameVisible(Default::default()),
2607 silent: Silent(Default::default()),
2608 no_gravity: NoGravity(Default::default()),
2609 pose: Pose::default(),
2610 ticks_frozen: TicksFrozen(Default::default()),
2611 },
2612 auto_spin_attack: AutoSpinAttack(false),
2613 abstract_living_using_item: AbstractLivingUsingItem(false),
2614 health: Health(1.0),
2615 effect_particles: EffectParticles(Default::default()),
2616 effect_ambience: EffectAmbience(false),
2617 arrow_count: ArrowCount(0),
2618 stinger_count: StingerCount(0),
2619 sleeping_pos: SleepingPos(None),
2620 },
2621 no_ai: NoAi(false),
2622 left_handed: LeftHanded(false),
2623 aggressive: Aggressive(false),
2624 },
2625 },
2626 abstract_ageable_baby: AbstractAgeableBaby(false),
2627 },
2628 got_fish: GotFish(false),
2629 moistness_level: MoistnessLevel(2400),
2630 }
2631 }
2632}
2633
2634#[derive(Component, Deref, DerefMut, Clone)]
2635pub struct Chest(pub bool);
2636#[derive(Component)]
2637pub struct Donkey;
2638impl Donkey {
2639 pub fn apply_metadata(
2640 entity: &mut bevy_ecs::system::EntityCommands,
2641 d: EntityDataItem,
2642 ) -> Result<(), UpdateMetadataError> {
2643 match d.index {
2644 0..=18 => AbstractChestedHorse::apply_metadata(entity, d)?,
2645 _ => {}
2646 }
2647 Ok(())
2648 }
2649}
2650
2651#[derive(Bundle)]
2652pub struct DonkeyMetadataBundle {
2653 _marker: Donkey,
2654 parent: AbstractChestedHorseMetadataBundle,
2655}
2656impl Default for DonkeyMetadataBundle {
2657 fn default() -> Self {
2658 Self {
2659 _marker: Donkey,
2660 parent: AbstractChestedHorseMetadataBundle {
2661 _marker: AbstractChestedHorse,
2662 parent: AbstractHorseMetadataBundle {
2663 _marker: AbstractHorse,
2664 parent: AbstractAnimalMetadataBundle {
2665 _marker: AbstractAnimal,
2666 parent: AbstractAgeableMetadataBundle {
2667 _marker: AbstractAgeable,
2668 parent: AbstractCreatureMetadataBundle {
2669 _marker: AbstractCreature,
2670 parent: AbstractInsentientMetadataBundle {
2671 _marker: AbstractInsentient,
2672 parent: AbstractLivingMetadataBundle {
2673 _marker: AbstractLiving,
2674 parent: AbstractEntityMetadataBundle {
2675 _marker: AbstractEntity,
2676 on_fire: OnFire(false),
2677 shift_key_down: ShiftKeyDown(false),
2678 sprinting: Sprinting(false),
2679 swimming: Swimming(false),
2680 currently_glowing: CurrentlyGlowing(false),
2681 invisible: Invisible(false),
2682 fall_flying: FallFlying(false),
2683 air_supply: AirSupply(Default::default()),
2684 custom_name: CustomName(Default::default()),
2685 custom_name_visible: CustomNameVisible(
2686 Default::default(),
2687 ),
2688 silent: Silent(Default::default()),
2689 no_gravity: NoGravity(Default::default()),
2690 pose: Pose::default(),
2691 ticks_frozen: TicksFrozen(Default::default()),
2692 },
2693 auto_spin_attack: AutoSpinAttack(false),
2694 abstract_living_using_item: AbstractLivingUsingItem(false),
2695 health: Health(1.0),
2696 effect_particles: EffectParticles(Default::default()),
2697 effect_ambience: EffectAmbience(false),
2698 arrow_count: ArrowCount(0),
2699 stinger_count: StingerCount(0),
2700 sleeping_pos: SleepingPos(None),
2701 },
2702 no_ai: NoAi(false),
2703 left_handed: LeftHanded(false),
2704 aggressive: Aggressive(false),
2705 },
2706 },
2707 abstract_ageable_baby: AbstractAgeableBaby(false),
2708 },
2709 },
2710 tamed: Tamed(false),
2711 eating: Eating(false),
2712 abstract_horse_standing: AbstractHorseStanding(false),
2713 bred: Bred(false),
2714 },
2715 chest: Chest(false),
2716 },
2717 }
2718 }
2719}
2720
2721#[derive(Component)]
2722pub struct DragonFireball;
2723impl DragonFireball {
2724 pub fn apply_metadata(
2725 entity: &mut bevy_ecs::system::EntityCommands,
2726 d: EntityDataItem,
2727 ) -> Result<(), UpdateMetadataError> {
2728 match d.index {
2729 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
2730 _ => {}
2731 }
2732 Ok(())
2733 }
2734}
2735
2736#[derive(Bundle)]
2737pub struct DragonFireballMetadataBundle {
2738 _marker: DragonFireball,
2739 parent: AbstractEntityMetadataBundle,
2740}
2741impl Default for DragonFireballMetadataBundle {
2742 fn default() -> Self {
2743 Self {
2744 _marker: DragonFireball,
2745 parent: AbstractEntityMetadataBundle {
2746 _marker: AbstractEntity,
2747 on_fire: OnFire(false),
2748 shift_key_down: ShiftKeyDown(false),
2749 sprinting: Sprinting(false),
2750 swimming: Swimming(false),
2751 currently_glowing: CurrentlyGlowing(false),
2752 invisible: Invisible(false),
2753 fall_flying: FallFlying(false),
2754 air_supply: AirSupply(Default::default()),
2755 custom_name: CustomName(Default::default()),
2756 custom_name_visible: CustomNameVisible(Default::default()),
2757 silent: Silent(Default::default()),
2758 no_gravity: NoGravity(Default::default()),
2759 pose: Pose::default(),
2760 ticks_frozen: TicksFrozen(Default::default()),
2761 },
2762 }
2763 }
2764}
2765
2766#[derive(Component, Deref, DerefMut, Clone)]
2767pub struct ZombieBaby(pub bool);
2768#[derive(Component, Deref, DerefMut, Clone)]
2769pub struct SpecialType(pub i32);
2770#[derive(Component, Deref, DerefMut, Clone)]
2771pub struct DrownedConversion(pub bool);
2772#[derive(Component)]
2773pub struct Drowned;
2774impl Drowned {
2775 pub fn apply_metadata(
2776 entity: &mut bevy_ecs::system::EntityCommands,
2777 d: EntityDataItem,
2778 ) -> Result<(), UpdateMetadataError> {
2779 match d.index {
2780 0..=18 => Zombie::apply_metadata(entity, d)?,
2781 _ => {}
2782 }
2783 Ok(())
2784 }
2785}
2786
2787#[derive(Bundle)]
2788pub struct DrownedMetadataBundle {
2789 _marker: Drowned,
2790 parent: ZombieMetadataBundle,
2791}
2792impl Default for DrownedMetadataBundle {
2793 fn default() -> Self {
2794 Self {
2795 _marker: Drowned,
2796 parent: ZombieMetadataBundle {
2797 _marker: Zombie,
2798 parent: AbstractMonsterMetadataBundle {
2799 _marker: AbstractMonster,
2800 parent: AbstractCreatureMetadataBundle {
2801 _marker: AbstractCreature,
2802 parent: AbstractInsentientMetadataBundle {
2803 _marker: AbstractInsentient,
2804 parent: AbstractLivingMetadataBundle {
2805 _marker: AbstractLiving,
2806 parent: AbstractEntityMetadataBundle {
2807 _marker: AbstractEntity,
2808 on_fire: OnFire(false),
2809 shift_key_down: ShiftKeyDown(false),
2810 sprinting: Sprinting(false),
2811 swimming: Swimming(false),
2812 currently_glowing: CurrentlyGlowing(false),
2813 invisible: Invisible(false),
2814 fall_flying: FallFlying(false),
2815 air_supply: AirSupply(Default::default()),
2816 custom_name: CustomName(Default::default()),
2817 custom_name_visible: CustomNameVisible(Default::default()),
2818 silent: Silent(Default::default()),
2819 no_gravity: NoGravity(Default::default()),
2820 pose: Pose::default(),
2821 ticks_frozen: TicksFrozen(Default::default()),
2822 },
2823 auto_spin_attack: AutoSpinAttack(false),
2824 abstract_living_using_item: AbstractLivingUsingItem(false),
2825 health: Health(1.0),
2826 effect_particles: EffectParticles(Default::default()),
2827 effect_ambience: EffectAmbience(false),
2828 arrow_count: ArrowCount(0),
2829 stinger_count: StingerCount(0),
2830 sleeping_pos: SleepingPos(None),
2831 },
2832 no_ai: NoAi(false),
2833 left_handed: LeftHanded(false),
2834 aggressive: Aggressive(false),
2835 },
2836 },
2837 },
2838 zombie_baby: ZombieBaby(false),
2839 special_type: SpecialType(0),
2840 drowned_conversion: DrownedConversion(false),
2841 },
2842 }
2843 }
2844}
2845
2846#[derive(Component, Deref, DerefMut, Clone)]
2847pub struct AbstractThrownItemProjectileItemStack(pub ItemStack);
2848#[derive(Component)]
2849pub struct Egg;
2850impl Egg {
2851 pub fn apply_metadata(
2852 entity: &mut bevy_ecs::system::EntityCommands,
2853 d: EntityDataItem,
2854 ) -> Result<(), UpdateMetadataError> {
2855 match d.index {
2856 0..=8 => AbstractThrownItemProjectile::apply_metadata(entity, d)?,
2857 _ => {}
2858 }
2859 Ok(())
2860 }
2861}
2862
2863#[derive(Bundle)]
2864pub struct EggMetadataBundle {
2865 _marker: Egg,
2866 parent: AbstractThrownItemProjectileMetadataBundle,
2867}
2868impl Default for EggMetadataBundle {
2869 fn default() -> Self {
2870 Self {
2871 _marker: Egg,
2872 parent: AbstractThrownItemProjectileMetadataBundle {
2873 _marker: AbstractThrownItemProjectile,
2874 parent: AbstractEntityMetadataBundle {
2875 _marker: AbstractEntity,
2876 on_fire: OnFire(false),
2877 shift_key_down: ShiftKeyDown(false),
2878 sprinting: Sprinting(false),
2879 swimming: Swimming(false),
2880 currently_glowing: CurrentlyGlowing(false),
2881 invisible: Invisible(false),
2882 fall_flying: FallFlying(false),
2883 air_supply: AirSupply(Default::default()),
2884 custom_name: CustomName(Default::default()),
2885 custom_name_visible: CustomNameVisible(Default::default()),
2886 silent: Silent(Default::default()),
2887 no_gravity: NoGravity(Default::default()),
2888 pose: Pose::default(),
2889 ticks_frozen: TicksFrozen(Default::default()),
2890 },
2891 abstract_thrown_item_projectile_item_stack: AbstractThrownItemProjectileItemStack(
2892 Default::default(),
2893 ),
2894 },
2895 }
2896 }
2897}
2898
2899#[derive(Component, Deref, DerefMut, Clone)]
2900pub struct Moving(pub bool);
2901#[derive(Component, Deref, DerefMut, Clone)]
2902pub struct AttackTarget(pub i32);
2903#[derive(Component)]
2904pub struct ElderGuardian;
2905impl ElderGuardian {
2906 pub fn apply_metadata(
2907 entity: &mut bevy_ecs::system::EntityCommands,
2908 d: EntityDataItem,
2909 ) -> Result<(), UpdateMetadataError> {
2910 match d.index {
2911 0..=17 => Guardian::apply_metadata(entity, d)?,
2912 _ => {}
2913 }
2914 Ok(())
2915 }
2916}
2917
2918#[derive(Bundle)]
2919pub struct ElderGuardianMetadataBundle {
2920 _marker: ElderGuardian,
2921 parent: GuardianMetadataBundle,
2922}
2923impl Default for ElderGuardianMetadataBundle {
2924 fn default() -> Self {
2925 Self {
2926 _marker: ElderGuardian,
2927 parent: GuardianMetadataBundle {
2928 _marker: Guardian,
2929 parent: AbstractMonsterMetadataBundle {
2930 _marker: AbstractMonster,
2931 parent: AbstractCreatureMetadataBundle {
2932 _marker: AbstractCreature,
2933 parent: AbstractInsentientMetadataBundle {
2934 _marker: AbstractInsentient,
2935 parent: AbstractLivingMetadataBundle {
2936 _marker: AbstractLiving,
2937 parent: AbstractEntityMetadataBundle {
2938 _marker: AbstractEntity,
2939 on_fire: OnFire(false),
2940 shift_key_down: ShiftKeyDown(false),
2941 sprinting: Sprinting(false),
2942 swimming: Swimming(false),
2943 currently_glowing: CurrentlyGlowing(false),
2944 invisible: Invisible(false),
2945 fall_flying: FallFlying(false),
2946 air_supply: AirSupply(Default::default()),
2947 custom_name: CustomName(Default::default()),
2948 custom_name_visible: CustomNameVisible(Default::default()),
2949 silent: Silent(Default::default()),
2950 no_gravity: NoGravity(Default::default()),
2951 pose: Pose::default(),
2952 ticks_frozen: TicksFrozen(Default::default()),
2953 },
2954 auto_spin_attack: AutoSpinAttack(false),
2955 abstract_living_using_item: AbstractLivingUsingItem(false),
2956 health: Health(1.0),
2957 effect_particles: EffectParticles(Default::default()),
2958 effect_ambience: EffectAmbience(false),
2959 arrow_count: ArrowCount(0),
2960 stinger_count: StingerCount(0),
2961 sleeping_pos: SleepingPos(None),
2962 },
2963 no_ai: NoAi(false),
2964 left_handed: LeftHanded(false),
2965 aggressive: Aggressive(false),
2966 },
2967 },
2968 },
2969 moving: Moving(false),
2970 attack_target: AttackTarget(0),
2971 },
2972 }
2973 }
2974}
2975
2976#[derive(Component, Deref, DerefMut, Clone)]
2977pub struct BeamTarget(pub Option<BlockPos>);
2978#[derive(Component, Deref, DerefMut, Clone)]
2979pub struct ShowBottom(pub bool);
2980#[derive(Component)]
2981pub struct EndCrystal;
2982impl EndCrystal {
2983 pub fn apply_metadata(
2984 entity: &mut bevy_ecs::system::EntityCommands,
2985 d: EntityDataItem,
2986 ) -> Result<(), UpdateMetadataError> {
2987 match d.index {
2988 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
2989 8 => {
2990 entity.insert(BeamTarget(d.value.into_optional_block_pos()?));
2991 }
2992 9 => {
2993 entity.insert(ShowBottom(d.value.into_boolean()?));
2994 }
2995 _ => {}
2996 }
2997 Ok(())
2998 }
2999}
3000
3001#[derive(Bundle)]
3002pub struct EndCrystalMetadataBundle {
3003 _marker: EndCrystal,
3004 parent: AbstractEntityMetadataBundle,
3005 beam_target: BeamTarget,
3006 show_bottom: ShowBottom,
3007}
3008impl Default for EndCrystalMetadataBundle {
3009 fn default() -> Self {
3010 Self {
3011 _marker: EndCrystal,
3012 parent: AbstractEntityMetadataBundle {
3013 _marker: AbstractEntity,
3014 on_fire: OnFire(false),
3015 shift_key_down: ShiftKeyDown(false),
3016 sprinting: Sprinting(false),
3017 swimming: Swimming(false),
3018 currently_glowing: CurrentlyGlowing(false),
3019 invisible: Invisible(false),
3020 fall_flying: FallFlying(false),
3021 air_supply: AirSupply(Default::default()),
3022 custom_name: CustomName(Default::default()),
3023 custom_name_visible: CustomNameVisible(Default::default()),
3024 silent: Silent(Default::default()),
3025 no_gravity: NoGravity(Default::default()),
3026 pose: Pose::default(),
3027 ticks_frozen: TicksFrozen(Default::default()),
3028 },
3029 beam_target: BeamTarget(None),
3030 show_bottom: ShowBottom(true),
3031 }
3032 }
3033}
3034
3035#[derive(Component, Deref, DerefMut, Clone)]
3036pub struct Phase(pub i32);
3037#[derive(Component)]
3038pub struct EnderDragon;
3039impl EnderDragon {
3040 pub fn apply_metadata(
3041 entity: &mut bevy_ecs::system::EntityCommands,
3042 d: EntityDataItem,
3043 ) -> Result<(), UpdateMetadataError> {
3044 match d.index {
3045 0..=15 => AbstractInsentient::apply_metadata(entity, d)?,
3046 16 => {
3047 entity.insert(Phase(d.value.into_int()?));
3048 }
3049 _ => {}
3050 }
3051 Ok(())
3052 }
3053}
3054
3055#[derive(Bundle)]
3056pub struct EnderDragonMetadataBundle {
3057 _marker: EnderDragon,
3058 parent: AbstractInsentientMetadataBundle,
3059 phase: Phase,
3060}
3061impl Default for EnderDragonMetadataBundle {
3062 fn default() -> Self {
3063 Self {
3064 _marker: EnderDragon,
3065 parent: AbstractInsentientMetadataBundle {
3066 _marker: AbstractInsentient,
3067 parent: AbstractLivingMetadataBundle {
3068 _marker: AbstractLiving,
3069 parent: AbstractEntityMetadataBundle {
3070 _marker: AbstractEntity,
3071 on_fire: OnFire(false),
3072 shift_key_down: ShiftKeyDown(false),
3073 sprinting: Sprinting(false),
3074 swimming: Swimming(false),
3075 currently_glowing: CurrentlyGlowing(false),
3076 invisible: Invisible(false),
3077 fall_flying: FallFlying(false),
3078 air_supply: AirSupply(Default::default()),
3079 custom_name: CustomName(Default::default()),
3080 custom_name_visible: CustomNameVisible(Default::default()),
3081 silent: Silent(Default::default()),
3082 no_gravity: NoGravity(Default::default()),
3083 pose: Pose::default(),
3084 ticks_frozen: TicksFrozen(Default::default()),
3085 },
3086 auto_spin_attack: AutoSpinAttack(false),
3087 abstract_living_using_item: AbstractLivingUsingItem(false),
3088 health: Health(1.0),
3089 effect_particles: EffectParticles(Default::default()),
3090 effect_ambience: EffectAmbience(false),
3091 arrow_count: ArrowCount(0),
3092 stinger_count: StingerCount(0),
3093 sleeping_pos: SleepingPos(None),
3094 },
3095 no_ai: NoAi(false),
3096 left_handed: LeftHanded(false),
3097 aggressive: Aggressive(false),
3098 },
3099 phase: Phase(Default::default()),
3100 }
3101 }
3102}
3103
3104#[derive(Component)]
3105pub struct EnderPearl;
3106impl EnderPearl {
3107 pub fn apply_metadata(
3108 entity: &mut bevy_ecs::system::EntityCommands,
3109 d: EntityDataItem,
3110 ) -> Result<(), UpdateMetadataError> {
3111 match d.index {
3112 0..=8 => AbstractThrownItemProjectile::apply_metadata(entity, d)?,
3113 _ => {}
3114 }
3115 Ok(())
3116 }
3117}
3118
3119#[derive(Bundle)]
3120pub struct EnderPearlMetadataBundle {
3121 _marker: EnderPearl,
3122 parent: AbstractThrownItemProjectileMetadataBundle,
3123}
3124impl Default for EnderPearlMetadataBundle {
3125 fn default() -> Self {
3126 Self {
3127 _marker: EnderPearl,
3128 parent: AbstractThrownItemProjectileMetadataBundle {
3129 _marker: AbstractThrownItemProjectile,
3130 parent: AbstractEntityMetadataBundle {
3131 _marker: AbstractEntity,
3132 on_fire: OnFire(false),
3133 shift_key_down: ShiftKeyDown(false),
3134 sprinting: Sprinting(false),
3135 swimming: Swimming(false),
3136 currently_glowing: CurrentlyGlowing(false),
3137 invisible: Invisible(false),
3138 fall_flying: FallFlying(false),
3139 air_supply: AirSupply(Default::default()),
3140 custom_name: CustomName(Default::default()),
3141 custom_name_visible: CustomNameVisible(Default::default()),
3142 silent: Silent(Default::default()),
3143 no_gravity: NoGravity(Default::default()),
3144 pose: Pose::default(),
3145 ticks_frozen: TicksFrozen(Default::default()),
3146 },
3147 abstract_thrown_item_projectile_item_stack: AbstractThrownItemProjectileItemStack(
3148 Default::default(),
3149 ),
3150 },
3151 }
3152 }
3153}
3154
3155#[derive(Component, Deref, DerefMut, Clone)]
3156pub struct CarryState(pub azalea_block::BlockState);
3157#[derive(Component, Deref, DerefMut, Clone)]
3158pub struct Creepy(pub bool);
3159#[derive(Component, Deref, DerefMut, Clone)]
3160pub struct StaredAt(pub bool);
3161#[derive(Component)]
3162pub struct Enderman;
3163impl Enderman {
3164 pub fn apply_metadata(
3165 entity: &mut bevy_ecs::system::EntityCommands,
3166 d: EntityDataItem,
3167 ) -> Result<(), UpdateMetadataError> {
3168 match d.index {
3169 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
3170 16 => {
3171 entity.insert(CarryState(d.value.into_optional_block_state()?));
3172 }
3173 17 => {
3174 entity.insert(Creepy(d.value.into_boolean()?));
3175 }
3176 18 => {
3177 entity.insert(StaredAt(d.value.into_boolean()?));
3178 }
3179 _ => {}
3180 }
3181 Ok(())
3182 }
3183}
3184
3185#[derive(Bundle)]
3186pub struct EndermanMetadataBundle {
3187 _marker: Enderman,
3188 parent: AbstractMonsterMetadataBundle,
3189 carry_state: CarryState,
3190 creepy: Creepy,
3191 stared_at: StaredAt,
3192}
3193impl Default for EndermanMetadataBundle {
3194 fn default() -> Self {
3195 Self {
3196 _marker: Enderman,
3197 parent: AbstractMonsterMetadataBundle {
3198 _marker: AbstractMonster,
3199 parent: AbstractCreatureMetadataBundle {
3200 _marker: AbstractCreature,
3201 parent: AbstractInsentientMetadataBundle {
3202 _marker: AbstractInsentient,
3203 parent: AbstractLivingMetadataBundle {
3204 _marker: AbstractLiving,
3205 parent: AbstractEntityMetadataBundle {
3206 _marker: AbstractEntity,
3207 on_fire: OnFire(false),
3208 shift_key_down: ShiftKeyDown(false),
3209 sprinting: Sprinting(false),
3210 swimming: Swimming(false),
3211 currently_glowing: CurrentlyGlowing(false),
3212 invisible: Invisible(false),
3213 fall_flying: FallFlying(false),
3214 air_supply: AirSupply(Default::default()),
3215 custom_name: CustomName(Default::default()),
3216 custom_name_visible: CustomNameVisible(Default::default()),
3217 silent: Silent(Default::default()),
3218 no_gravity: NoGravity(Default::default()),
3219 pose: Pose::default(),
3220 ticks_frozen: TicksFrozen(Default::default()),
3221 },
3222 auto_spin_attack: AutoSpinAttack(false),
3223 abstract_living_using_item: AbstractLivingUsingItem(false),
3224 health: Health(1.0),
3225 effect_particles: EffectParticles(Default::default()),
3226 effect_ambience: EffectAmbience(false),
3227 arrow_count: ArrowCount(0),
3228 stinger_count: StingerCount(0),
3229 sleeping_pos: SleepingPos(None),
3230 },
3231 no_ai: NoAi(false),
3232 left_handed: LeftHanded(false),
3233 aggressive: Aggressive(false),
3234 },
3235 },
3236 },
3237 carry_state: CarryState(azalea_block::BlockState::AIR),
3238 creepy: Creepy(false),
3239 stared_at: StaredAt(false),
3240 }
3241 }
3242}
3243
3244#[derive(Component)]
3245pub struct Endermite;
3246impl Endermite {
3247 pub fn apply_metadata(
3248 entity: &mut bevy_ecs::system::EntityCommands,
3249 d: EntityDataItem,
3250 ) -> Result<(), UpdateMetadataError> {
3251 match d.index {
3252 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
3253 _ => {}
3254 }
3255 Ok(())
3256 }
3257}
3258
3259#[derive(Bundle)]
3260pub struct EndermiteMetadataBundle {
3261 _marker: Endermite,
3262 parent: AbstractMonsterMetadataBundle,
3263}
3264impl Default for EndermiteMetadataBundle {
3265 fn default() -> Self {
3266 Self {
3267 _marker: Endermite,
3268 parent: AbstractMonsterMetadataBundle {
3269 _marker: AbstractMonster,
3270 parent: AbstractCreatureMetadataBundle {
3271 _marker: AbstractCreature,
3272 parent: AbstractInsentientMetadataBundle {
3273 _marker: AbstractInsentient,
3274 parent: AbstractLivingMetadataBundle {
3275 _marker: AbstractLiving,
3276 parent: AbstractEntityMetadataBundle {
3277 _marker: AbstractEntity,
3278 on_fire: OnFire(false),
3279 shift_key_down: ShiftKeyDown(false),
3280 sprinting: Sprinting(false),
3281 swimming: Swimming(false),
3282 currently_glowing: CurrentlyGlowing(false),
3283 invisible: Invisible(false),
3284 fall_flying: FallFlying(false),
3285 air_supply: AirSupply(Default::default()),
3286 custom_name: CustomName(Default::default()),
3287 custom_name_visible: CustomNameVisible(Default::default()),
3288 silent: Silent(Default::default()),
3289 no_gravity: NoGravity(Default::default()),
3290 pose: Pose::default(),
3291 ticks_frozen: TicksFrozen(Default::default()),
3292 },
3293 auto_spin_attack: AutoSpinAttack(false),
3294 abstract_living_using_item: AbstractLivingUsingItem(false),
3295 health: Health(1.0),
3296 effect_particles: EffectParticles(Default::default()),
3297 effect_ambience: EffectAmbience(false),
3298 arrow_count: ArrowCount(0),
3299 stinger_count: StingerCount(0),
3300 sleeping_pos: SleepingPos(None),
3301 },
3302 no_ai: NoAi(false),
3303 left_handed: LeftHanded(false),
3304 aggressive: Aggressive(false),
3305 },
3306 },
3307 },
3308 }
3309 }
3310}
3311
3312#[derive(Component, Deref, DerefMut, Clone)]
3313pub struct IsCelebrating(pub bool);
3314#[derive(Component, Deref, DerefMut, Clone)]
3315pub struct SpellCasting(pub u8);
3316#[derive(Component)]
3317pub struct Evoker;
3318impl Evoker {
3319 pub fn apply_metadata(
3320 entity: &mut bevy_ecs::system::EntityCommands,
3321 d: EntityDataItem,
3322 ) -> Result<(), UpdateMetadataError> {
3323 match d.index {
3324 0..=17 => AbstractSpellcasterIllager::apply_metadata(entity, d)?,
3325 _ => {}
3326 }
3327 Ok(())
3328 }
3329}
3330
3331#[derive(Bundle)]
3332pub struct EvokerMetadataBundle {
3333 _marker: Evoker,
3334 parent: AbstractSpellcasterIllagerMetadataBundle,
3335}
3336impl Default for EvokerMetadataBundle {
3337 fn default() -> Self {
3338 Self {
3339 _marker: Evoker,
3340 parent: AbstractSpellcasterIllagerMetadataBundle {
3341 _marker: AbstractSpellcasterIllager,
3342 parent: AbstractRaiderMetadataBundle {
3343 _marker: AbstractRaider,
3344 parent: AbstractMonsterMetadataBundle {
3345 _marker: AbstractMonster,
3346 parent: AbstractCreatureMetadataBundle {
3347 _marker: AbstractCreature,
3348 parent: AbstractInsentientMetadataBundle {
3349 _marker: AbstractInsentient,
3350 parent: AbstractLivingMetadataBundle {
3351 _marker: AbstractLiving,
3352 parent: AbstractEntityMetadataBundle {
3353 _marker: AbstractEntity,
3354 on_fire: OnFire(false),
3355 shift_key_down: ShiftKeyDown(false),
3356 sprinting: Sprinting(false),
3357 swimming: Swimming(false),
3358 currently_glowing: CurrentlyGlowing(false),
3359 invisible: Invisible(false),
3360 fall_flying: FallFlying(false),
3361 air_supply: AirSupply(Default::default()),
3362 custom_name: CustomName(Default::default()),
3363 custom_name_visible: CustomNameVisible(Default::default()),
3364 silent: Silent(Default::default()),
3365 no_gravity: NoGravity(Default::default()),
3366 pose: Pose::default(),
3367 ticks_frozen: TicksFrozen(Default::default()),
3368 },
3369 auto_spin_attack: AutoSpinAttack(false),
3370 abstract_living_using_item: AbstractLivingUsingItem(false),
3371 health: Health(1.0),
3372 effect_particles: EffectParticles(Default::default()),
3373 effect_ambience: EffectAmbience(false),
3374 arrow_count: ArrowCount(0),
3375 stinger_count: StingerCount(0),
3376 sleeping_pos: SleepingPos(None),
3377 },
3378 no_ai: NoAi(false),
3379 left_handed: LeftHanded(false),
3380 aggressive: Aggressive(false),
3381 },
3382 },
3383 },
3384 is_celebrating: IsCelebrating(false),
3385 },
3386 spell_casting: SpellCasting(0),
3387 },
3388 }
3389 }
3390}
3391
3392#[derive(Component)]
3393pub struct EvokerFangs;
3394impl EvokerFangs {
3395 pub fn apply_metadata(
3396 entity: &mut bevy_ecs::system::EntityCommands,
3397 d: EntityDataItem,
3398 ) -> Result<(), UpdateMetadataError> {
3399 match d.index {
3400 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
3401 _ => {}
3402 }
3403 Ok(())
3404 }
3405}
3406
3407#[derive(Bundle)]
3408pub struct EvokerFangsMetadataBundle {
3409 _marker: EvokerFangs,
3410 parent: AbstractEntityMetadataBundle,
3411}
3412impl Default for EvokerFangsMetadataBundle {
3413 fn default() -> Self {
3414 Self {
3415 _marker: EvokerFangs,
3416 parent: AbstractEntityMetadataBundle {
3417 _marker: AbstractEntity,
3418 on_fire: OnFire(false),
3419 shift_key_down: ShiftKeyDown(false),
3420 sprinting: Sprinting(false),
3421 swimming: Swimming(false),
3422 currently_glowing: CurrentlyGlowing(false),
3423 invisible: Invisible(false),
3424 fall_flying: FallFlying(false),
3425 air_supply: AirSupply(Default::default()),
3426 custom_name: CustomName(Default::default()),
3427 custom_name_visible: CustomNameVisible(Default::default()),
3428 silent: Silent(Default::default()),
3429 no_gravity: NoGravity(Default::default()),
3430 pose: Pose::default(),
3431 ticks_frozen: TicksFrozen(Default::default()),
3432 },
3433 }
3434 }
3435}
3436
3437#[derive(Component)]
3438pub struct ExperienceBottle;
3439impl ExperienceBottle {
3440 pub fn apply_metadata(
3441 entity: &mut bevy_ecs::system::EntityCommands,
3442 d: EntityDataItem,
3443 ) -> Result<(), UpdateMetadataError> {
3444 match d.index {
3445 0..=8 => AbstractThrownItemProjectile::apply_metadata(entity, d)?,
3446 _ => {}
3447 }
3448 Ok(())
3449 }
3450}
3451
3452#[derive(Bundle)]
3453pub struct ExperienceBottleMetadataBundle {
3454 _marker: ExperienceBottle,
3455 parent: AbstractThrownItemProjectileMetadataBundle,
3456}
3457impl Default for ExperienceBottleMetadataBundle {
3458 fn default() -> Self {
3459 Self {
3460 _marker: ExperienceBottle,
3461 parent: AbstractThrownItemProjectileMetadataBundle {
3462 _marker: AbstractThrownItemProjectile,
3463 parent: AbstractEntityMetadataBundle {
3464 _marker: AbstractEntity,
3465 on_fire: OnFire(false),
3466 shift_key_down: ShiftKeyDown(false),
3467 sprinting: Sprinting(false),
3468 swimming: Swimming(false),
3469 currently_glowing: CurrentlyGlowing(false),
3470 invisible: Invisible(false),
3471 fall_flying: FallFlying(false),
3472 air_supply: AirSupply(Default::default()),
3473 custom_name: CustomName(Default::default()),
3474 custom_name_visible: CustomNameVisible(Default::default()),
3475 silent: Silent(Default::default()),
3476 no_gravity: NoGravity(Default::default()),
3477 pose: Pose::default(),
3478 ticks_frozen: TicksFrozen(Default::default()),
3479 },
3480 abstract_thrown_item_projectile_item_stack: AbstractThrownItemProjectileItemStack(
3481 Default::default(),
3482 ),
3483 },
3484 }
3485 }
3486}
3487
3488#[derive(Component, Deref, DerefMut, Clone)]
3489pub struct Value(pub i32);
3490#[derive(Component)]
3491pub struct ExperienceOrb;
3492impl ExperienceOrb {
3493 pub fn apply_metadata(
3494 entity: &mut bevy_ecs::system::EntityCommands,
3495 d: EntityDataItem,
3496 ) -> Result<(), UpdateMetadataError> {
3497 match d.index {
3498 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
3499 8 => {
3500 entity.insert(Value(d.value.into_int()?));
3501 }
3502 _ => {}
3503 }
3504 Ok(())
3505 }
3506}
3507
3508#[derive(Bundle)]
3509pub struct ExperienceOrbMetadataBundle {
3510 _marker: ExperienceOrb,
3511 parent: AbstractEntityMetadataBundle,
3512 value: Value,
3513}
3514impl Default for ExperienceOrbMetadataBundle {
3515 fn default() -> Self {
3516 Self {
3517 _marker: ExperienceOrb,
3518 parent: AbstractEntityMetadataBundle {
3519 _marker: AbstractEntity,
3520 on_fire: OnFire(false),
3521 shift_key_down: ShiftKeyDown(false),
3522 sprinting: Sprinting(false),
3523 swimming: Swimming(false),
3524 currently_glowing: CurrentlyGlowing(false),
3525 invisible: Invisible(false),
3526 fall_flying: FallFlying(false),
3527 air_supply: AirSupply(Default::default()),
3528 custom_name: CustomName(Default::default()),
3529 custom_name_visible: CustomNameVisible(Default::default()),
3530 silent: Silent(Default::default()),
3531 no_gravity: NoGravity(Default::default()),
3532 pose: Pose::default(),
3533 ticks_frozen: TicksFrozen(Default::default()),
3534 },
3535 value: Value(0),
3536 }
3537 }
3538}
3539
3540#[derive(Component, Deref, DerefMut, Clone)]
3541pub struct EyeOfEnderItemStack(pub ItemStack);
3542#[derive(Component)]
3543pub struct EyeOfEnder;
3544impl EyeOfEnder {
3545 pub fn apply_metadata(
3546 entity: &mut bevy_ecs::system::EntityCommands,
3547 d: EntityDataItem,
3548 ) -> Result<(), UpdateMetadataError> {
3549 match d.index {
3550 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
3551 8 => {
3552 entity.insert(EyeOfEnderItemStack(d.value.into_item_stack()?));
3553 }
3554 _ => {}
3555 }
3556 Ok(())
3557 }
3558}
3559
3560#[derive(Bundle)]
3561pub struct EyeOfEnderMetadataBundle {
3562 _marker: EyeOfEnder,
3563 parent: AbstractEntityMetadataBundle,
3564 eye_of_ender_item_stack: EyeOfEnderItemStack,
3565}
3566impl Default for EyeOfEnderMetadataBundle {
3567 fn default() -> Self {
3568 Self {
3569 _marker: EyeOfEnder,
3570 parent: AbstractEntityMetadataBundle {
3571 _marker: AbstractEntity,
3572 on_fire: OnFire(false),
3573 shift_key_down: ShiftKeyDown(false),
3574 sprinting: Sprinting(false),
3575 swimming: Swimming(false),
3576 currently_glowing: CurrentlyGlowing(false),
3577 invisible: Invisible(false),
3578 fall_flying: FallFlying(false),
3579 air_supply: AirSupply(Default::default()),
3580 custom_name: CustomName(Default::default()),
3581 custom_name_visible: CustomNameVisible(Default::default()),
3582 silent: Silent(Default::default()),
3583 no_gravity: NoGravity(Default::default()),
3584 pose: Pose::default(),
3585 ticks_frozen: TicksFrozen(Default::default()),
3586 },
3587 eye_of_ender_item_stack: EyeOfEnderItemStack(Default::default()),
3588 }
3589 }
3590}
3591
3592#[derive(Component, Deref, DerefMut, Clone)]
3593pub struct StartPos(pub BlockPos);
3594#[derive(Component)]
3595pub struct FallingBlock;
3596impl FallingBlock {
3597 pub fn apply_metadata(
3598 entity: &mut bevy_ecs::system::EntityCommands,
3599 d: EntityDataItem,
3600 ) -> Result<(), UpdateMetadataError> {
3601 match d.index {
3602 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
3603 8 => {
3604 entity.insert(StartPos(d.value.into_block_pos()?));
3605 }
3606 _ => {}
3607 }
3608 Ok(())
3609 }
3610}
3611
3612#[derive(Bundle)]
3613pub struct FallingBlockMetadataBundle {
3614 _marker: FallingBlock,
3615 parent: AbstractEntityMetadataBundle,
3616 start_pos: StartPos,
3617}
3618impl Default for FallingBlockMetadataBundle {
3619 fn default() -> Self {
3620 Self {
3621 _marker: FallingBlock,
3622 parent: AbstractEntityMetadataBundle {
3623 _marker: AbstractEntity,
3624 on_fire: OnFire(false),
3625 shift_key_down: ShiftKeyDown(false),
3626 sprinting: Sprinting(false),
3627 swimming: Swimming(false),
3628 currently_glowing: CurrentlyGlowing(false),
3629 invisible: Invisible(false),
3630 fall_flying: FallFlying(false),
3631 air_supply: AirSupply(Default::default()),
3632 custom_name: CustomName(Default::default()),
3633 custom_name_visible: CustomNameVisible(Default::default()),
3634 silent: Silent(Default::default()),
3635 no_gravity: NoGravity(Default::default()),
3636 pose: Pose::default(),
3637 ticks_frozen: TicksFrozen(Default::default()),
3638 },
3639 start_pos: StartPos(BlockPos::new(0, 0, 0)),
3640 }
3641 }
3642}
3643
3644#[derive(Component, Deref, DerefMut, Clone)]
3645pub struct FireballItemStack(pub ItemStack);
3646#[derive(Component)]
3647pub struct Fireball;
3648impl Fireball {
3649 pub fn apply_metadata(
3650 entity: &mut bevy_ecs::system::EntityCommands,
3651 d: EntityDataItem,
3652 ) -> Result<(), UpdateMetadataError> {
3653 match d.index {
3654 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
3655 8 => {
3656 entity.insert(FireballItemStack(d.value.into_item_stack()?));
3657 }
3658 _ => {}
3659 }
3660 Ok(())
3661 }
3662}
3663
3664#[derive(Bundle)]
3665pub struct FireballMetadataBundle {
3666 _marker: Fireball,
3667 parent: AbstractEntityMetadataBundle,
3668 fireball_item_stack: FireballItemStack,
3669}
3670impl Default for FireballMetadataBundle {
3671 fn default() -> Self {
3672 Self {
3673 _marker: Fireball,
3674 parent: AbstractEntityMetadataBundle {
3675 _marker: AbstractEntity,
3676 on_fire: OnFire(false),
3677 shift_key_down: ShiftKeyDown(false),
3678 sprinting: Sprinting(false),
3679 swimming: Swimming(false),
3680 currently_glowing: CurrentlyGlowing(false),
3681 invisible: Invisible(false),
3682 fall_flying: FallFlying(false),
3683 air_supply: AirSupply(Default::default()),
3684 custom_name: CustomName(Default::default()),
3685 custom_name_visible: CustomNameVisible(Default::default()),
3686 silent: Silent(Default::default()),
3687 no_gravity: NoGravity(Default::default()),
3688 pose: Pose::default(),
3689 ticks_frozen: TicksFrozen(Default::default()),
3690 },
3691 fireball_item_stack: FireballItemStack(Default::default()),
3692 }
3693 }
3694}
3695
3696#[derive(Component, Deref, DerefMut, Clone)]
3697pub struct FireworksItem(pub ItemStack);
3698#[derive(Component, Deref, DerefMut, Clone)]
3699pub struct AttachedToTarget(pub OptionalUnsignedInt);
3700#[derive(Component, Deref, DerefMut, Clone)]
3701pub struct ShotAtAngle(pub bool);
3702#[derive(Component)]
3703pub struct FireworkRocket;
3704impl FireworkRocket {
3705 pub fn apply_metadata(
3706 entity: &mut bevy_ecs::system::EntityCommands,
3707 d: EntityDataItem,
3708 ) -> Result<(), UpdateMetadataError> {
3709 match d.index {
3710 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
3711 8 => {
3712 entity.insert(FireworksItem(d.value.into_item_stack()?));
3713 }
3714 9 => {
3715 entity.insert(AttachedToTarget(d.value.into_optional_unsigned_int()?));
3716 }
3717 10 => {
3718 entity.insert(ShotAtAngle(d.value.into_boolean()?));
3719 }
3720 _ => {}
3721 }
3722 Ok(())
3723 }
3724}
3725
3726#[derive(Bundle)]
3727pub struct FireworkRocketMetadataBundle {
3728 _marker: FireworkRocket,
3729 parent: AbstractEntityMetadataBundle,
3730 fireworks_item: FireworksItem,
3731 attached_to_target: AttachedToTarget,
3732 shot_at_angle: ShotAtAngle,
3733}
3734impl Default for FireworkRocketMetadataBundle {
3735 fn default() -> Self {
3736 Self {
3737 _marker: FireworkRocket,
3738 parent: AbstractEntityMetadataBundle {
3739 _marker: AbstractEntity,
3740 on_fire: OnFire(false),
3741 shift_key_down: ShiftKeyDown(false),
3742 sprinting: Sprinting(false),
3743 swimming: Swimming(false),
3744 currently_glowing: CurrentlyGlowing(false),
3745 invisible: Invisible(false),
3746 fall_flying: FallFlying(false),
3747 air_supply: AirSupply(Default::default()),
3748 custom_name: CustomName(Default::default()),
3749 custom_name_visible: CustomNameVisible(Default::default()),
3750 silent: Silent(Default::default()),
3751 no_gravity: NoGravity(Default::default()),
3752 pose: Pose::default(),
3753 ticks_frozen: TicksFrozen(Default::default()),
3754 },
3755 fireworks_item: FireworksItem(Default::default()),
3756 attached_to_target: AttachedToTarget(OptionalUnsignedInt(None)),
3757 shot_at_angle: ShotAtAngle(false),
3758 }
3759 }
3760}
3761
3762#[derive(Component, Deref, DerefMut, Clone)]
3763pub struct HookedEntity(pub i32);
3764#[derive(Component, Deref, DerefMut, Clone)]
3765pub struct Biting(pub bool);
3766#[derive(Component)]
3767pub struct FishingBobber;
3768impl FishingBobber {
3769 pub fn apply_metadata(
3770 entity: &mut bevy_ecs::system::EntityCommands,
3771 d: EntityDataItem,
3772 ) -> Result<(), UpdateMetadataError> {
3773 match d.index {
3774 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
3775 8 => {
3776 entity.insert(HookedEntity(d.value.into_int()?));
3777 }
3778 9 => {
3779 entity.insert(Biting(d.value.into_boolean()?));
3780 }
3781 _ => {}
3782 }
3783 Ok(())
3784 }
3785}
3786
3787#[derive(Bundle)]
3788pub struct FishingBobberMetadataBundle {
3789 _marker: FishingBobber,
3790 parent: AbstractEntityMetadataBundle,
3791 hooked_entity: HookedEntity,
3792 biting: Biting,
3793}
3794impl Default for FishingBobberMetadataBundle {
3795 fn default() -> Self {
3796 Self {
3797 _marker: FishingBobber,
3798 parent: AbstractEntityMetadataBundle {
3799 _marker: AbstractEntity,
3800 on_fire: OnFire(false),
3801 shift_key_down: ShiftKeyDown(false),
3802 sprinting: Sprinting(false),
3803 swimming: Swimming(false),
3804 currently_glowing: CurrentlyGlowing(false),
3805 invisible: Invisible(false),
3806 fall_flying: FallFlying(false),
3807 air_supply: AirSupply(Default::default()),
3808 custom_name: CustomName(Default::default()),
3809 custom_name_visible: CustomNameVisible(Default::default()),
3810 silent: Silent(Default::default()),
3811 no_gravity: NoGravity(Default::default()),
3812 pose: Pose::default(),
3813 ticks_frozen: TicksFrozen(Default::default()),
3814 },
3815 hooked_entity: HookedEntity(0),
3816 biting: Biting(false),
3817 }
3818 }
3819}
3820
3821#[derive(Component, Deref, DerefMut, Clone)]
3822pub struct FoxKind(pub i32);
3823#[derive(Component, Deref, DerefMut, Clone, Copy)]
3824pub struct FoxSitting(pub bool);
3825#[derive(Component, Deref, DerefMut, Clone, Copy)]
3826pub struct Faceplanted(pub bool);
3827#[derive(Component, Deref, DerefMut, Clone, Copy)]
3828pub struct Defending(pub bool);
3829#[derive(Component, Deref, DerefMut, Clone, Copy)]
3830pub struct Sleeping(pub bool);
3831#[derive(Component, Deref, DerefMut, Clone, Copy)]
3832pub struct Pouncing(pub bool);
3833#[derive(Component, Deref, DerefMut, Clone, Copy)]
3834pub struct Crouching(pub bool);
3835#[derive(Component, Deref, DerefMut, Clone, Copy)]
3836pub struct FoxInterested(pub bool);
3837#[derive(Component, Deref, DerefMut, Clone)]
3838pub struct TrustedId0(pub Option<Uuid>);
3839#[derive(Component, Deref, DerefMut, Clone)]
3840pub struct TrustedId1(pub Option<Uuid>);
3841#[derive(Component)]
3842pub struct Fox;
3843impl Fox {
3844 pub fn apply_metadata(
3845 entity: &mut bevy_ecs::system::EntityCommands,
3846 d: EntityDataItem,
3847 ) -> Result<(), UpdateMetadataError> {
3848 match d.index {
3849 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
3850 17 => {
3851 entity.insert(FoxKind(d.value.into_int()?));
3852 }
3853 18 => {
3854 let bitfield = d.value.into_byte()?;
3855 entity.insert(FoxSitting(bitfield & 0x1 != 0));
3856 entity.insert(Faceplanted(bitfield & 0x40 != 0));
3857 entity.insert(Defending(bitfield & 0x80 != 0));
3858 entity.insert(Sleeping(bitfield & 0x20 != 0));
3859 entity.insert(Pouncing(bitfield & 0x10 != 0));
3860 entity.insert(Crouching(bitfield & 0x4 != 0));
3861 entity.insert(FoxInterested(bitfield & 0x8 != 0));
3862 }
3863 19 => {
3864 entity.insert(TrustedId0(d.value.into_optional_living_entity_reference()?));
3865 }
3866 20 => {
3867 entity.insert(TrustedId1(d.value.into_optional_living_entity_reference()?));
3868 }
3869 _ => {}
3870 }
3871 Ok(())
3872 }
3873}
3874
3875#[derive(Bundle)]
3876pub struct FoxMetadataBundle {
3877 _marker: Fox,
3878 parent: AbstractAnimalMetadataBundle,
3879 fox_kind: FoxKind,
3880 fox_sitting: FoxSitting,
3881 faceplanted: Faceplanted,
3882 defending: Defending,
3883 sleeping: Sleeping,
3884 pouncing: Pouncing,
3885 crouching: Crouching,
3886 fox_interested: FoxInterested,
3887 trusted_id_0: TrustedId0,
3888 trusted_id_1: TrustedId1,
3889}
3890impl Default for FoxMetadataBundle {
3891 fn default() -> Self {
3892 Self {
3893 _marker: Fox,
3894 parent: AbstractAnimalMetadataBundle {
3895 _marker: AbstractAnimal,
3896 parent: AbstractAgeableMetadataBundle {
3897 _marker: AbstractAgeable,
3898 parent: AbstractCreatureMetadataBundle {
3899 _marker: AbstractCreature,
3900 parent: AbstractInsentientMetadataBundle {
3901 _marker: AbstractInsentient,
3902 parent: AbstractLivingMetadataBundle {
3903 _marker: AbstractLiving,
3904 parent: AbstractEntityMetadataBundle {
3905 _marker: AbstractEntity,
3906 on_fire: OnFire(false),
3907 shift_key_down: ShiftKeyDown(false),
3908 sprinting: Sprinting(false),
3909 swimming: Swimming(false),
3910 currently_glowing: CurrentlyGlowing(false),
3911 invisible: Invisible(false),
3912 fall_flying: FallFlying(false),
3913 air_supply: AirSupply(Default::default()),
3914 custom_name: CustomName(Default::default()),
3915 custom_name_visible: CustomNameVisible(Default::default()),
3916 silent: Silent(Default::default()),
3917 no_gravity: NoGravity(Default::default()),
3918 pose: Pose::default(),
3919 ticks_frozen: TicksFrozen(Default::default()),
3920 },
3921 auto_spin_attack: AutoSpinAttack(false),
3922 abstract_living_using_item: AbstractLivingUsingItem(false),
3923 health: Health(1.0),
3924 effect_particles: EffectParticles(Default::default()),
3925 effect_ambience: EffectAmbience(false),
3926 arrow_count: ArrowCount(0),
3927 stinger_count: StingerCount(0),
3928 sleeping_pos: SleepingPos(None),
3929 },
3930 no_ai: NoAi(false),
3931 left_handed: LeftHanded(false),
3932 aggressive: Aggressive(false),
3933 },
3934 },
3935 abstract_ageable_baby: AbstractAgeableBaby(false),
3936 },
3937 },
3938 fox_kind: FoxKind(Default::default()),
3939 fox_sitting: FoxSitting(false),
3940 faceplanted: Faceplanted(false),
3941 defending: Defending(false),
3942 sleeping: Sleeping(false),
3943 pouncing: Pouncing(false),
3944 crouching: Crouching(false),
3945 fox_interested: FoxInterested(false),
3946 trusted_id_0: TrustedId0(None),
3947 trusted_id_1: TrustedId1(None),
3948 }
3949 }
3950}
3951
3952#[derive(Component, Deref, DerefMut, Clone)]
3953pub struct FrogVariant(pub azalea_registry::WolfSoundVariant);
3954#[derive(Component, Deref, DerefMut, Clone)]
3955pub struct TongueTarget(pub OptionalUnsignedInt);
3956#[derive(Component)]
3957pub struct Frog;
3958impl Frog {
3959 pub fn apply_metadata(
3960 entity: &mut bevy_ecs::system::EntityCommands,
3961 d: EntityDataItem,
3962 ) -> Result<(), UpdateMetadataError> {
3963 match d.index {
3964 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
3965 17 => {
3966 entity.insert(FrogVariant(d.value.into_wolf_sound_variant()?));
3967 }
3968 18 => {
3969 entity.insert(TongueTarget(d.value.into_optional_unsigned_int()?));
3970 }
3971 _ => {}
3972 }
3973 Ok(())
3974 }
3975}
3976
3977#[derive(Bundle)]
3978pub struct FrogMetadataBundle {
3979 _marker: Frog,
3980 parent: AbstractAnimalMetadataBundle,
3981 frog_variant: FrogVariant,
3982 tongue_target: TongueTarget,
3983}
3984impl Default for FrogMetadataBundle {
3985 fn default() -> Self {
3986 Self {
3987 _marker: Frog,
3988 parent: AbstractAnimalMetadataBundle {
3989 _marker: AbstractAnimal,
3990 parent: AbstractAgeableMetadataBundle {
3991 _marker: AbstractAgeable,
3992 parent: AbstractCreatureMetadataBundle {
3993 _marker: AbstractCreature,
3994 parent: AbstractInsentientMetadataBundle {
3995 _marker: AbstractInsentient,
3996 parent: AbstractLivingMetadataBundle {
3997 _marker: AbstractLiving,
3998 parent: AbstractEntityMetadataBundle {
3999 _marker: AbstractEntity,
4000 on_fire: OnFire(false),
4001 shift_key_down: ShiftKeyDown(false),
4002 sprinting: Sprinting(false),
4003 swimming: Swimming(false),
4004 currently_glowing: CurrentlyGlowing(false),
4005 invisible: Invisible(false),
4006 fall_flying: FallFlying(false),
4007 air_supply: AirSupply(Default::default()),
4008 custom_name: CustomName(Default::default()),
4009 custom_name_visible: CustomNameVisible(Default::default()),
4010 silent: Silent(Default::default()),
4011 no_gravity: NoGravity(Default::default()),
4012 pose: Pose::default(),
4013 ticks_frozen: TicksFrozen(Default::default()),
4014 },
4015 auto_spin_attack: AutoSpinAttack(false),
4016 abstract_living_using_item: AbstractLivingUsingItem(false),
4017 health: Health(1.0),
4018 effect_particles: EffectParticles(Default::default()),
4019 effect_ambience: EffectAmbience(false),
4020 arrow_count: ArrowCount(0),
4021 stinger_count: StingerCount(0),
4022 sleeping_pos: SleepingPos(None),
4023 },
4024 no_ai: NoAi(false),
4025 left_handed: LeftHanded(false),
4026 aggressive: Aggressive(false),
4027 },
4028 },
4029 abstract_ageable_baby: AbstractAgeableBaby(false),
4030 },
4031 },
4032 frog_variant: FrogVariant(azalea_registry::WolfSoundVariant::new_raw(0)),
4033 tongue_target: TongueTarget(OptionalUnsignedInt(None)),
4034 }
4035 }
4036}
4037
4038#[derive(Component, Deref, DerefMut, Clone)]
4039pub struct Fuel(pub bool);
4040#[derive(Component)]
4041pub struct FurnaceMinecart;
4042impl FurnaceMinecart {
4043 pub fn apply_metadata(
4044 entity: &mut bevy_ecs::system::EntityCommands,
4045 d: EntityDataItem,
4046 ) -> Result<(), UpdateMetadataError> {
4047 match d.index {
4048 0..=12 => AbstractMinecart::apply_metadata(entity, d)?,
4049 13 => {
4050 entity.insert(Fuel(d.value.into_boolean()?));
4051 }
4052 _ => {}
4053 }
4054 Ok(())
4055 }
4056}
4057
4058#[derive(Bundle)]
4059pub struct FurnaceMinecartMetadataBundle {
4060 _marker: FurnaceMinecart,
4061 parent: AbstractMinecartMetadataBundle,
4062 fuel: Fuel,
4063}
4064impl Default for FurnaceMinecartMetadataBundle {
4065 fn default() -> Self {
4066 Self {
4067 _marker: FurnaceMinecart,
4068 parent: AbstractMinecartMetadataBundle {
4069 _marker: AbstractMinecart,
4070 parent: AbstractVehicleMetadataBundle {
4071 _marker: AbstractVehicle,
4072 parent: AbstractEntityMetadataBundle {
4073 _marker: AbstractEntity,
4074 on_fire: OnFire(false),
4075 shift_key_down: ShiftKeyDown(false),
4076 sprinting: Sprinting(false),
4077 swimming: Swimming(false),
4078 currently_glowing: CurrentlyGlowing(false),
4079 invisible: Invisible(false),
4080 fall_flying: FallFlying(false),
4081 air_supply: AirSupply(Default::default()),
4082 custom_name: CustomName(Default::default()),
4083 custom_name_visible: CustomNameVisible(Default::default()),
4084 silent: Silent(Default::default()),
4085 no_gravity: NoGravity(Default::default()),
4086 pose: Pose::default(),
4087 ticks_frozen: TicksFrozen(Default::default()),
4088 },
4089 hurt: Hurt(0),
4090 hurtdir: Hurtdir(1),
4091 damage: Damage(0.0),
4092 },
4093 custom_display_block: CustomDisplayBlock(azalea_block::BlockState::AIR),
4094 display_offset: DisplayOffset(Default::default()),
4095 },
4096 fuel: Fuel(false),
4097 }
4098 }
4099}
4100
4101#[derive(Component, Deref, DerefMut, Clone)]
4102pub struct IsCharging(pub bool);
4103#[derive(Component)]
4104pub struct Ghast;
4105impl Ghast {
4106 pub fn apply_metadata(
4107 entity: &mut bevy_ecs::system::EntityCommands,
4108 d: EntityDataItem,
4109 ) -> Result<(), UpdateMetadataError> {
4110 match d.index {
4111 0..=15 => AbstractInsentient::apply_metadata(entity, d)?,
4112 16 => {
4113 entity.insert(IsCharging(d.value.into_boolean()?));
4114 }
4115 _ => {}
4116 }
4117 Ok(())
4118 }
4119}
4120
4121#[derive(Bundle)]
4122pub struct GhastMetadataBundle {
4123 _marker: Ghast,
4124 parent: AbstractInsentientMetadataBundle,
4125 is_charging: IsCharging,
4126}
4127impl Default for GhastMetadataBundle {
4128 fn default() -> Self {
4129 Self {
4130 _marker: Ghast,
4131 parent: AbstractInsentientMetadataBundle {
4132 _marker: AbstractInsentient,
4133 parent: AbstractLivingMetadataBundle {
4134 _marker: AbstractLiving,
4135 parent: AbstractEntityMetadataBundle {
4136 _marker: AbstractEntity,
4137 on_fire: OnFire(false),
4138 shift_key_down: ShiftKeyDown(false),
4139 sprinting: Sprinting(false),
4140 swimming: Swimming(false),
4141 currently_glowing: CurrentlyGlowing(false),
4142 invisible: Invisible(false),
4143 fall_flying: FallFlying(false),
4144 air_supply: AirSupply(Default::default()),
4145 custom_name: CustomName(Default::default()),
4146 custom_name_visible: CustomNameVisible(Default::default()),
4147 silent: Silent(Default::default()),
4148 no_gravity: NoGravity(Default::default()),
4149 pose: Pose::default(),
4150 ticks_frozen: TicksFrozen(Default::default()),
4151 },
4152 auto_spin_attack: AutoSpinAttack(false),
4153 abstract_living_using_item: AbstractLivingUsingItem(false),
4154 health: Health(1.0),
4155 effect_particles: EffectParticles(Default::default()),
4156 effect_ambience: EffectAmbience(false),
4157 arrow_count: ArrowCount(0),
4158 stinger_count: StingerCount(0),
4159 sleeping_pos: SleepingPos(None),
4160 },
4161 no_ai: NoAi(false),
4162 left_handed: LeftHanded(false),
4163 aggressive: Aggressive(false),
4164 },
4165 is_charging: IsCharging(false),
4166 }
4167 }
4168}
4169
4170#[derive(Component)]
4171pub struct Giant;
4172impl Giant {
4173 pub fn apply_metadata(
4174 entity: &mut bevy_ecs::system::EntityCommands,
4175 d: EntityDataItem,
4176 ) -> Result<(), UpdateMetadataError> {
4177 match d.index {
4178 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
4179 _ => {}
4180 }
4181 Ok(())
4182 }
4183}
4184
4185#[derive(Bundle)]
4186pub struct GiantMetadataBundle {
4187 _marker: Giant,
4188 parent: AbstractMonsterMetadataBundle,
4189}
4190impl Default for GiantMetadataBundle {
4191 fn default() -> Self {
4192 Self {
4193 _marker: Giant,
4194 parent: AbstractMonsterMetadataBundle {
4195 _marker: AbstractMonster,
4196 parent: AbstractCreatureMetadataBundle {
4197 _marker: AbstractCreature,
4198 parent: AbstractInsentientMetadataBundle {
4199 _marker: AbstractInsentient,
4200 parent: AbstractLivingMetadataBundle {
4201 _marker: AbstractLiving,
4202 parent: AbstractEntityMetadataBundle {
4203 _marker: AbstractEntity,
4204 on_fire: OnFire(false),
4205 shift_key_down: ShiftKeyDown(false),
4206 sprinting: Sprinting(false),
4207 swimming: Swimming(false),
4208 currently_glowing: CurrentlyGlowing(false),
4209 invisible: Invisible(false),
4210 fall_flying: FallFlying(false),
4211 air_supply: AirSupply(Default::default()),
4212 custom_name: CustomName(Default::default()),
4213 custom_name_visible: CustomNameVisible(Default::default()),
4214 silent: Silent(Default::default()),
4215 no_gravity: NoGravity(Default::default()),
4216 pose: Pose::default(),
4217 ticks_frozen: TicksFrozen(Default::default()),
4218 },
4219 auto_spin_attack: AutoSpinAttack(false),
4220 abstract_living_using_item: AbstractLivingUsingItem(false),
4221 health: Health(1.0),
4222 effect_particles: EffectParticles(Default::default()),
4223 effect_ambience: EffectAmbience(false),
4224 arrow_count: ArrowCount(0),
4225 stinger_count: StingerCount(0),
4226 sleeping_pos: SleepingPos(None),
4227 },
4228 no_ai: NoAi(false),
4229 left_handed: LeftHanded(false),
4230 aggressive: Aggressive(false),
4231 },
4232 },
4233 },
4234 }
4235 }
4236}
4237
4238#[derive(Component, Deref, DerefMut, Clone)]
4239pub struct ItemFrameDirection(pub Direction);
4240#[derive(Component, Deref, DerefMut, Clone)]
4241pub struct ItemFrameItem(pub ItemStack);
4242#[derive(Component, Deref, DerefMut, Clone)]
4243pub struct Rotation(pub i32);
4244#[derive(Component)]
4245pub struct GlowItemFrame;
4246impl GlowItemFrame {
4247 pub fn apply_metadata(
4248 entity: &mut bevy_ecs::system::EntityCommands,
4249 d: EntityDataItem,
4250 ) -> Result<(), UpdateMetadataError> {
4251 match d.index {
4252 0..=10 => ItemFrame::apply_metadata(entity, d)?,
4253 _ => {}
4254 }
4255 Ok(())
4256 }
4257}
4258
4259#[derive(Bundle)]
4260pub struct GlowItemFrameMetadataBundle {
4261 _marker: GlowItemFrame,
4262 parent: ItemFrameMetadataBundle,
4263}
4264impl Default for GlowItemFrameMetadataBundle {
4265 fn default() -> Self {
4266 Self {
4267 _marker: GlowItemFrame,
4268 parent: ItemFrameMetadataBundle {
4269 _marker: ItemFrame,
4270 parent: AbstractEntityMetadataBundle {
4271 _marker: AbstractEntity,
4272 on_fire: OnFire(false),
4273 shift_key_down: ShiftKeyDown(false),
4274 sprinting: Sprinting(false),
4275 swimming: Swimming(false),
4276 currently_glowing: CurrentlyGlowing(false),
4277 invisible: Invisible(false),
4278 fall_flying: FallFlying(false),
4279 air_supply: AirSupply(Default::default()),
4280 custom_name: CustomName(Default::default()),
4281 custom_name_visible: CustomNameVisible(Default::default()),
4282 silent: Silent(Default::default()),
4283 no_gravity: NoGravity(Default::default()),
4284 pose: Pose::default(),
4285 ticks_frozen: TicksFrozen(Default::default()),
4286 },
4287 item_frame_direction: ItemFrameDirection(Default::default()),
4288 item_frame_item: ItemFrameItem(Default::default()),
4289 rotation: Rotation(0),
4290 },
4291 }
4292 }
4293}
4294
4295#[derive(Component, Deref, DerefMut, Clone)]
4296pub struct DarkTicksRemaining(pub i32);
4297#[derive(Component)]
4298pub struct GlowSquid;
4299impl GlowSquid {
4300 pub fn apply_metadata(
4301 entity: &mut bevy_ecs::system::EntityCommands,
4302 d: EntityDataItem,
4303 ) -> Result<(), UpdateMetadataError> {
4304 match d.index {
4305 0..=16 => Squid::apply_metadata(entity, d)?,
4306 17 => {
4307 entity.insert(DarkTicksRemaining(d.value.into_int()?));
4308 }
4309 _ => {}
4310 }
4311 Ok(())
4312 }
4313}
4314
4315#[derive(Bundle)]
4316pub struct GlowSquidMetadataBundle {
4317 _marker: GlowSquid,
4318 parent: SquidMetadataBundle,
4319 dark_ticks_remaining: DarkTicksRemaining,
4320}
4321impl Default for GlowSquidMetadataBundle {
4322 fn default() -> Self {
4323 Self {
4324 _marker: GlowSquid,
4325 parent: SquidMetadataBundle {
4326 _marker: Squid,
4327 parent: AbstractAgeableMetadataBundle {
4328 _marker: AbstractAgeable,
4329 parent: AbstractCreatureMetadataBundle {
4330 _marker: AbstractCreature,
4331 parent: AbstractInsentientMetadataBundle {
4332 _marker: AbstractInsentient,
4333 parent: AbstractLivingMetadataBundle {
4334 _marker: AbstractLiving,
4335 parent: AbstractEntityMetadataBundle {
4336 _marker: AbstractEntity,
4337 on_fire: OnFire(false),
4338 shift_key_down: ShiftKeyDown(false),
4339 sprinting: Sprinting(false),
4340 swimming: Swimming(false),
4341 currently_glowing: CurrentlyGlowing(false),
4342 invisible: Invisible(false),
4343 fall_flying: FallFlying(false),
4344 air_supply: AirSupply(Default::default()),
4345 custom_name: CustomName(Default::default()),
4346 custom_name_visible: CustomNameVisible(Default::default()),
4347 silent: Silent(Default::default()),
4348 no_gravity: NoGravity(Default::default()),
4349 pose: Pose::default(),
4350 ticks_frozen: TicksFrozen(Default::default()),
4351 },
4352 auto_spin_attack: AutoSpinAttack(false),
4353 abstract_living_using_item: AbstractLivingUsingItem(false),
4354 health: Health(1.0),
4355 effect_particles: EffectParticles(Default::default()),
4356 effect_ambience: EffectAmbience(false),
4357 arrow_count: ArrowCount(0),
4358 stinger_count: StingerCount(0),
4359 sleeping_pos: SleepingPos(None),
4360 },
4361 no_ai: NoAi(false),
4362 left_handed: LeftHanded(false),
4363 aggressive: Aggressive(false),
4364 },
4365 },
4366 abstract_ageable_baby: AbstractAgeableBaby(false),
4367 },
4368 },
4369 dark_ticks_remaining: DarkTicksRemaining(0),
4370 }
4371 }
4372}
4373
4374#[derive(Component, Deref, DerefMut, Clone)]
4375pub struct IsScreamingGoat(pub bool);
4376#[derive(Component, Deref, DerefMut, Clone)]
4377pub struct HasLeftHorn(pub bool);
4378#[derive(Component, Deref, DerefMut, Clone)]
4379pub struct HasRightHorn(pub bool);
4380#[derive(Component)]
4381pub struct Goat;
4382impl Goat {
4383 pub fn apply_metadata(
4384 entity: &mut bevy_ecs::system::EntityCommands,
4385 d: EntityDataItem,
4386 ) -> Result<(), UpdateMetadataError> {
4387 match d.index {
4388 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
4389 17 => {
4390 entity.insert(IsScreamingGoat(d.value.into_boolean()?));
4391 }
4392 18 => {
4393 entity.insert(HasLeftHorn(d.value.into_boolean()?));
4394 }
4395 19 => {
4396 entity.insert(HasRightHorn(d.value.into_boolean()?));
4397 }
4398 _ => {}
4399 }
4400 Ok(())
4401 }
4402}
4403
4404#[derive(Bundle)]
4405pub struct GoatMetadataBundle {
4406 _marker: Goat,
4407 parent: AbstractAnimalMetadataBundle,
4408 is_screaming_goat: IsScreamingGoat,
4409 has_left_horn: HasLeftHorn,
4410 has_right_horn: HasRightHorn,
4411}
4412impl Default for GoatMetadataBundle {
4413 fn default() -> Self {
4414 Self {
4415 _marker: Goat,
4416 parent: AbstractAnimalMetadataBundle {
4417 _marker: AbstractAnimal,
4418 parent: AbstractAgeableMetadataBundle {
4419 _marker: AbstractAgeable,
4420 parent: AbstractCreatureMetadataBundle {
4421 _marker: AbstractCreature,
4422 parent: AbstractInsentientMetadataBundle {
4423 _marker: AbstractInsentient,
4424 parent: AbstractLivingMetadataBundle {
4425 _marker: AbstractLiving,
4426 parent: AbstractEntityMetadataBundle {
4427 _marker: AbstractEntity,
4428 on_fire: OnFire(false),
4429 shift_key_down: ShiftKeyDown(false),
4430 sprinting: Sprinting(false),
4431 swimming: Swimming(false),
4432 currently_glowing: CurrentlyGlowing(false),
4433 invisible: Invisible(false),
4434 fall_flying: FallFlying(false),
4435 air_supply: AirSupply(Default::default()),
4436 custom_name: CustomName(Default::default()),
4437 custom_name_visible: CustomNameVisible(Default::default()),
4438 silent: Silent(Default::default()),
4439 no_gravity: NoGravity(Default::default()),
4440 pose: Pose::default(),
4441 ticks_frozen: TicksFrozen(Default::default()),
4442 },
4443 auto_spin_attack: AutoSpinAttack(false),
4444 abstract_living_using_item: AbstractLivingUsingItem(false),
4445 health: Health(1.0),
4446 effect_particles: EffectParticles(Default::default()),
4447 effect_ambience: EffectAmbience(false),
4448 arrow_count: ArrowCount(0),
4449 stinger_count: StingerCount(0),
4450 sleeping_pos: SleepingPos(None),
4451 },
4452 no_ai: NoAi(false),
4453 left_handed: LeftHanded(false),
4454 aggressive: Aggressive(false),
4455 },
4456 },
4457 abstract_ageable_baby: AbstractAgeableBaby(false),
4458 },
4459 },
4460 is_screaming_goat: IsScreamingGoat(false),
4461 has_left_horn: HasLeftHorn(true),
4462 has_right_horn: HasRightHorn(true),
4463 }
4464 }
4465}
4466
4467#[derive(Component)]
4468pub struct Guardian;
4469impl Guardian {
4470 pub fn apply_metadata(
4471 entity: &mut bevy_ecs::system::EntityCommands,
4472 d: EntityDataItem,
4473 ) -> Result<(), UpdateMetadataError> {
4474 match d.index {
4475 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
4476 16 => {
4477 entity.insert(Moving(d.value.into_boolean()?));
4478 }
4479 17 => {
4480 entity.insert(AttackTarget(d.value.into_int()?));
4481 }
4482 _ => {}
4483 }
4484 Ok(())
4485 }
4486}
4487
4488#[derive(Bundle)]
4489pub struct GuardianMetadataBundle {
4490 _marker: Guardian,
4491 parent: AbstractMonsterMetadataBundle,
4492 moving: Moving,
4493 attack_target: AttackTarget,
4494}
4495impl Default for GuardianMetadataBundle {
4496 fn default() -> Self {
4497 Self {
4498 _marker: Guardian,
4499 parent: AbstractMonsterMetadataBundle {
4500 _marker: AbstractMonster,
4501 parent: AbstractCreatureMetadataBundle {
4502 _marker: AbstractCreature,
4503 parent: AbstractInsentientMetadataBundle {
4504 _marker: AbstractInsentient,
4505 parent: AbstractLivingMetadataBundle {
4506 _marker: AbstractLiving,
4507 parent: AbstractEntityMetadataBundle {
4508 _marker: AbstractEntity,
4509 on_fire: OnFire(false),
4510 shift_key_down: ShiftKeyDown(false),
4511 sprinting: Sprinting(false),
4512 swimming: Swimming(false),
4513 currently_glowing: CurrentlyGlowing(false),
4514 invisible: Invisible(false),
4515 fall_flying: FallFlying(false),
4516 air_supply: AirSupply(Default::default()),
4517 custom_name: CustomName(Default::default()),
4518 custom_name_visible: CustomNameVisible(Default::default()),
4519 silent: Silent(Default::default()),
4520 no_gravity: NoGravity(Default::default()),
4521 pose: Pose::default(),
4522 ticks_frozen: TicksFrozen(Default::default()),
4523 },
4524 auto_spin_attack: AutoSpinAttack(false),
4525 abstract_living_using_item: AbstractLivingUsingItem(false),
4526 health: Health(1.0),
4527 effect_particles: EffectParticles(Default::default()),
4528 effect_ambience: EffectAmbience(false),
4529 arrow_count: ArrowCount(0),
4530 stinger_count: StingerCount(0),
4531 sleeping_pos: SleepingPos(None),
4532 },
4533 no_ai: NoAi(false),
4534 left_handed: LeftHanded(false),
4535 aggressive: Aggressive(false),
4536 },
4537 },
4538 },
4539 moving: Moving(false),
4540 attack_target: AttackTarget(0),
4541 }
4542 }
4543}
4544
4545#[derive(Component, Deref, DerefMut, Clone)]
4546pub struct IsLeashHolder(pub bool);
4547#[derive(Component, Deref, DerefMut, Clone)]
4548pub struct StaysStill(pub bool);
4549#[derive(Component)]
4550pub struct HappyGhast;
4551impl HappyGhast {
4552 pub fn apply_metadata(
4553 entity: &mut bevy_ecs::system::EntityCommands,
4554 d: EntityDataItem,
4555 ) -> Result<(), UpdateMetadataError> {
4556 match d.index {
4557 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
4558 17 => {
4559 entity.insert(IsLeashHolder(d.value.into_boolean()?));
4560 }
4561 18 => {
4562 entity.insert(StaysStill(d.value.into_boolean()?));
4563 }
4564 _ => {}
4565 }
4566 Ok(())
4567 }
4568}
4569
4570#[derive(Bundle)]
4571pub struct HappyGhastMetadataBundle {
4572 _marker: HappyGhast,
4573 parent: AbstractAnimalMetadataBundle,
4574 is_leash_holder: IsLeashHolder,
4575 stays_still: StaysStill,
4576}
4577impl Default for HappyGhastMetadataBundle {
4578 fn default() -> Self {
4579 Self {
4580 _marker: HappyGhast,
4581 parent: AbstractAnimalMetadataBundle {
4582 _marker: AbstractAnimal,
4583 parent: AbstractAgeableMetadataBundle {
4584 _marker: AbstractAgeable,
4585 parent: AbstractCreatureMetadataBundle {
4586 _marker: AbstractCreature,
4587 parent: AbstractInsentientMetadataBundle {
4588 _marker: AbstractInsentient,
4589 parent: AbstractLivingMetadataBundle {
4590 _marker: AbstractLiving,
4591 parent: AbstractEntityMetadataBundle {
4592 _marker: AbstractEntity,
4593 on_fire: OnFire(false),
4594 shift_key_down: ShiftKeyDown(false),
4595 sprinting: Sprinting(false),
4596 swimming: Swimming(false),
4597 currently_glowing: CurrentlyGlowing(false),
4598 invisible: Invisible(false),
4599 fall_flying: FallFlying(false),
4600 air_supply: AirSupply(Default::default()),
4601 custom_name: CustomName(Default::default()),
4602 custom_name_visible: CustomNameVisible(Default::default()),
4603 silent: Silent(Default::default()),
4604 no_gravity: NoGravity(Default::default()),
4605 pose: Pose::default(),
4606 ticks_frozen: TicksFrozen(Default::default()),
4607 },
4608 auto_spin_attack: AutoSpinAttack(false),
4609 abstract_living_using_item: AbstractLivingUsingItem(false),
4610 health: Health(1.0),
4611 effect_particles: EffectParticles(Default::default()),
4612 effect_ambience: EffectAmbience(false),
4613 arrow_count: ArrowCount(0),
4614 stinger_count: StingerCount(0),
4615 sleeping_pos: SleepingPos(None),
4616 },
4617 no_ai: NoAi(false),
4618 left_handed: LeftHanded(false),
4619 aggressive: Aggressive(false),
4620 },
4621 },
4622 abstract_ageable_baby: AbstractAgeableBaby(false),
4623 },
4624 },
4625 is_leash_holder: IsLeashHolder(false),
4626 stays_still: StaysStill(false),
4627 }
4628 }
4629}
4630
4631#[derive(Component, Deref, DerefMut, Clone)]
4632pub struct HoglinImmuneToZombification(pub bool);
4633#[derive(Component)]
4634pub struct Hoglin;
4635impl Hoglin {
4636 pub fn apply_metadata(
4637 entity: &mut bevy_ecs::system::EntityCommands,
4638 d: EntityDataItem,
4639 ) -> Result<(), UpdateMetadataError> {
4640 match d.index {
4641 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
4642 17 => {
4643 entity.insert(HoglinImmuneToZombification(d.value.into_boolean()?));
4644 }
4645 _ => {}
4646 }
4647 Ok(())
4648 }
4649}
4650
4651#[derive(Bundle)]
4652pub struct HoglinMetadataBundle {
4653 _marker: Hoglin,
4654 parent: AbstractAnimalMetadataBundle,
4655 hoglin_immune_to_zombification: HoglinImmuneToZombification,
4656}
4657impl Default for HoglinMetadataBundle {
4658 fn default() -> Self {
4659 Self {
4660 _marker: Hoglin,
4661 parent: AbstractAnimalMetadataBundle {
4662 _marker: AbstractAnimal,
4663 parent: AbstractAgeableMetadataBundle {
4664 _marker: AbstractAgeable,
4665 parent: AbstractCreatureMetadataBundle {
4666 _marker: AbstractCreature,
4667 parent: AbstractInsentientMetadataBundle {
4668 _marker: AbstractInsentient,
4669 parent: AbstractLivingMetadataBundle {
4670 _marker: AbstractLiving,
4671 parent: AbstractEntityMetadataBundle {
4672 _marker: AbstractEntity,
4673 on_fire: OnFire(false),
4674 shift_key_down: ShiftKeyDown(false),
4675 sprinting: Sprinting(false),
4676 swimming: Swimming(false),
4677 currently_glowing: CurrentlyGlowing(false),
4678 invisible: Invisible(false),
4679 fall_flying: FallFlying(false),
4680 air_supply: AirSupply(Default::default()),
4681 custom_name: CustomName(Default::default()),
4682 custom_name_visible: CustomNameVisible(Default::default()),
4683 silent: Silent(Default::default()),
4684 no_gravity: NoGravity(Default::default()),
4685 pose: Pose::default(),
4686 ticks_frozen: TicksFrozen(Default::default()),
4687 },
4688 auto_spin_attack: AutoSpinAttack(false),
4689 abstract_living_using_item: AbstractLivingUsingItem(false),
4690 health: Health(1.0),
4691 effect_particles: EffectParticles(Default::default()),
4692 effect_ambience: EffectAmbience(false),
4693 arrow_count: ArrowCount(0),
4694 stinger_count: StingerCount(0),
4695 sleeping_pos: SleepingPos(None),
4696 },
4697 no_ai: NoAi(false),
4698 left_handed: LeftHanded(false),
4699 aggressive: Aggressive(false),
4700 },
4701 },
4702 abstract_ageable_baby: AbstractAgeableBaby(false),
4703 },
4704 },
4705 hoglin_immune_to_zombification: HoglinImmuneToZombification(false),
4706 }
4707 }
4708}
4709
4710#[derive(Component)]
4711pub struct HopperMinecart;
4712impl HopperMinecart {
4713 pub fn apply_metadata(
4714 entity: &mut bevy_ecs::system::EntityCommands,
4715 d: EntityDataItem,
4716 ) -> Result<(), UpdateMetadataError> {
4717 match d.index {
4718 0..=12 => AbstractMinecart::apply_metadata(entity, d)?,
4719 _ => {}
4720 }
4721 Ok(())
4722 }
4723}
4724
4725#[derive(Bundle)]
4726pub struct HopperMinecartMetadataBundle {
4727 _marker: HopperMinecart,
4728 parent: AbstractMinecartMetadataBundle,
4729}
4730impl Default for HopperMinecartMetadataBundle {
4731 fn default() -> Self {
4732 Self {
4733 _marker: HopperMinecart,
4734 parent: AbstractMinecartMetadataBundle {
4735 _marker: AbstractMinecart,
4736 parent: AbstractVehicleMetadataBundle {
4737 _marker: AbstractVehicle,
4738 parent: AbstractEntityMetadataBundle {
4739 _marker: AbstractEntity,
4740 on_fire: OnFire(false),
4741 shift_key_down: ShiftKeyDown(false),
4742 sprinting: Sprinting(false),
4743 swimming: Swimming(false),
4744 currently_glowing: CurrentlyGlowing(false),
4745 invisible: Invisible(false),
4746 fall_flying: FallFlying(false),
4747 air_supply: AirSupply(Default::default()),
4748 custom_name: CustomName(Default::default()),
4749 custom_name_visible: CustomNameVisible(Default::default()),
4750 silent: Silent(Default::default()),
4751 no_gravity: NoGravity(Default::default()),
4752 pose: Pose::default(),
4753 ticks_frozen: TicksFrozen(Default::default()),
4754 },
4755 hurt: Hurt(0),
4756 hurtdir: Hurtdir(1),
4757 damage: Damage(0.0),
4758 },
4759 custom_display_block: CustomDisplayBlock(azalea_block::BlockState::AIR),
4760 display_offset: DisplayOffset(Default::default()),
4761 },
4762 }
4763 }
4764}
4765
4766#[derive(Component, Deref, DerefMut, Clone)]
4767pub struct HorseTypeVariant(pub i32);
4768#[derive(Component)]
4769pub struct Horse;
4770impl Horse {
4771 pub fn apply_metadata(
4772 entity: &mut bevy_ecs::system::EntityCommands,
4773 d: EntityDataItem,
4774 ) -> Result<(), UpdateMetadataError> {
4775 match d.index {
4776 0..=17 => AbstractHorse::apply_metadata(entity, d)?,
4777 18 => {
4778 entity.insert(HorseTypeVariant(d.value.into_int()?));
4779 }
4780 _ => {}
4781 }
4782 Ok(())
4783 }
4784}
4785
4786#[derive(Bundle)]
4787pub struct HorseMetadataBundle {
4788 _marker: Horse,
4789 parent: AbstractHorseMetadataBundle,
4790 horse_type_variant: HorseTypeVariant,
4791}
4792impl Default for HorseMetadataBundle {
4793 fn default() -> Self {
4794 Self {
4795 _marker: Horse,
4796 parent: AbstractHorseMetadataBundle {
4797 _marker: AbstractHorse,
4798 parent: AbstractAnimalMetadataBundle {
4799 _marker: AbstractAnimal,
4800 parent: AbstractAgeableMetadataBundle {
4801 _marker: AbstractAgeable,
4802 parent: AbstractCreatureMetadataBundle {
4803 _marker: AbstractCreature,
4804 parent: AbstractInsentientMetadataBundle {
4805 _marker: AbstractInsentient,
4806 parent: AbstractLivingMetadataBundle {
4807 _marker: AbstractLiving,
4808 parent: AbstractEntityMetadataBundle {
4809 _marker: AbstractEntity,
4810 on_fire: OnFire(false),
4811 shift_key_down: ShiftKeyDown(false),
4812 sprinting: Sprinting(false),
4813 swimming: Swimming(false),
4814 currently_glowing: CurrentlyGlowing(false),
4815 invisible: Invisible(false),
4816 fall_flying: FallFlying(false),
4817 air_supply: AirSupply(Default::default()),
4818 custom_name: CustomName(Default::default()),
4819 custom_name_visible: CustomNameVisible(Default::default()),
4820 silent: Silent(Default::default()),
4821 no_gravity: NoGravity(Default::default()),
4822 pose: Pose::default(),
4823 ticks_frozen: TicksFrozen(Default::default()),
4824 },
4825 auto_spin_attack: AutoSpinAttack(false),
4826 abstract_living_using_item: AbstractLivingUsingItem(false),
4827 health: Health(1.0),
4828 effect_particles: EffectParticles(Default::default()),
4829 effect_ambience: EffectAmbience(false),
4830 arrow_count: ArrowCount(0),
4831 stinger_count: StingerCount(0),
4832 sleeping_pos: SleepingPos(None),
4833 },
4834 no_ai: NoAi(false),
4835 left_handed: LeftHanded(false),
4836 aggressive: Aggressive(false),
4837 },
4838 },
4839 abstract_ageable_baby: AbstractAgeableBaby(false),
4840 },
4841 },
4842 tamed: Tamed(false),
4843 eating: Eating(false),
4844 abstract_horse_standing: AbstractHorseStanding(false),
4845 bred: Bred(false),
4846 },
4847 horse_type_variant: HorseTypeVariant(0),
4848 }
4849 }
4850}
4851
4852#[derive(Component)]
4853pub struct Husk;
4854impl Husk {
4855 pub fn apply_metadata(
4856 entity: &mut bevy_ecs::system::EntityCommands,
4857 d: EntityDataItem,
4858 ) -> Result<(), UpdateMetadataError> {
4859 match d.index {
4860 0..=18 => Zombie::apply_metadata(entity, d)?,
4861 _ => {}
4862 }
4863 Ok(())
4864 }
4865}
4866
4867#[derive(Bundle)]
4868pub struct HuskMetadataBundle {
4869 _marker: Husk,
4870 parent: ZombieMetadataBundle,
4871}
4872impl Default for HuskMetadataBundle {
4873 fn default() -> Self {
4874 Self {
4875 _marker: Husk,
4876 parent: ZombieMetadataBundle {
4877 _marker: Zombie,
4878 parent: AbstractMonsterMetadataBundle {
4879 _marker: AbstractMonster,
4880 parent: AbstractCreatureMetadataBundle {
4881 _marker: AbstractCreature,
4882 parent: AbstractInsentientMetadataBundle {
4883 _marker: AbstractInsentient,
4884 parent: AbstractLivingMetadataBundle {
4885 _marker: AbstractLiving,
4886 parent: AbstractEntityMetadataBundle {
4887 _marker: AbstractEntity,
4888 on_fire: OnFire(false),
4889 shift_key_down: ShiftKeyDown(false),
4890 sprinting: Sprinting(false),
4891 swimming: Swimming(false),
4892 currently_glowing: CurrentlyGlowing(false),
4893 invisible: Invisible(false),
4894 fall_flying: FallFlying(false),
4895 air_supply: AirSupply(Default::default()),
4896 custom_name: CustomName(Default::default()),
4897 custom_name_visible: CustomNameVisible(Default::default()),
4898 silent: Silent(Default::default()),
4899 no_gravity: NoGravity(Default::default()),
4900 pose: Pose::default(),
4901 ticks_frozen: TicksFrozen(Default::default()),
4902 },
4903 auto_spin_attack: AutoSpinAttack(false),
4904 abstract_living_using_item: AbstractLivingUsingItem(false),
4905 health: Health(1.0),
4906 effect_particles: EffectParticles(Default::default()),
4907 effect_ambience: EffectAmbience(false),
4908 arrow_count: ArrowCount(0),
4909 stinger_count: StingerCount(0),
4910 sleeping_pos: SleepingPos(None),
4911 },
4912 no_ai: NoAi(false),
4913 left_handed: LeftHanded(false),
4914 aggressive: Aggressive(false),
4915 },
4916 },
4917 },
4918 zombie_baby: ZombieBaby(false),
4919 special_type: SpecialType(0),
4920 drowned_conversion: DrownedConversion(false),
4921 },
4922 }
4923 }
4924}
4925
4926#[derive(Component)]
4927pub struct Illusioner;
4928impl Illusioner {
4929 pub fn apply_metadata(
4930 entity: &mut bevy_ecs::system::EntityCommands,
4931 d: EntityDataItem,
4932 ) -> Result<(), UpdateMetadataError> {
4933 match d.index {
4934 0..=17 => AbstractSpellcasterIllager::apply_metadata(entity, d)?,
4935 _ => {}
4936 }
4937 Ok(())
4938 }
4939}
4940
4941#[derive(Bundle)]
4942pub struct IllusionerMetadataBundle {
4943 _marker: Illusioner,
4944 parent: AbstractSpellcasterIllagerMetadataBundle,
4945}
4946impl Default for IllusionerMetadataBundle {
4947 fn default() -> Self {
4948 Self {
4949 _marker: Illusioner,
4950 parent: AbstractSpellcasterIllagerMetadataBundle {
4951 _marker: AbstractSpellcasterIllager,
4952 parent: AbstractRaiderMetadataBundle {
4953 _marker: AbstractRaider,
4954 parent: AbstractMonsterMetadataBundle {
4955 _marker: AbstractMonster,
4956 parent: AbstractCreatureMetadataBundle {
4957 _marker: AbstractCreature,
4958 parent: AbstractInsentientMetadataBundle {
4959 _marker: AbstractInsentient,
4960 parent: AbstractLivingMetadataBundle {
4961 _marker: AbstractLiving,
4962 parent: AbstractEntityMetadataBundle {
4963 _marker: AbstractEntity,
4964 on_fire: OnFire(false),
4965 shift_key_down: ShiftKeyDown(false),
4966 sprinting: Sprinting(false),
4967 swimming: Swimming(false),
4968 currently_glowing: CurrentlyGlowing(false),
4969 invisible: Invisible(false),
4970 fall_flying: FallFlying(false),
4971 air_supply: AirSupply(Default::default()),
4972 custom_name: CustomName(Default::default()),
4973 custom_name_visible: CustomNameVisible(Default::default()),
4974 silent: Silent(Default::default()),
4975 no_gravity: NoGravity(Default::default()),
4976 pose: Pose::default(),
4977 ticks_frozen: TicksFrozen(Default::default()),
4978 },
4979 auto_spin_attack: AutoSpinAttack(false),
4980 abstract_living_using_item: AbstractLivingUsingItem(false),
4981 health: Health(1.0),
4982 effect_particles: EffectParticles(Default::default()),
4983 effect_ambience: EffectAmbience(false),
4984 arrow_count: ArrowCount(0),
4985 stinger_count: StingerCount(0),
4986 sleeping_pos: SleepingPos(None),
4987 },
4988 no_ai: NoAi(false),
4989 left_handed: LeftHanded(false),
4990 aggressive: Aggressive(false),
4991 },
4992 },
4993 },
4994 is_celebrating: IsCelebrating(false),
4995 },
4996 spell_casting: SpellCasting(0),
4997 },
4998 }
4999 }
5000}
5001
5002#[derive(Component, Deref, DerefMut, Clone)]
5003pub struct InteractionWidth(pub f32);
5004#[derive(Component, Deref, DerefMut, Clone)]
5005pub struct InteractionHeight(pub f32);
5006#[derive(Component, Deref, DerefMut, Clone)]
5007pub struct Response(pub bool);
5008#[derive(Component)]
5009pub struct Interaction;
5010impl Interaction {
5011 pub fn apply_metadata(
5012 entity: &mut bevy_ecs::system::EntityCommands,
5013 d: EntityDataItem,
5014 ) -> Result<(), UpdateMetadataError> {
5015 match d.index {
5016 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
5017 8 => {
5018 entity.insert(InteractionWidth(d.value.into_float()?));
5019 }
5020 9 => {
5021 entity.insert(InteractionHeight(d.value.into_float()?));
5022 }
5023 10 => {
5024 entity.insert(Response(d.value.into_boolean()?));
5025 }
5026 _ => {}
5027 }
5028 Ok(())
5029 }
5030}
5031
5032#[derive(Bundle)]
5033pub struct InteractionMetadataBundle {
5034 _marker: Interaction,
5035 parent: AbstractEntityMetadataBundle,
5036 interaction_width: InteractionWidth,
5037 interaction_height: InteractionHeight,
5038 response: Response,
5039}
5040impl Default for InteractionMetadataBundle {
5041 fn default() -> Self {
5042 Self {
5043 _marker: Interaction,
5044 parent: AbstractEntityMetadataBundle {
5045 _marker: AbstractEntity,
5046 on_fire: OnFire(false),
5047 shift_key_down: ShiftKeyDown(false),
5048 sprinting: Sprinting(false),
5049 swimming: Swimming(false),
5050 currently_glowing: CurrentlyGlowing(false),
5051 invisible: Invisible(false),
5052 fall_flying: FallFlying(false),
5053 air_supply: AirSupply(Default::default()),
5054 custom_name: CustomName(Default::default()),
5055 custom_name_visible: CustomNameVisible(Default::default()),
5056 silent: Silent(Default::default()),
5057 no_gravity: NoGravity(Default::default()),
5058 pose: Pose::default(),
5059 ticks_frozen: TicksFrozen(Default::default()),
5060 },
5061 interaction_width: InteractionWidth(1.0),
5062 interaction_height: InteractionHeight(1.0),
5063 response: Response(false),
5064 }
5065 }
5066}
5067
5068#[derive(Component, Deref, DerefMut, Clone, Copy)]
5069pub struct PlayerCreated(pub bool);
5070#[derive(Component)]
5071pub struct IronGolem;
5072impl IronGolem {
5073 pub fn apply_metadata(
5074 entity: &mut bevy_ecs::system::EntityCommands,
5075 d: EntityDataItem,
5076 ) -> Result<(), UpdateMetadataError> {
5077 match d.index {
5078 0..=15 => AbstractCreature::apply_metadata(entity, d)?,
5079 16 => {
5080 let bitfield = d.value.into_byte()?;
5081 entity.insert(PlayerCreated(bitfield & 0x1 != 0));
5082 }
5083 _ => {}
5084 }
5085 Ok(())
5086 }
5087}
5088
5089#[derive(Bundle)]
5090pub struct IronGolemMetadataBundle {
5091 _marker: IronGolem,
5092 parent: AbstractCreatureMetadataBundle,
5093 player_created: PlayerCreated,
5094}
5095impl Default for IronGolemMetadataBundle {
5096 fn default() -> Self {
5097 Self {
5098 _marker: IronGolem,
5099 parent: AbstractCreatureMetadataBundle {
5100 _marker: AbstractCreature,
5101 parent: AbstractInsentientMetadataBundle {
5102 _marker: AbstractInsentient,
5103 parent: AbstractLivingMetadataBundle {
5104 _marker: AbstractLiving,
5105 parent: AbstractEntityMetadataBundle {
5106 _marker: AbstractEntity,
5107 on_fire: OnFire(false),
5108 shift_key_down: ShiftKeyDown(false),
5109 sprinting: Sprinting(false),
5110 swimming: Swimming(false),
5111 currently_glowing: CurrentlyGlowing(false),
5112 invisible: Invisible(false),
5113 fall_flying: FallFlying(false),
5114 air_supply: AirSupply(Default::default()),
5115 custom_name: CustomName(Default::default()),
5116 custom_name_visible: CustomNameVisible(Default::default()),
5117 silent: Silent(Default::default()),
5118 no_gravity: NoGravity(Default::default()),
5119 pose: Pose::default(),
5120 ticks_frozen: TicksFrozen(Default::default()),
5121 },
5122 auto_spin_attack: AutoSpinAttack(false),
5123 abstract_living_using_item: AbstractLivingUsingItem(false),
5124 health: Health(1.0),
5125 effect_particles: EffectParticles(Default::default()),
5126 effect_ambience: EffectAmbience(false),
5127 arrow_count: ArrowCount(0),
5128 stinger_count: StingerCount(0),
5129 sleeping_pos: SleepingPos(None),
5130 },
5131 no_ai: NoAi(false),
5132 left_handed: LeftHanded(false),
5133 aggressive: Aggressive(false),
5134 },
5135 },
5136 player_created: PlayerCreated(false),
5137 }
5138 }
5139}
5140
5141#[derive(Component, Deref, DerefMut, Clone)]
5142pub struct ItemItem(pub ItemStack);
5143#[derive(Component)]
5144pub struct Item;
5145impl Item {
5146 pub fn apply_metadata(
5147 entity: &mut bevy_ecs::system::EntityCommands,
5148 d: EntityDataItem,
5149 ) -> Result<(), UpdateMetadataError> {
5150 match d.index {
5151 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
5152 8 => {
5153 entity.insert(ItemItem(d.value.into_item_stack()?));
5154 }
5155 _ => {}
5156 }
5157 Ok(())
5158 }
5159}
5160
5161#[derive(Bundle)]
5162pub struct ItemMetadataBundle {
5163 _marker: Item,
5164 parent: AbstractEntityMetadataBundle,
5165 item_item: ItemItem,
5166}
5167impl Default for ItemMetadataBundle {
5168 fn default() -> Self {
5169 Self {
5170 _marker: Item,
5171 parent: AbstractEntityMetadataBundle {
5172 _marker: AbstractEntity,
5173 on_fire: OnFire(false),
5174 shift_key_down: ShiftKeyDown(false),
5175 sprinting: Sprinting(false),
5176 swimming: Swimming(false),
5177 currently_glowing: CurrentlyGlowing(false),
5178 invisible: Invisible(false),
5179 fall_flying: FallFlying(false),
5180 air_supply: AirSupply(Default::default()),
5181 custom_name: CustomName(Default::default()),
5182 custom_name_visible: CustomNameVisible(Default::default()),
5183 silent: Silent(Default::default()),
5184 no_gravity: NoGravity(Default::default()),
5185 pose: Pose::default(),
5186 ticks_frozen: TicksFrozen(Default::default()),
5187 },
5188 item_item: ItemItem(Default::default()),
5189 }
5190 }
5191}
5192
5193#[derive(Component, Deref, DerefMut, Clone)]
5194pub struct ItemDisplayItemStack(pub ItemStack);
5195#[derive(Component, Deref, DerefMut, Clone)]
5196pub struct ItemDisplayItemDisplay(pub u8);
5197#[derive(Component)]
5198pub struct ItemDisplay;
5199impl ItemDisplay {
5200 pub fn apply_metadata(
5201 entity: &mut bevy_ecs::system::EntityCommands,
5202 d: EntityDataItem,
5203 ) -> Result<(), UpdateMetadataError> {
5204 match d.index {
5205 0..=22 => AbstractDisplay::apply_metadata(entity, d)?,
5206 23 => {
5207 entity.insert(ItemDisplayItemStack(d.value.into_item_stack()?));
5208 }
5209 24 => {
5210 entity.insert(ItemDisplayItemDisplay(d.value.into_byte()?));
5211 }
5212 _ => {}
5213 }
5214 Ok(())
5215 }
5216}
5217
5218#[derive(Bundle)]
5219pub struct ItemDisplayMetadataBundle {
5220 _marker: ItemDisplay,
5221 parent: AbstractDisplayMetadataBundle,
5222 item_display_item_stack: ItemDisplayItemStack,
5223 item_display_item_display: ItemDisplayItemDisplay,
5224}
5225impl Default for ItemDisplayMetadataBundle {
5226 fn default() -> Self {
5227 Self {
5228 _marker: ItemDisplay,
5229 parent: AbstractDisplayMetadataBundle {
5230 _marker: AbstractDisplay,
5231 parent: AbstractEntityMetadataBundle {
5232 _marker: AbstractEntity,
5233 on_fire: OnFire(false),
5234 shift_key_down: ShiftKeyDown(false),
5235 sprinting: Sprinting(false),
5236 swimming: Swimming(false),
5237 currently_glowing: CurrentlyGlowing(false),
5238 invisible: Invisible(false),
5239 fall_flying: FallFlying(false),
5240 air_supply: AirSupply(Default::default()),
5241 custom_name: CustomName(Default::default()),
5242 custom_name_visible: CustomNameVisible(Default::default()),
5243 silent: Silent(Default::default()),
5244 no_gravity: NoGravity(Default::default()),
5245 pose: Pose::default(),
5246 ticks_frozen: TicksFrozen(Default::default()),
5247 },
5248 transformation_interpolation_start_delta_ticks:
5249 TransformationInterpolationStartDeltaTicks(0),
5250 transformation_interpolation_duration: TransformationInterpolationDuration(0),
5251 pos_rot_interpolation_duration: PosRotInterpolationDuration(0),
5252 translation: Translation(Vec3 {
5253 x: 0.0,
5254 y: 0.0,
5255 z: 0.0,
5256 }),
5257 scale: Scale(Vec3 {
5258 x: 1.0,
5259 y: 1.0,
5260 z: 1.0,
5261 }),
5262 left_rotation: LeftRotation(Quaternion {
5263 x: 0.0,
5264 y: 0.0,
5265 z: 0.0,
5266 w: 1.0,
5267 }),
5268 right_rotation: RightRotation(Quaternion {
5269 x: 0.0,
5270 y: 0.0,
5271 z: 0.0,
5272 w: 1.0,
5273 }),
5274 billboard_render_constraints: BillboardRenderConstraints(Default::default()),
5275 brightness_override: BrightnessOverride(-1),
5276 view_range: ViewRange(1.0),
5277 shadow_radius: ShadowRadius(0.0),
5278 shadow_strength: ShadowStrength(1.0),
5279 abstract_display_width: AbstractDisplayWidth(0.0),
5280 abstract_display_height: AbstractDisplayHeight(0.0),
5281 glow_color_override: GlowColorOverride(-1),
5282 },
5283 item_display_item_stack: ItemDisplayItemStack(Default::default()),
5284 item_display_item_display: ItemDisplayItemDisplay(Default::default()),
5285 }
5286 }
5287}
5288
5289#[derive(Component)]
5290pub struct ItemFrame;
5291impl ItemFrame {
5292 pub fn apply_metadata(
5293 entity: &mut bevy_ecs::system::EntityCommands,
5294 d: EntityDataItem,
5295 ) -> Result<(), UpdateMetadataError> {
5296 match d.index {
5297 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
5298 8 => {
5299 entity.insert(ItemFrameDirection(d.value.into_direction()?));
5300 }
5301 9 => {
5302 entity.insert(ItemFrameItem(d.value.into_item_stack()?));
5303 }
5304 10 => {
5305 entity.insert(Rotation(d.value.into_int()?));
5306 }
5307 _ => {}
5308 }
5309 Ok(())
5310 }
5311}
5312
5313#[derive(Bundle)]
5314pub struct ItemFrameMetadataBundle {
5315 _marker: ItemFrame,
5316 parent: AbstractEntityMetadataBundle,
5317 item_frame_direction: ItemFrameDirection,
5318 item_frame_item: ItemFrameItem,
5319 rotation: Rotation,
5320}
5321impl Default for ItemFrameMetadataBundle {
5322 fn default() -> Self {
5323 Self {
5324 _marker: ItemFrame,
5325 parent: AbstractEntityMetadataBundle {
5326 _marker: AbstractEntity,
5327 on_fire: OnFire(false),
5328 shift_key_down: ShiftKeyDown(false),
5329 sprinting: Sprinting(false),
5330 swimming: Swimming(false),
5331 currently_glowing: CurrentlyGlowing(false),
5332 invisible: Invisible(false),
5333 fall_flying: FallFlying(false),
5334 air_supply: AirSupply(Default::default()),
5335 custom_name: CustomName(Default::default()),
5336 custom_name_visible: CustomNameVisible(Default::default()),
5337 silent: Silent(Default::default()),
5338 no_gravity: NoGravity(Default::default()),
5339 pose: Pose::default(),
5340 ticks_frozen: TicksFrozen(Default::default()),
5341 },
5342 item_frame_direction: ItemFrameDirection(Default::default()),
5343 item_frame_item: ItemFrameItem(Default::default()),
5344 rotation: Rotation(0),
5345 }
5346 }
5347}
5348
5349#[derive(Component)]
5350pub struct JungleBoat;
5351impl JungleBoat {
5352 pub fn apply_metadata(
5353 entity: &mut bevy_ecs::system::EntityCommands,
5354 d: EntityDataItem,
5355 ) -> Result<(), UpdateMetadataError> {
5356 match d.index {
5357 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
5358 _ => {}
5359 }
5360 Ok(())
5361 }
5362}
5363
5364#[derive(Bundle)]
5365pub struct JungleBoatMetadataBundle {
5366 _marker: JungleBoat,
5367 parent: AbstractBoatMetadataBundle,
5368}
5369impl Default for JungleBoatMetadataBundle {
5370 fn default() -> Self {
5371 Self {
5372 _marker: JungleBoat,
5373 parent: AbstractBoatMetadataBundle {
5374 _marker: AbstractBoat,
5375 parent: AbstractVehicleMetadataBundle {
5376 _marker: AbstractVehicle,
5377 parent: AbstractEntityMetadataBundle {
5378 _marker: AbstractEntity,
5379 on_fire: OnFire(false),
5380 shift_key_down: ShiftKeyDown(false),
5381 sprinting: Sprinting(false),
5382 swimming: Swimming(false),
5383 currently_glowing: CurrentlyGlowing(false),
5384 invisible: Invisible(false),
5385 fall_flying: FallFlying(false),
5386 air_supply: AirSupply(Default::default()),
5387 custom_name: CustomName(Default::default()),
5388 custom_name_visible: CustomNameVisible(Default::default()),
5389 silent: Silent(Default::default()),
5390 no_gravity: NoGravity(Default::default()),
5391 pose: Pose::default(),
5392 ticks_frozen: TicksFrozen(Default::default()),
5393 },
5394 hurt: Hurt(0),
5395 hurtdir: Hurtdir(1),
5396 damage: Damage(0.0),
5397 },
5398 paddle_left: PaddleLeft(false),
5399 paddle_right: PaddleRight(false),
5400 bubble_time: BubbleTime(0),
5401 },
5402 }
5403 }
5404}
5405
5406#[derive(Component)]
5407pub struct JungleChestBoat;
5408impl JungleChestBoat {
5409 pub fn apply_metadata(
5410 entity: &mut bevy_ecs::system::EntityCommands,
5411 d: EntityDataItem,
5412 ) -> Result<(), UpdateMetadataError> {
5413 match d.index {
5414 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
5415 _ => {}
5416 }
5417 Ok(())
5418 }
5419}
5420
5421#[derive(Bundle)]
5422pub struct JungleChestBoatMetadataBundle {
5423 _marker: JungleChestBoat,
5424 parent: AbstractBoatMetadataBundle,
5425}
5426impl Default for JungleChestBoatMetadataBundle {
5427 fn default() -> Self {
5428 Self {
5429 _marker: JungleChestBoat,
5430 parent: AbstractBoatMetadataBundle {
5431 _marker: AbstractBoat,
5432 parent: AbstractVehicleMetadataBundle {
5433 _marker: AbstractVehicle,
5434 parent: AbstractEntityMetadataBundle {
5435 _marker: AbstractEntity,
5436 on_fire: OnFire(false),
5437 shift_key_down: ShiftKeyDown(false),
5438 sprinting: Sprinting(false),
5439 swimming: Swimming(false),
5440 currently_glowing: CurrentlyGlowing(false),
5441 invisible: Invisible(false),
5442 fall_flying: FallFlying(false),
5443 air_supply: AirSupply(Default::default()),
5444 custom_name: CustomName(Default::default()),
5445 custom_name_visible: CustomNameVisible(Default::default()),
5446 silent: Silent(Default::default()),
5447 no_gravity: NoGravity(Default::default()),
5448 pose: Pose::default(),
5449 ticks_frozen: TicksFrozen(Default::default()),
5450 },
5451 hurt: Hurt(0),
5452 hurtdir: Hurtdir(1),
5453 damage: Damage(0.0),
5454 },
5455 paddle_left: PaddleLeft(false),
5456 paddle_right: PaddleRight(false),
5457 bubble_time: BubbleTime(0),
5458 },
5459 }
5460 }
5461}
5462
5463#[derive(Component)]
5464pub struct LeashKnot;
5465impl LeashKnot {
5466 pub fn apply_metadata(
5467 entity: &mut bevy_ecs::system::EntityCommands,
5468 d: EntityDataItem,
5469 ) -> Result<(), UpdateMetadataError> {
5470 match d.index {
5471 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
5472 _ => {}
5473 }
5474 Ok(())
5475 }
5476}
5477
5478#[derive(Bundle)]
5479pub struct LeashKnotMetadataBundle {
5480 _marker: LeashKnot,
5481 parent: AbstractEntityMetadataBundle,
5482}
5483impl Default for LeashKnotMetadataBundle {
5484 fn default() -> Self {
5485 Self {
5486 _marker: LeashKnot,
5487 parent: AbstractEntityMetadataBundle {
5488 _marker: AbstractEntity,
5489 on_fire: OnFire(false),
5490 shift_key_down: ShiftKeyDown(false),
5491 sprinting: Sprinting(false),
5492 swimming: Swimming(false),
5493 currently_glowing: CurrentlyGlowing(false),
5494 invisible: Invisible(false),
5495 fall_flying: FallFlying(false),
5496 air_supply: AirSupply(Default::default()),
5497 custom_name: CustomName(Default::default()),
5498 custom_name_visible: CustomNameVisible(Default::default()),
5499 silent: Silent(Default::default()),
5500 no_gravity: NoGravity(Default::default()),
5501 pose: Pose::default(),
5502 ticks_frozen: TicksFrozen(Default::default()),
5503 },
5504 }
5505 }
5506}
5507
5508#[derive(Component)]
5509pub struct LightningBolt;
5510impl LightningBolt {
5511 pub fn apply_metadata(
5512 entity: &mut bevy_ecs::system::EntityCommands,
5513 d: EntityDataItem,
5514 ) -> Result<(), UpdateMetadataError> {
5515 match d.index {
5516 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
5517 _ => {}
5518 }
5519 Ok(())
5520 }
5521}
5522
5523#[derive(Bundle)]
5524pub struct LightningBoltMetadataBundle {
5525 _marker: LightningBolt,
5526 parent: AbstractEntityMetadataBundle,
5527}
5528impl Default for LightningBoltMetadataBundle {
5529 fn default() -> Self {
5530 Self {
5531 _marker: LightningBolt,
5532 parent: AbstractEntityMetadataBundle {
5533 _marker: AbstractEntity,
5534 on_fire: OnFire(false),
5535 shift_key_down: ShiftKeyDown(false),
5536 sprinting: Sprinting(false),
5537 swimming: Swimming(false),
5538 currently_glowing: CurrentlyGlowing(false),
5539 invisible: Invisible(false),
5540 fall_flying: FallFlying(false),
5541 air_supply: AirSupply(Default::default()),
5542 custom_name: CustomName(Default::default()),
5543 custom_name_visible: CustomNameVisible(Default::default()),
5544 silent: Silent(Default::default()),
5545 no_gravity: NoGravity(Default::default()),
5546 pose: Pose::default(),
5547 ticks_frozen: TicksFrozen(Default::default()),
5548 },
5549 }
5550 }
5551}
5552
5553#[derive(Component)]
5554pub struct LingeringPotion;
5555impl LingeringPotion {
5556 pub fn apply_metadata(
5557 entity: &mut bevy_ecs::system::EntityCommands,
5558 d: EntityDataItem,
5559 ) -> Result<(), UpdateMetadataError> {
5560 match d.index {
5561 0..=8 => AbstractThrownItemProjectile::apply_metadata(entity, d)?,
5562 _ => {}
5563 }
5564 Ok(())
5565 }
5566}
5567
5568#[derive(Bundle)]
5569pub struct LingeringPotionMetadataBundle {
5570 _marker: LingeringPotion,
5571 parent: AbstractThrownItemProjectileMetadataBundle,
5572}
5573impl Default for LingeringPotionMetadataBundle {
5574 fn default() -> Self {
5575 Self {
5576 _marker: LingeringPotion,
5577 parent: AbstractThrownItemProjectileMetadataBundle {
5578 _marker: AbstractThrownItemProjectile,
5579 parent: AbstractEntityMetadataBundle {
5580 _marker: AbstractEntity,
5581 on_fire: OnFire(false),
5582 shift_key_down: ShiftKeyDown(false),
5583 sprinting: Sprinting(false),
5584 swimming: Swimming(false),
5585 currently_glowing: CurrentlyGlowing(false),
5586 invisible: Invisible(false),
5587 fall_flying: FallFlying(false),
5588 air_supply: AirSupply(Default::default()),
5589 custom_name: CustomName(Default::default()),
5590 custom_name_visible: CustomNameVisible(Default::default()),
5591 silent: Silent(Default::default()),
5592 no_gravity: NoGravity(Default::default()),
5593 pose: Pose::default(),
5594 ticks_frozen: TicksFrozen(Default::default()),
5595 },
5596 abstract_thrown_item_projectile_item_stack: AbstractThrownItemProjectileItemStack(
5597 Default::default(),
5598 ),
5599 },
5600 }
5601 }
5602}
5603
5604#[derive(Component, Deref, DerefMut, Clone)]
5605pub struct Strength(pub i32);
5606#[derive(Component, Deref, DerefMut, Clone)]
5607pub struct LlamaVariant(pub i32);
5608#[derive(Component)]
5609pub struct Llama;
5610impl Llama {
5611 pub fn apply_metadata(
5612 entity: &mut bevy_ecs::system::EntityCommands,
5613 d: EntityDataItem,
5614 ) -> Result<(), UpdateMetadataError> {
5615 match d.index {
5616 0..=18 => AbstractChestedHorse::apply_metadata(entity, d)?,
5617 19 => {
5618 entity.insert(Strength(d.value.into_int()?));
5619 }
5620 20 => {
5621 entity.insert(LlamaVariant(d.value.into_int()?));
5622 }
5623 _ => {}
5624 }
5625 Ok(())
5626 }
5627}
5628
5629#[derive(Bundle)]
5630pub struct LlamaMetadataBundle {
5631 _marker: Llama,
5632 parent: AbstractChestedHorseMetadataBundle,
5633 strength: Strength,
5634 llama_variant: LlamaVariant,
5635}
5636impl Default for LlamaMetadataBundle {
5637 fn default() -> Self {
5638 Self {
5639 _marker: Llama,
5640 parent: AbstractChestedHorseMetadataBundle {
5641 _marker: AbstractChestedHorse,
5642 parent: AbstractHorseMetadataBundle {
5643 _marker: AbstractHorse,
5644 parent: AbstractAnimalMetadataBundle {
5645 _marker: AbstractAnimal,
5646 parent: AbstractAgeableMetadataBundle {
5647 _marker: AbstractAgeable,
5648 parent: AbstractCreatureMetadataBundle {
5649 _marker: AbstractCreature,
5650 parent: AbstractInsentientMetadataBundle {
5651 _marker: AbstractInsentient,
5652 parent: AbstractLivingMetadataBundle {
5653 _marker: AbstractLiving,
5654 parent: AbstractEntityMetadataBundle {
5655 _marker: AbstractEntity,
5656 on_fire: OnFire(false),
5657 shift_key_down: ShiftKeyDown(false),
5658 sprinting: Sprinting(false),
5659 swimming: Swimming(false),
5660 currently_glowing: CurrentlyGlowing(false),
5661 invisible: Invisible(false),
5662 fall_flying: FallFlying(false),
5663 air_supply: AirSupply(Default::default()),
5664 custom_name: CustomName(Default::default()),
5665 custom_name_visible: CustomNameVisible(
5666 Default::default(),
5667 ),
5668 silent: Silent(Default::default()),
5669 no_gravity: NoGravity(Default::default()),
5670 pose: Pose::default(),
5671 ticks_frozen: TicksFrozen(Default::default()),
5672 },
5673 auto_spin_attack: AutoSpinAttack(false),
5674 abstract_living_using_item: AbstractLivingUsingItem(false),
5675 health: Health(1.0),
5676 effect_particles: EffectParticles(Default::default()),
5677 effect_ambience: EffectAmbience(false),
5678 arrow_count: ArrowCount(0),
5679 stinger_count: StingerCount(0),
5680 sleeping_pos: SleepingPos(None),
5681 },
5682 no_ai: NoAi(false),
5683 left_handed: LeftHanded(false),
5684 aggressive: Aggressive(false),
5685 },
5686 },
5687 abstract_ageable_baby: AbstractAgeableBaby(false),
5688 },
5689 },
5690 tamed: Tamed(false),
5691 eating: Eating(false),
5692 abstract_horse_standing: AbstractHorseStanding(false),
5693 bred: Bred(false),
5694 },
5695 chest: Chest(false),
5696 },
5697 strength: Strength(0),
5698 llama_variant: LlamaVariant(0),
5699 }
5700 }
5701}
5702
5703#[derive(Component)]
5704pub struct LlamaSpit;
5705impl LlamaSpit {
5706 pub fn apply_metadata(
5707 entity: &mut bevy_ecs::system::EntityCommands,
5708 d: EntityDataItem,
5709 ) -> Result<(), UpdateMetadataError> {
5710 match d.index {
5711 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
5712 _ => {}
5713 }
5714 Ok(())
5715 }
5716}
5717
5718#[derive(Bundle)]
5719pub struct LlamaSpitMetadataBundle {
5720 _marker: LlamaSpit,
5721 parent: AbstractEntityMetadataBundle,
5722}
5723impl Default for LlamaSpitMetadataBundle {
5724 fn default() -> Self {
5725 Self {
5726 _marker: LlamaSpit,
5727 parent: AbstractEntityMetadataBundle {
5728 _marker: AbstractEntity,
5729 on_fire: OnFire(false),
5730 shift_key_down: ShiftKeyDown(false),
5731 sprinting: Sprinting(false),
5732 swimming: Swimming(false),
5733 currently_glowing: CurrentlyGlowing(false),
5734 invisible: Invisible(false),
5735 fall_flying: FallFlying(false),
5736 air_supply: AirSupply(Default::default()),
5737 custom_name: CustomName(Default::default()),
5738 custom_name_visible: CustomNameVisible(Default::default()),
5739 silent: Silent(Default::default()),
5740 no_gravity: NoGravity(Default::default()),
5741 pose: Pose::default(),
5742 ticks_frozen: TicksFrozen(Default::default()),
5743 },
5744 }
5745 }
5746}
5747
5748#[derive(Component, Deref, DerefMut, Clone)]
5749pub struct SlimeSize(pub i32);
5750#[derive(Component)]
5751pub struct MagmaCube;
5752impl MagmaCube {
5753 pub fn apply_metadata(
5754 entity: &mut bevy_ecs::system::EntityCommands,
5755 d: EntityDataItem,
5756 ) -> Result<(), UpdateMetadataError> {
5757 match d.index {
5758 0..=16 => Slime::apply_metadata(entity, d)?,
5759 _ => {}
5760 }
5761 Ok(())
5762 }
5763}
5764
5765#[derive(Bundle)]
5766pub struct MagmaCubeMetadataBundle {
5767 _marker: MagmaCube,
5768 parent: SlimeMetadataBundle,
5769}
5770impl Default for MagmaCubeMetadataBundle {
5771 fn default() -> Self {
5772 Self {
5773 _marker: MagmaCube,
5774 parent: SlimeMetadataBundle {
5775 _marker: Slime,
5776 parent: AbstractInsentientMetadataBundle {
5777 _marker: AbstractInsentient,
5778 parent: AbstractLivingMetadataBundle {
5779 _marker: AbstractLiving,
5780 parent: AbstractEntityMetadataBundle {
5781 _marker: AbstractEntity,
5782 on_fire: OnFire(false),
5783 shift_key_down: ShiftKeyDown(false),
5784 sprinting: Sprinting(false),
5785 swimming: Swimming(false),
5786 currently_glowing: CurrentlyGlowing(false),
5787 invisible: Invisible(false),
5788 fall_flying: FallFlying(false),
5789 air_supply: AirSupply(Default::default()),
5790 custom_name: CustomName(Default::default()),
5791 custom_name_visible: CustomNameVisible(Default::default()),
5792 silent: Silent(Default::default()),
5793 no_gravity: NoGravity(Default::default()),
5794 pose: Pose::default(),
5795 ticks_frozen: TicksFrozen(Default::default()),
5796 },
5797 auto_spin_attack: AutoSpinAttack(false),
5798 abstract_living_using_item: AbstractLivingUsingItem(false),
5799 health: Health(1.0),
5800 effect_particles: EffectParticles(Default::default()),
5801 effect_ambience: EffectAmbience(false),
5802 arrow_count: ArrowCount(0),
5803 stinger_count: StingerCount(0),
5804 sleeping_pos: SleepingPos(None),
5805 },
5806 no_ai: NoAi(false),
5807 left_handed: LeftHanded(false),
5808 aggressive: Aggressive(false),
5809 },
5810 slime_size: SlimeSize(1),
5811 },
5812 }
5813 }
5814}
5815
5816#[derive(Component)]
5817pub struct MangroveBoat;
5818impl MangroveBoat {
5819 pub fn apply_metadata(
5820 entity: &mut bevy_ecs::system::EntityCommands,
5821 d: EntityDataItem,
5822 ) -> Result<(), UpdateMetadataError> {
5823 match d.index {
5824 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
5825 _ => {}
5826 }
5827 Ok(())
5828 }
5829}
5830
5831#[derive(Bundle)]
5832pub struct MangroveBoatMetadataBundle {
5833 _marker: MangroveBoat,
5834 parent: AbstractBoatMetadataBundle,
5835}
5836impl Default for MangroveBoatMetadataBundle {
5837 fn default() -> Self {
5838 Self {
5839 _marker: MangroveBoat,
5840 parent: AbstractBoatMetadataBundle {
5841 _marker: AbstractBoat,
5842 parent: AbstractVehicleMetadataBundle {
5843 _marker: AbstractVehicle,
5844 parent: AbstractEntityMetadataBundle {
5845 _marker: AbstractEntity,
5846 on_fire: OnFire(false),
5847 shift_key_down: ShiftKeyDown(false),
5848 sprinting: Sprinting(false),
5849 swimming: Swimming(false),
5850 currently_glowing: CurrentlyGlowing(false),
5851 invisible: Invisible(false),
5852 fall_flying: FallFlying(false),
5853 air_supply: AirSupply(Default::default()),
5854 custom_name: CustomName(Default::default()),
5855 custom_name_visible: CustomNameVisible(Default::default()),
5856 silent: Silent(Default::default()),
5857 no_gravity: NoGravity(Default::default()),
5858 pose: Pose::default(),
5859 ticks_frozen: TicksFrozen(Default::default()),
5860 },
5861 hurt: Hurt(0),
5862 hurtdir: Hurtdir(1),
5863 damage: Damage(0.0),
5864 },
5865 paddle_left: PaddleLeft(false),
5866 paddle_right: PaddleRight(false),
5867 bubble_time: BubbleTime(0),
5868 },
5869 }
5870 }
5871}
5872
5873#[derive(Component)]
5874pub struct MangroveChestBoat;
5875impl MangroveChestBoat {
5876 pub fn apply_metadata(
5877 entity: &mut bevy_ecs::system::EntityCommands,
5878 d: EntityDataItem,
5879 ) -> Result<(), UpdateMetadataError> {
5880 match d.index {
5881 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
5882 _ => {}
5883 }
5884 Ok(())
5885 }
5886}
5887
5888#[derive(Bundle)]
5889pub struct MangroveChestBoatMetadataBundle {
5890 _marker: MangroveChestBoat,
5891 parent: AbstractBoatMetadataBundle,
5892}
5893impl Default for MangroveChestBoatMetadataBundle {
5894 fn default() -> Self {
5895 Self {
5896 _marker: MangroveChestBoat,
5897 parent: AbstractBoatMetadataBundle {
5898 _marker: AbstractBoat,
5899 parent: AbstractVehicleMetadataBundle {
5900 _marker: AbstractVehicle,
5901 parent: AbstractEntityMetadataBundle {
5902 _marker: AbstractEntity,
5903 on_fire: OnFire(false),
5904 shift_key_down: ShiftKeyDown(false),
5905 sprinting: Sprinting(false),
5906 swimming: Swimming(false),
5907 currently_glowing: CurrentlyGlowing(false),
5908 invisible: Invisible(false),
5909 fall_flying: FallFlying(false),
5910 air_supply: AirSupply(Default::default()),
5911 custom_name: CustomName(Default::default()),
5912 custom_name_visible: CustomNameVisible(Default::default()),
5913 silent: Silent(Default::default()),
5914 no_gravity: NoGravity(Default::default()),
5915 pose: Pose::default(),
5916 ticks_frozen: TicksFrozen(Default::default()),
5917 },
5918 hurt: Hurt(0),
5919 hurtdir: Hurtdir(1),
5920 damage: Damage(0.0),
5921 },
5922 paddle_left: PaddleLeft(false),
5923 paddle_right: PaddleRight(false),
5924 bubble_time: BubbleTime(0),
5925 },
5926 }
5927 }
5928}
5929
5930#[derive(Component)]
5931pub struct Marker;
5932impl Marker {
5933 pub fn apply_metadata(
5934 entity: &mut bevy_ecs::system::EntityCommands,
5935 d: EntityDataItem,
5936 ) -> Result<(), UpdateMetadataError> {
5937 match d.index {
5938 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
5939 _ => {}
5940 }
5941 Ok(())
5942 }
5943}
5944
5945#[derive(Bundle)]
5946pub struct MarkerMetadataBundle {
5947 _marker: Marker,
5948 parent: AbstractEntityMetadataBundle,
5949}
5950impl Default for MarkerMetadataBundle {
5951 fn default() -> Self {
5952 Self {
5953 _marker: Marker,
5954 parent: AbstractEntityMetadataBundle {
5955 _marker: AbstractEntity,
5956 on_fire: OnFire(false),
5957 shift_key_down: ShiftKeyDown(false),
5958 sprinting: Sprinting(false),
5959 swimming: Swimming(false),
5960 currently_glowing: CurrentlyGlowing(false),
5961 invisible: Invisible(false),
5962 fall_flying: FallFlying(false),
5963 air_supply: AirSupply(Default::default()),
5964 custom_name: CustomName(Default::default()),
5965 custom_name_visible: CustomNameVisible(Default::default()),
5966 silent: Silent(Default::default()),
5967 no_gravity: NoGravity(Default::default()),
5968 pose: Pose::default(),
5969 ticks_frozen: TicksFrozen(Default::default()),
5970 },
5971 }
5972 }
5973}
5974
5975#[derive(Component)]
5976pub struct Minecart;
5977impl Minecart {
5978 pub fn apply_metadata(
5979 entity: &mut bevy_ecs::system::EntityCommands,
5980 d: EntityDataItem,
5981 ) -> Result<(), UpdateMetadataError> {
5982 match d.index {
5983 0..=12 => AbstractMinecart::apply_metadata(entity, d)?,
5984 _ => {}
5985 }
5986 Ok(())
5987 }
5988}
5989
5990#[derive(Bundle)]
5991pub struct MinecartMetadataBundle {
5992 _marker: Minecart,
5993 parent: AbstractMinecartMetadataBundle,
5994}
5995impl Default for MinecartMetadataBundle {
5996 fn default() -> Self {
5997 Self {
5998 _marker: Minecart,
5999 parent: AbstractMinecartMetadataBundle {
6000 _marker: AbstractMinecart,
6001 parent: AbstractVehicleMetadataBundle {
6002 _marker: AbstractVehicle,
6003 parent: AbstractEntityMetadataBundle {
6004 _marker: AbstractEntity,
6005 on_fire: OnFire(false),
6006 shift_key_down: ShiftKeyDown(false),
6007 sprinting: Sprinting(false),
6008 swimming: Swimming(false),
6009 currently_glowing: CurrentlyGlowing(false),
6010 invisible: Invisible(false),
6011 fall_flying: FallFlying(false),
6012 air_supply: AirSupply(Default::default()),
6013 custom_name: CustomName(Default::default()),
6014 custom_name_visible: CustomNameVisible(Default::default()),
6015 silent: Silent(Default::default()),
6016 no_gravity: NoGravity(Default::default()),
6017 pose: Pose::default(),
6018 ticks_frozen: TicksFrozen(Default::default()),
6019 },
6020 hurt: Hurt(0),
6021 hurtdir: Hurtdir(1),
6022 damage: Damage(0.0),
6023 },
6024 custom_display_block: CustomDisplayBlock(azalea_block::BlockState::AIR),
6025 display_offset: DisplayOffset(Default::default()),
6026 },
6027 }
6028 }
6029}
6030
6031#[derive(Component, Deref, DerefMut, Clone)]
6032pub struct MooshroomKind(pub i32);
6033#[derive(Component)]
6034pub struct Mooshroom;
6035impl Mooshroom {
6036 pub fn apply_metadata(
6037 entity: &mut bevy_ecs::system::EntityCommands,
6038 d: EntityDataItem,
6039 ) -> Result<(), UpdateMetadataError> {
6040 match d.index {
6041 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
6042 17 => {
6043 entity.insert(MooshroomKind(d.value.into_int()?));
6044 }
6045 _ => {}
6046 }
6047 Ok(())
6048 }
6049}
6050
6051#[derive(Bundle)]
6052pub struct MooshroomMetadataBundle {
6053 _marker: Mooshroom,
6054 parent: AbstractAnimalMetadataBundle,
6055 mooshroom_kind: MooshroomKind,
6056}
6057impl Default for MooshroomMetadataBundle {
6058 fn default() -> Self {
6059 Self {
6060 _marker: Mooshroom,
6061 parent: AbstractAnimalMetadataBundle {
6062 _marker: AbstractAnimal,
6063 parent: AbstractAgeableMetadataBundle {
6064 _marker: AbstractAgeable,
6065 parent: AbstractCreatureMetadataBundle {
6066 _marker: AbstractCreature,
6067 parent: AbstractInsentientMetadataBundle {
6068 _marker: AbstractInsentient,
6069 parent: AbstractLivingMetadataBundle {
6070 _marker: AbstractLiving,
6071 parent: AbstractEntityMetadataBundle {
6072 _marker: AbstractEntity,
6073 on_fire: OnFire(false),
6074 shift_key_down: ShiftKeyDown(false),
6075 sprinting: Sprinting(false),
6076 swimming: Swimming(false),
6077 currently_glowing: CurrentlyGlowing(false),
6078 invisible: Invisible(false),
6079 fall_flying: FallFlying(false),
6080 air_supply: AirSupply(Default::default()),
6081 custom_name: CustomName(Default::default()),
6082 custom_name_visible: CustomNameVisible(Default::default()),
6083 silent: Silent(Default::default()),
6084 no_gravity: NoGravity(Default::default()),
6085 pose: Pose::default(),
6086 ticks_frozen: TicksFrozen(Default::default()),
6087 },
6088 auto_spin_attack: AutoSpinAttack(false),
6089 abstract_living_using_item: AbstractLivingUsingItem(false),
6090 health: Health(1.0),
6091 effect_particles: EffectParticles(Default::default()),
6092 effect_ambience: EffectAmbience(false),
6093 arrow_count: ArrowCount(0),
6094 stinger_count: StingerCount(0),
6095 sleeping_pos: SleepingPos(None),
6096 },
6097 no_ai: NoAi(false),
6098 left_handed: LeftHanded(false),
6099 aggressive: Aggressive(false),
6100 },
6101 },
6102 abstract_ageable_baby: AbstractAgeableBaby(false),
6103 },
6104 },
6105 mooshroom_kind: MooshroomKind(Default::default()),
6106 }
6107 }
6108}
6109
6110#[derive(Component)]
6111pub struct Mule;
6112impl Mule {
6113 pub fn apply_metadata(
6114 entity: &mut bevy_ecs::system::EntityCommands,
6115 d: EntityDataItem,
6116 ) -> Result<(), UpdateMetadataError> {
6117 match d.index {
6118 0..=18 => AbstractChestedHorse::apply_metadata(entity, d)?,
6119 _ => {}
6120 }
6121 Ok(())
6122 }
6123}
6124
6125#[derive(Bundle)]
6126pub struct MuleMetadataBundle {
6127 _marker: Mule,
6128 parent: AbstractChestedHorseMetadataBundle,
6129}
6130impl Default for MuleMetadataBundle {
6131 fn default() -> Self {
6132 Self {
6133 _marker: Mule,
6134 parent: AbstractChestedHorseMetadataBundle {
6135 _marker: AbstractChestedHorse,
6136 parent: AbstractHorseMetadataBundle {
6137 _marker: AbstractHorse,
6138 parent: AbstractAnimalMetadataBundle {
6139 _marker: AbstractAnimal,
6140 parent: AbstractAgeableMetadataBundle {
6141 _marker: AbstractAgeable,
6142 parent: AbstractCreatureMetadataBundle {
6143 _marker: AbstractCreature,
6144 parent: AbstractInsentientMetadataBundle {
6145 _marker: AbstractInsentient,
6146 parent: AbstractLivingMetadataBundle {
6147 _marker: AbstractLiving,
6148 parent: AbstractEntityMetadataBundle {
6149 _marker: AbstractEntity,
6150 on_fire: OnFire(false),
6151 shift_key_down: ShiftKeyDown(false),
6152 sprinting: Sprinting(false),
6153 swimming: Swimming(false),
6154 currently_glowing: CurrentlyGlowing(false),
6155 invisible: Invisible(false),
6156 fall_flying: FallFlying(false),
6157 air_supply: AirSupply(Default::default()),
6158 custom_name: CustomName(Default::default()),
6159 custom_name_visible: CustomNameVisible(
6160 Default::default(),
6161 ),
6162 silent: Silent(Default::default()),
6163 no_gravity: NoGravity(Default::default()),
6164 pose: Pose::default(),
6165 ticks_frozen: TicksFrozen(Default::default()),
6166 },
6167 auto_spin_attack: AutoSpinAttack(false),
6168 abstract_living_using_item: AbstractLivingUsingItem(false),
6169 health: Health(1.0),
6170 effect_particles: EffectParticles(Default::default()),
6171 effect_ambience: EffectAmbience(false),
6172 arrow_count: ArrowCount(0),
6173 stinger_count: StingerCount(0),
6174 sleeping_pos: SleepingPos(None),
6175 },
6176 no_ai: NoAi(false),
6177 left_handed: LeftHanded(false),
6178 aggressive: Aggressive(false),
6179 },
6180 },
6181 abstract_ageable_baby: AbstractAgeableBaby(false),
6182 },
6183 },
6184 tamed: Tamed(false),
6185 eating: Eating(false),
6186 abstract_horse_standing: AbstractHorseStanding(false),
6187 bred: Bred(false),
6188 },
6189 chest: Chest(false),
6190 },
6191 }
6192 }
6193}
6194
6195#[derive(Component)]
6196pub struct OakBoat;
6197impl OakBoat {
6198 pub fn apply_metadata(
6199 entity: &mut bevy_ecs::system::EntityCommands,
6200 d: EntityDataItem,
6201 ) -> Result<(), UpdateMetadataError> {
6202 match d.index {
6203 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
6204 _ => {}
6205 }
6206 Ok(())
6207 }
6208}
6209
6210#[derive(Bundle)]
6211pub struct OakBoatMetadataBundle {
6212 _marker: OakBoat,
6213 parent: AbstractBoatMetadataBundle,
6214}
6215impl Default for OakBoatMetadataBundle {
6216 fn default() -> Self {
6217 Self {
6218 _marker: OakBoat,
6219 parent: AbstractBoatMetadataBundle {
6220 _marker: AbstractBoat,
6221 parent: AbstractVehicleMetadataBundle {
6222 _marker: AbstractVehicle,
6223 parent: AbstractEntityMetadataBundle {
6224 _marker: AbstractEntity,
6225 on_fire: OnFire(false),
6226 shift_key_down: ShiftKeyDown(false),
6227 sprinting: Sprinting(false),
6228 swimming: Swimming(false),
6229 currently_glowing: CurrentlyGlowing(false),
6230 invisible: Invisible(false),
6231 fall_flying: FallFlying(false),
6232 air_supply: AirSupply(Default::default()),
6233 custom_name: CustomName(Default::default()),
6234 custom_name_visible: CustomNameVisible(Default::default()),
6235 silent: Silent(Default::default()),
6236 no_gravity: NoGravity(Default::default()),
6237 pose: Pose::default(),
6238 ticks_frozen: TicksFrozen(Default::default()),
6239 },
6240 hurt: Hurt(0),
6241 hurtdir: Hurtdir(1),
6242 damage: Damage(0.0),
6243 },
6244 paddle_left: PaddleLeft(false),
6245 paddle_right: PaddleRight(false),
6246 bubble_time: BubbleTime(0),
6247 },
6248 }
6249 }
6250}
6251
6252#[derive(Component)]
6253pub struct OakChestBoat;
6254impl OakChestBoat {
6255 pub fn apply_metadata(
6256 entity: &mut bevy_ecs::system::EntityCommands,
6257 d: EntityDataItem,
6258 ) -> Result<(), UpdateMetadataError> {
6259 match d.index {
6260 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
6261 _ => {}
6262 }
6263 Ok(())
6264 }
6265}
6266
6267#[derive(Bundle)]
6268pub struct OakChestBoatMetadataBundle {
6269 _marker: OakChestBoat,
6270 parent: AbstractBoatMetadataBundle,
6271}
6272impl Default for OakChestBoatMetadataBundle {
6273 fn default() -> Self {
6274 Self {
6275 _marker: OakChestBoat,
6276 parent: AbstractBoatMetadataBundle {
6277 _marker: AbstractBoat,
6278 parent: AbstractVehicleMetadataBundle {
6279 _marker: AbstractVehicle,
6280 parent: AbstractEntityMetadataBundle {
6281 _marker: AbstractEntity,
6282 on_fire: OnFire(false),
6283 shift_key_down: ShiftKeyDown(false),
6284 sprinting: Sprinting(false),
6285 swimming: Swimming(false),
6286 currently_glowing: CurrentlyGlowing(false),
6287 invisible: Invisible(false),
6288 fall_flying: FallFlying(false),
6289 air_supply: AirSupply(Default::default()),
6290 custom_name: CustomName(Default::default()),
6291 custom_name_visible: CustomNameVisible(Default::default()),
6292 silent: Silent(Default::default()),
6293 no_gravity: NoGravity(Default::default()),
6294 pose: Pose::default(),
6295 ticks_frozen: TicksFrozen(Default::default()),
6296 },
6297 hurt: Hurt(0),
6298 hurtdir: Hurtdir(1),
6299 damage: Damage(0.0),
6300 },
6301 paddle_left: PaddleLeft(false),
6302 paddle_right: PaddleRight(false),
6303 bubble_time: BubbleTime(0),
6304 },
6305 }
6306 }
6307}
6308
6309#[derive(Component, Deref, DerefMut, Clone)]
6310pub struct Trusting(pub bool);
6311#[derive(Component)]
6312pub struct Ocelot;
6313impl Ocelot {
6314 pub fn apply_metadata(
6315 entity: &mut bevy_ecs::system::EntityCommands,
6316 d: EntityDataItem,
6317 ) -> Result<(), UpdateMetadataError> {
6318 match d.index {
6319 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
6320 17 => {
6321 entity.insert(Trusting(d.value.into_boolean()?));
6322 }
6323 _ => {}
6324 }
6325 Ok(())
6326 }
6327}
6328
6329#[derive(Bundle)]
6330pub struct OcelotMetadataBundle {
6331 _marker: Ocelot,
6332 parent: AbstractAnimalMetadataBundle,
6333 trusting: Trusting,
6334}
6335impl Default for OcelotMetadataBundle {
6336 fn default() -> Self {
6337 Self {
6338 _marker: Ocelot,
6339 parent: AbstractAnimalMetadataBundle {
6340 _marker: AbstractAnimal,
6341 parent: AbstractAgeableMetadataBundle {
6342 _marker: AbstractAgeable,
6343 parent: AbstractCreatureMetadataBundle {
6344 _marker: AbstractCreature,
6345 parent: AbstractInsentientMetadataBundle {
6346 _marker: AbstractInsentient,
6347 parent: AbstractLivingMetadataBundle {
6348 _marker: AbstractLiving,
6349 parent: AbstractEntityMetadataBundle {
6350 _marker: AbstractEntity,
6351 on_fire: OnFire(false),
6352 shift_key_down: ShiftKeyDown(false),
6353 sprinting: Sprinting(false),
6354 swimming: Swimming(false),
6355 currently_glowing: CurrentlyGlowing(false),
6356 invisible: Invisible(false),
6357 fall_flying: FallFlying(false),
6358 air_supply: AirSupply(Default::default()),
6359 custom_name: CustomName(Default::default()),
6360 custom_name_visible: CustomNameVisible(Default::default()),
6361 silent: Silent(Default::default()),
6362 no_gravity: NoGravity(Default::default()),
6363 pose: Pose::default(),
6364 ticks_frozen: TicksFrozen(Default::default()),
6365 },
6366 auto_spin_attack: AutoSpinAttack(false),
6367 abstract_living_using_item: AbstractLivingUsingItem(false),
6368 health: Health(1.0),
6369 effect_particles: EffectParticles(Default::default()),
6370 effect_ambience: EffectAmbience(false),
6371 arrow_count: ArrowCount(0),
6372 stinger_count: StingerCount(0),
6373 sleeping_pos: SleepingPos(None),
6374 },
6375 no_ai: NoAi(false),
6376 left_handed: LeftHanded(false),
6377 aggressive: Aggressive(false),
6378 },
6379 },
6380 abstract_ageable_baby: AbstractAgeableBaby(false),
6381 },
6382 },
6383 trusting: Trusting(false),
6384 }
6385 }
6386}
6387
6388#[derive(Component, Deref, DerefMut, Clone)]
6389pub struct OminousItemSpawnerItem(pub ItemStack);
6390#[derive(Component)]
6391pub struct OminousItemSpawner;
6392impl OminousItemSpawner {
6393 pub fn apply_metadata(
6394 entity: &mut bevy_ecs::system::EntityCommands,
6395 d: EntityDataItem,
6396 ) -> Result<(), UpdateMetadataError> {
6397 match d.index {
6398 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
6399 8 => {
6400 entity.insert(OminousItemSpawnerItem(d.value.into_item_stack()?));
6401 }
6402 _ => {}
6403 }
6404 Ok(())
6405 }
6406}
6407
6408#[derive(Bundle)]
6409pub struct OminousItemSpawnerMetadataBundle {
6410 _marker: OminousItemSpawner,
6411 parent: AbstractEntityMetadataBundle,
6412 ominous_item_spawner_item: OminousItemSpawnerItem,
6413}
6414impl Default for OminousItemSpawnerMetadataBundle {
6415 fn default() -> Self {
6416 Self {
6417 _marker: OminousItemSpawner,
6418 parent: AbstractEntityMetadataBundle {
6419 _marker: AbstractEntity,
6420 on_fire: OnFire(false),
6421 shift_key_down: ShiftKeyDown(false),
6422 sprinting: Sprinting(false),
6423 swimming: Swimming(false),
6424 currently_glowing: CurrentlyGlowing(false),
6425 invisible: Invisible(false),
6426 fall_flying: FallFlying(false),
6427 air_supply: AirSupply(Default::default()),
6428 custom_name: CustomName(Default::default()),
6429 custom_name_visible: CustomNameVisible(Default::default()),
6430 silent: Silent(Default::default()),
6431 no_gravity: NoGravity(Default::default()),
6432 pose: Pose::default(),
6433 ticks_frozen: TicksFrozen(Default::default()),
6434 },
6435 ominous_item_spawner_item: OminousItemSpawnerItem(Default::default()),
6436 }
6437 }
6438}
6439
6440#[derive(Component, Deref, DerefMut, Clone)]
6441pub struct PaintingDirection(pub Direction);
6442#[derive(Component, Deref, DerefMut, Clone)]
6443pub struct PaintingVariant(pub azalea_registry::PaintingVariant);
6444#[derive(Component)]
6445pub struct Painting;
6446impl Painting {
6447 pub fn apply_metadata(
6448 entity: &mut bevy_ecs::system::EntityCommands,
6449 d: EntityDataItem,
6450 ) -> Result<(), UpdateMetadataError> {
6451 match d.index {
6452 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
6453 8 => {
6454 entity.insert(PaintingDirection(d.value.into_direction()?));
6455 }
6456 9 => {
6457 entity.insert(PaintingVariant(d.value.into_painting_variant()?));
6458 }
6459 _ => {}
6460 }
6461 Ok(())
6462 }
6463}
6464
6465#[derive(Bundle)]
6466pub struct PaintingMetadataBundle {
6467 _marker: Painting,
6468 parent: AbstractEntityMetadataBundle,
6469 painting_direction: PaintingDirection,
6470 painting_variant: PaintingVariant,
6471}
6472impl Default for PaintingMetadataBundle {
6473 fn default() -> Self {
6474 Self {
6475 _marker: Painting,
6476 parent: AbstractEntityMetadataBundle {
6477 _marker: AbstractEntity,
6478 on_fire: OnFire(false),
6479 shift_key_down: ShiftKeyDown(false),
6480 sprinting: Sprinting(false),
6481 swimming: Swimming(false),
6482 currently_glowing: CurrentlyGlowing(false),
6483 invisible: Invisible(false),
6484 fall_flying: FallFlying(false),
6485 air_supply: AirSupply(Default::default()),
6486 custom_name: CustomName(Default::default()),
6487 custom_name_visible: CustomNameVisible(Default::default()),
6488 silent: Silent(Default::default()),
6489 no_gravity: NoGravity(Default::default()),
6490 pose: Pose::default(),
6491 ticks_frozen: TicksFrozen(Default::default()),
6492 },
6493 painting_direction: PaintingDirection(Default::default()),
6494 painting_variant: PaintingVariant(azalea_registry::PaintingVariant::new_raw(0)),
6495 }
6496 }
6497}
6498
6499#[derive(Component)]
6500pub struct PaleOakBoat;
6501impl PaleOakBoat {
6502 pub fn apply_metadata(
6503 entity: &mut bevy_ecs::system::EntityCommands,
6504 d: EntityDataItem,
6505 ) -> Result<(), UpdateMetadataError> {
6506 match d.index {
6507 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
6508 _ => {}
6509 }
6510 Ok(())
6511 }
6512}
6513
6514#[derive(Bundle)]
6515pub struct PaleOakBoatMetadataBundle {
6516 _marker: PaleOakBoat,
6517 parent: AbstractBoatMetadataBundle,
6518}
6519impl Default for PaleOakBoatMetadataBundle {
6520 fn default() -> Self {
6521 Self {
6522 _marker: PaleOakBoat,
6523 parent: AbstractBoatMetadataBundle {
6524 _marker: AbstractBoat,
6525 parent: AbstractVehicleMetadataBundle {
6526 _marker: AbstractVehicle,
6527 parent: AbstractEntityMetadataBundle {
6528 _marker: AbstractEntity,
6529 on_fire: OnFire(false),
6530 shift_key_down: ShiftKeyDown(false),
6531 sprinting: Sprinting(false),
6532 swimming: Swimming(false),
6533 currently_glowing: CurrentlyGlowing(false),
6534 invisible: Invisible(false),
6535 fall_flying: FallFlying(false),
6536 air_supply: AirSupply(Default::default()),
6537 custom_name: CustomName(Default::default()),
6538 custom_name_visible: CustomNameVisible(Default::default()),
6539 silent: Silent(Default::default()),
6540 no_gravity: NoGravity(Default::default()),
6541 pose: Pose::default(),
6542 ticks_frozen: TicksFrozen(Default::default()),
6543 },
6544 hurt: Hurt(0),
6545 hurtdir: Hurtdir(1),
6546 damage: Damage(0.0),
6547 },
6548 paddle_left: PaddleLeft(false),
6549 paddle_right: PaddleRight(false),
6550 bubble_time: BubbleTime(0),
6551 },
6552 }
6553 }
6554}
6555
6556#[derive(Component)]
6557pub struct PaleOakChestBoat;
6558impl PaleOakChestBoat {
6559 pub fn apply_metadata(
6560 entity: &mut bevy_ecs::system::EntityCommands,
6561 d: EntityDataItem,
6562 ) -> Result<(), UpdateMetadataError> {
6563 match d.index {
6564 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
6565 _ => {}
6566 }
6567 Ok(())
6568 }
6569}
6570
6571#[derive(Bundle)]
6572pub struct PaleOakChestBoatMetadataBundle {
6573 _marker: PaleOakChestBoat,
6574 parent: AbstractBoatMetadataBundle,
6575}
6576impl Default for PaleOakChestBoatMetadataBundle {
6577 fn default() -> Self {
6578 Self {
6579 _marker: PaleOakChestBoat,
6580 parent: AbstractBoatMetadataBundle {
6581 _marker: AbstractBoat,
6582 parent: AbstractVehicleMetadataBundle {
6583 _marker: AbstractVehicle,
6584 parent: AbstractEntityMetadataBundle {
6585 _marker: AbstractEntity,
6586 on_fire: OnFire(false),
6587 shift_key_down: ShiftKeyDown(false),
6588 sprinting: Sprinting(false),
6589 swimming: Swimming(false),
6590 currently_glowing: CurrentlyGlowing(false),
6591 invisible: Invisible(false),
6592 fall_flying: FallFlying(false),
6593 air_supply: AirSupply(Default::default()),
6594 custom_name: CustomName(Default::default()),
6595 custom_name_visible: CustomNameVisible(Default::default()),
6596 silent: Silent(Default::default()),
6597 no_gravity: NoGravity(Default::default()),
6598 pose: Pose::default(),
6599 ticks_frozen: TicksFrozen(Default::default()),
6600 },
6601 hurt: Hurt(0),
6602 hurtdir: Hurtdir(1),
6603 damage: Damage(0.0),
6604 },
6605 paddle_left: PaddleLeft(false),
6606 paddle_right: PaddleRight(false),
6607 bubble_time: BubbleTime(0),
6608 },
6609 }
6610 }
6611}
6612
6613#[derive(Component, Deref, DerefMut, Clone)]
6614pub struct PandaUnhappyCounter(pub i32);
6615#[derive(Component, Deref, DerefMut, Clone)]
6616pub struct SneezeCounter(pub i32);
6617#[derive(Component, Deref, DerefMut, Clone)]
6618pub struct EatCounter(pub i32);
6619#[derive(Component, Deref, DerefMut, Clone, Copy)]
6620pub struct Sneezing(pub bool);
6621#[derive(Component, Deref, DerefMut, Clone, Copy)]
6622pub struct PandaSitting(pub bool);
6623#[derive(Component, Deref, DerefMut, Clone, Copy)]
6624pub struct OnBack(pub bool);
6625#[derive(Component, Deref, DerefMut, Clone, Copy)]
6626pub struct PandaRolling(pub bool);
6627#[derive(Component, Deref, DerefMut, Clone)]
6628pub struct HiddenGene(pub u8);
6629#[derive(Component, Deref, DerefMut, Clone)]
6630pub struct PandaFlags(pub u8);
6631#[derive(Component)]
6632pub struct Panda;
6633impl Panda {
6634 pub fn apply_metadata(
6635 entity: &mut bevy_ecs::system::EntityCommands,
6636 d: EntityDataItem,
6637 ) -> Result<(), UpdateMetadataError> {
6638 match d.index {
6639 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
6640 17 => {
6641 entity.insert(PandaUnhappyCounter(d.value.into_int()?));
6642 }
6643 18 => {
6644 entity.insert(SneezeCounter(d.value.into_int()?));
6645 }
6646 19 => {
6647 entity.insert(EatCounter(d.value.into_int()?));
6648 }
6649 20 => {
6650 let bitfield = d.value.into_byte()?;
6651 entity.insert(Sneezing(bitfield & 0x2 != 0));
6652 entity.insert(PandaSitting(bitfield & 0x8 != 0));
6653 entity.insert(OnBack(bitfield & 0x10 != 0));
6654 entity.insert(PandaRolling(bitfield & 0x4 != 0));
6655 }
6656 21 => {
6657 entity.insert(HiddenGene(d.value.into_byte()?));
6658 }
6659 22 => {
6660 entity.insert(PandaFlags(d.value.into_byte()?));
6661 }
6662 _ => {}
6663 }
6664 Ok(())
6665 }
6666}
6667
6668#[derive(Bundle)]
6669pub struct PandaMetadataBundle {
6670 _marker: Panda,
6671 parent: AbstractAnimalMetadataBundle,
6672 panda_unhappy_counter: PandaUnhappyCounter,
6673 sneeze_counter: SneezeCounter,
6674 eat_counter: EatCounter,
6675 sneezing: Sneezing,
6676 panda_sitting: PandaSitting,
6677 on_back: OnBack,
6678 panda_rolling: PandaRolling,
6679 hidden_gene: HiddenGene,
6680 panda_flags: PandaFlags,
6681}
6682impl Default for PandaMetadataBundle {
6683 fn default() -> Self {
6684 Self {
6685 _marker: Panda,
6686 parent: AbstractAnimalMetadataBundle {
6687 _marker: AbstractAnimal,
6688 parent: AbstractAgeableMetadataBundle {
6689 _marker: AbstractAgeable,
6690 parent: AbstractCreatureMetadataBundle {
6691 _marker: AbstractCreature,
6692 parent: AbstractInsentientMetadataBundle {
6693 _marker: AbstractInsentient,
6694 parent: AbstractLivingMetadataBundle {
6695 _marker: AbstractLiving,
6696 parent: AbstractEntityMetadataBundle {
6697 _marker: AbstractEntity,
6698 on_fire: OnFire(false),
6699 shift_key_down: ShiftKeyDown(false),
6700 sprinting: Sprinting(false),
6701 swimming: Swimming(false),
6702 currently_glowing: CurrentlyGlowing(false),
6703 invisible: Invisible(false),
6704 fall_flying: FallFlying(false),
6705 air_supply: AirSupply(Default::default()),
6706 custom_name: CustomName(Default::default()),
6707 custom_name_visible: CustomNameVisible(Default::default()),
6708 silent: Silent(Default::default()),
6709 no_gravity: NoGravity(Default::default()),
6710 pose: Pose::default(),
6711 ticks_frozen: TicksFrozen(Default::default()),
6712 },
6713 auto_spin_attack: AutoSpinAttack(false),
6714 abstract_living_using_item: AbstractLivingUsingItem(false),
6715 health: Health(1.0),
6716 effect_particles: EffectParticles(Default::default()),
6717 effect_ambience: EffectAmbience(false),
6718 arrow_count: ArrowCount(0),
6719 stinger_count: StingerCount(0),
6720 sleeping_pos: SleepingPos(None),
6721 },
6722 no_ai: NoAi(false),
6723 left_handed: LeftHanded(false),
6724 aggressive: Aggressive(false),
6725 },
6726 },
6727 abstract_ageable_baby: AbstractAgeableBaby(false),
6728 },
6729 },
6730 panda_unhappy_counter: PandaUnhappyCounter(0),
6731 sneeze_counter: SneezeCounter(0),
6732 eat_counter: EatCounter(0),
6733 sneezing: Sneezing(false),
6734 panda_sitting: PandaSitting(false),
6735 on_back: OnBack(false),
6736 panda_rolling: PandaRolling(false),
6737 hidden_gene: HiddenGene(0),
6738 panda_flags: PandaFlags(0),
6739 }
6740 }
6741}
6742
6743#[derive(Component, Deref, DerefMut, Clone)]
6744pub struct ParrotVariant(pub i32);
6745#[derive(Component)]
6746pub struct Parrot;
6747impl Parrot {
6748 pub fn apply_metadata(
6749 entity: &mut bevy_ecs::system::EntityCommands,
6750 d: EntityDataItem,
6751 ) -> Result<(), UpdateMetadataError> {
6752 match d.index {
6753 0..=18 => AbstractTameable::apply_metadata(entity, d)?,
6754 19 => {
6755 entity.insert(ParrotVariant(d.value.into_int()?));
6756 }
6757 _ => {}
6758 }
6759 Ok(())
6760 }
6761}
6762
6763#[derive(Bundle)]
6764pub struct ParrotMetadataBundle {
6765 _marker: Parrot,
6766 parent: AbstractTameableMetadataBundle,
6767 parrot_variant: ParrotVariant,
6768}
6769impl Default for ParrotMetadataBundle {
6770 fn default() -> Self {
6771 Self {
6772 _marker: Parrot,
6773 parent: AbstractTameableMetadataBundle {
6774 _marker: AbstractTameable,
6775 parent: AbstractAnimalMetadataBundle {
6776 _marker: AbstractAnimal,
6777 parent: AbstractAgeableMetadataBundle {
6778 _marker: AbstractAgeable,
6779 parent: AbstractCreatureMetadataBundle {
6780 _marker: AbstractCreature,
6781 parent: AbstractInsentientMetadataBundle {
6782 _marker: AbstractInsentient,
6783 parent: AbstractLivingMetadataBundle {
6784 _marker: AbstractLiving,
6785 parent: AbstractEntityMetadataBundle {
6786 _marker: AbstractEntity,
6787 on_fire: OnFire(false),
6788 shift_key_down: ShiftKeyDown(false),
6789 sprinting: Sprinting(false),
6790 swimming: Swimming(false),
6791 currently_glowing: CurrentlyGlowing(false),
6792 invisible: Invisible(false),
6793 fall_flying: FallFlying(false),
6794 air_supply: AirSupply(Default::default()),
6795 custom_name: CustomName(Default::default()),
6796 custom_name_visible: CustomNameVisible(Default::default()),
6797 silent: Silent(Default::default()),
6798 no_gravity: NoGravity(Default::default()),
6799 pose: Pose::default(),
6800 ticks_frozen: TicksFrozen(Default::default()),
6801 },
6802 auto_spin_attack: AutoSpinAttack(false),
6803 abstract_living_using_item: AbstractLivingUsingItem(false),
6804 health: Health(1.0),
6805 effect_particles: EffectParticles(Default::default()),
6806 effect_ambience: EffectAmbience(false),
6807 arrow_count: ArrowCount(0),
6808 stinger_count: StingerCount(0),
6809 sleeping_pos: SleepingPos(None),
6810 },
6811 no_ai: NoAi(false),
6812 left_handed: LeftHanded(false),
6813 aggressive: Aggressive(false),
6814 },
6815 },
6816 abstract_ageable_baby: AbstractAgeableBaby(false),
6817 },
6818 },
6819 tame: Tame(false),
6820 in_sitting_pose: InSittingPose(false),
6821 owneruuid: Owneruuid(None),
6822 },
6823 parrot_variant: ParrotVariant(Default::default()),
6824 }
6825 }
6826}
6827
6828#[derive(Component, Deref, DerefMut, Clone)]
6829pub struct PhantomSize(pub i32);
6830#[derive(Component)]
6831pub struct Phantom;
6832impl Phantom {
6833 pub fn apply_metadata(
6834 entity: &mut bevy_ecs::system::EntityCommands,
6835 d: EntityDataItem,
6836 ) -> Result<(), UpdateMetadataError> {
6837 match d.index {
6838 0..=15 => AbstractInsentient::apply_metadata(entity, d)?,
6839 16 => {
6840 entity.insert(PhantomSize(d.value.into_int()?));
6841 }
6842 _ => {}
6843 }
6844 Ok(())
6845 }
6846}
6847
6848#[derive(Bundle)]
6849pub struct PhantomMetadataBundle {
6850 _marker: Phantom,
6851 parent: AbstractInsentientMetadataBundle,
6852 phantom_size: PhantomSize,
6853}
6854impl Default for PhantomMetadataBundle {
6855 fn default() -> Self {
6856 Self {
6857 _marker: Phantom,
6858 parent: AbstractInsentientMetadataBundle {
6859 _marker: AbstractInsentient,
6860 parent: AbstractLivingMetadataBundle {
6861 _marker: AbstractLiving,
6862 parent: AbstractEntityMetadataBundle {
6863 _marker: AbstractEntity,
6864 on_fire: OnFire(false),
6865 shift_key_down: ShiftKeyDown(false),
6866 sprinting: Sprinting(false),
6867 swimming: Swimming(false),
6868 currently_glowing: CurrentlyGlowing(false),
6869 invisible: Invisible(false),
6870 fall_flying: FallFlying(false),
6871 air_supply: AirSupply(Default::default()),
6872 custom_name: CustomName(Default::default()),
6873 custom_name_visible: CustomNameVisible(Default::default()),
6874 silent: Silent(Default::default()),
6875 no_gravity: NoGravity(Default::default()),
6876 pose: Pose::default(),
6877 ticks_frozen: TicksFrozen(Default::default()),
6878 },
6879 auto_spin_attack: AutoSpinAttack(false),
6880 abstract_living_using_item: AbstractLivingUsingItem(false),
6881 health: Health(1.0),
6882 effect_particles: EffectParticles(Default::default()),
6883 effect_ambience: EffectAmbience(false),
6884 arrow_count: ArrowCount(0),
6885 stinger_count: StingerCount(0),
6886 sleeping_pos: SleepingPos(None),
6887 },
6888 no_ai: NoAi(false),
6889 left_handed: LeftHanded(false),
6890 aggressive: Aggressive(false),
6891 },
6892 phantom_size: PhantomSize(0),
6893 }
6894 }
6895}
6896
6897#[derive(Component, Deref, DerefMut, Clone)]
6898pub struct PigBoostTime(pub i32);
6899#[derive(Component, Deref, DerefMut, Clone)]
6900pub struct PigVariant(pub azalea_registry::FrogVariant);
6901#[derive(Component)]
6902pub struct Pig;
6903impl Pig {
6904 pub fn apply_metadata(
6905 entity: &mut bevy_ecs::system::EntityCommands,
6906 d: EntityDataItem,
6907 ) -> Result<(), UpdateMetadataError> {
6908 match d.index {
6909 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
6910 17 => {
6911 entity.insert(PigBoostTime(d.value.into_int()?));
6912 }
6913 18 => {
6914 entity.insert(PigVariant(d.value.into_frog_variant()?));
6915 }
6916 _ => {}
6917 }
6918 Ok(())
6919 }
6920}
6921
6922#[derive(Bundle)]
6923pub struct PigMetadataBundle {
6924 _marker: Pig,
6925 parent: AbstractAnimalMetadataBundle,
6926 pig_boost_time: PigBoostTime,
6927 pig_variant: PigVariant,
6928}
6929impl Default for PigMetadataBundle {
6930 fn default() -> Self {
6931 Self {
6932 _marker: Pig,
6933 parent: AbstractAnimalMetadataBundle {
6934 _marker: AbstractAnimal,
6935 parent: AbstractAgeableMetadataBundle {
6936 _marker: AbstractAgeable,
6937 parent: AbstractCreatureMetadataBundle {
6938 _marker: AbstractCreature,
6939 parent: AbstractInsentientMetadataBundle {
6940 _marker: AbstractInsentient,
6941 parent: AbstractLivingMetadataBundle {
6942 _marker: AbstractLiving,
6943 parent: AbstractEntityMetadataBundle {
6944 _marker: AbstractEntity,
6945 on_fire: OnFire(false),
6946 shift_key_down: ShiftKeyDown(false),
6947 sprinting: Sprinting(false),
6948 swimming: Swimming(false),
6949 currently_glowing: CurrentlyGlowing(false),
6950 invisible: Invisible(false),
6951 fall_flying: FallFlying(false),
6952 air_supply: AirSupply(Default::default()),
6953 custom_name: CustomName(Default::default()),
6954 custom_name_visible: CustomNameVisible(Default::default()),
6955 silent: Silent(Default::default()),
6956 no_gravity: NoGravity(Default::default()),
6957 pose: Pose::default(),
6958 ticks_frozen: TicksFrozen(Default::default()),
6959 },
6960 auto_spin_attack: AutoSpinAttack(false),
6961 abstract_living_using_item: AbstractLivingUsingItem(false),
6962 health: Health(1.0),
6963 effect_particles: EffectParticles(Default::default()),
6964 effect_ambience: EffectAmbience(false),
6965 arrow_count: ArrowCount(0),
6966 stinger_count: StingerCount(0),
6967 sleeping_pos: SleepingPos(None),
6968 },
6969 no_ai: NoAi(false),
6970 left_handed: LeftHanded(false),
6971 aggressive: Aggressive(false),
6972 },
6973 },
6974 abstract_ageable_baby: AbstractAgeableBaby(false),
6975 },
6976 },
6977 pig_boost_time: PigBoostTime(0),
6978 pig_variant: PigVariant(azalea_registry::FrogVariant::new_raw(0)),
6979 }
6980 }
6981}
6982
6983#[derive(Component, Deref, DerefMut, Clone)]
6984pub struct AbstractPiglinImmuneToZombification(pub bool);
6985#[derive(Component, Deref, DerefMut, Clone)]
6986pub struct PiglinBaby(pub bool);
6987#[derive(Component, Deref, DerefMut, Clone)]
6988pub struct PiglinIsChargingCrossbow(pub bool);
6989#[derive(Component, Deref, DerefMut, Clone)]
6990pub struct IsDancing(pub bool);
6991#[derive(Component)]
6992pub struct Piglin;
6993impl Piglin {
6994 pub fn apply_metadata(
6995 entity: &mut bevy_ecs::system::EntityCommands,
6996 d: EntityDataItem,
6997 ) -> Result<(), UpdateMetadataError> {
6998 match d.index {
6999 0..=16 => AbstractPiglin::apply_metadata(entity, d)?,
7000 17 => {
7001 entity.insert(PiglinBaby(d.value.into_boolean()?));
7002 }
7003 18 => {
7004 entity.insert(PiglinIsChargingCrossbow(d.value.into_boolean()?));
7005 }
7006 19 => {
7007 entity.insert(IsDancing(d.value.into_boolean()?));
7008 }
7009 _ => {}
7010 }
7011 Ok(())
7012 }
7013}
7014
7015#[derive(Bundle)]
7016pub struct PiglinMetadataBundle {
7017 _marker: Piglin,
7018 parent: AbstractPiglinMetadataBundle,
7019 piglin_baby: PiglinBaby,
7020 piglin_is_charging_crossbow: PiglinIsChargingCrossbow,
7021 is_dancing: IsDancing,
7022}
7023impl Default for PiglinMetadataBundle {
7024 fn default() -> Self {
7025 Self {
7026 _marker: Piglin,
7027 parent: AbstractPiglinMetadataBundle {
7028 _marker: AbstractPiglin,
7029 parent: AbstractMonsterMetadataBundle {
7030 _marker: AbstractMonster,
7031 parent: AbstractCreatureMetadataBundle {
7032 _marker: AbstractCreature,
7033 parent: AbstractInsentientMetadataBundle {
7034 _marker: AbstractInsentient,
7035 parent: AbstractLivingMetadataBundle {
7036 _marker: AbstractLiving,
7037 parent: AbstractEntityMetadataBundle {
7038 _marker: AbstractEntity,
7039 on_fire: OnFire(false),
7040 shift_key_down: ShiftKeyDown(false),
7041 sprinting: Sprinting(false),
7042 swimming: Swimming(false),
7043 currently_glowing: CurrentlyGlowing(false),
7044 invisible: Invisible(false),
7045 fall_flying: FallFlying(false),
7046 air_supply: AirSupply(Default::default()),
7047 custom_name: CustomName(Default::default()),
7048 custom_name_visible: CustomNameVisible(Default::default()),
7049 silent: Silent(Default::default()),
7050 no_gravity: NoGravity(Default::default()),
7051 pose: Pose::default(),
7052 ticks_frozen: TicksFrozen(Default::default()),
7053 },
7054 auto_spin_attack: AutoSpinAttack(false),
7055 abstract_living_using_item: AbstractLivingUsingItem(false),
7056 health: Health(1.0),
7057 effect_particles: EffectParticles(Default::default()),
7058 effect_ambience: EffectAmbience(false),
7059 arrow_count: ArrowCount(0),
7060 stinger_count: StingerCount(0),
7061 sleeping_pos: SleepingPos(None),
7062 },
7063 no_ai: NoAi(false),
7064 left_handed: LeftHanded(false),
7065 aggressive: Aggressive(false),
7066 },
7067 },
7068 },
7069 abstract_piglin_immune_to_zombification: AbstractPiglinImmuneToZombification(false),
7070 },
7071 piglin_baby: PiglinBaby(false),
7072 piglin_is_charging_crossbow: PiglinIsChargingCrossbow(false),
7073 is_dancing: IsDancing(false),
7074 }
7075 }
7076}
7077
7078#[derive(Component)]
7079pub struct PiglinBrute;
7080impl PiglinBrute {
7081 pub fn apply_metadata(
7082 entity: &mut bevy_ecs::system::EntityCommands,
7083 d: EntityDataItem,
7084 ) -> Result<(), UpdateMetadataError> {
7085 match d.index {
7086 0..=16 => AbstractPiglin::apply_metadata(entity, d)?,
7087 _ => {}
7088 }
7089 Ok(())
7090 }
7091}
7092
7093#[derive(Bundle)]
7094pub struct PiglinBruteMetadataBundle {
7095 _marker: PiglinBrute,
7096 parent: AbstractPiglinMetadataBundle,
7097}
7098impl Default for PiglinBruteMetadataBundle {
7099 fn default() -> Self {
7100 Self {
7101 _marker: PiglinBrute,
7102 parent: AbstractPiglinMetadataBundle {
7103 _marker: AbstractPiglin,
7104 parent: AbstractMonsterMetadataBundle {
7105 _marker: AbstractMonster,
7106 parent: AbstractCreatureMetadataBundle {
7107 _marker: AbstractCreature,
7108 parent: AbstractInsentientMetadataBundle {
7109 _marker: AbstractInsentient,
7110 parent: AbstractLivingMetadataBundle {
7111 _marker: AbstractLiving,
7112 parent: AbstractEntityMetadataBundle {
7113 _marker: AbstractEntity,
7114 on_fire: OnFire(false),
7115 shift_key_down: ShiftKeyDown(false),
7116 sprinting: Sprinting(false),
7117 swimming: Swimming(false),
7118 currently_glowing: CurrentlyGlowing(false),
7119 invisible: Invisible(false),
7120 fall_flying: FallFlying(false),
7121 air_supply: AirSupply(Default::default()),
7122 custom_name: CustomName(Default::default()),
7123 custom_name_visible: CustomNameVisible(Default::default()),
7124 silent: Silent(Default::default()),
7125 no_gravity: NoGravity(Default::default()),
7126 pose: Pose::default(),
7127 ticks_frozen: TicksFrozen(Default::default()),
7128 },
7129 auto_spin_attack: AutoSpinAttack(false),
7130 abstract_living_using_item: AbstractLivingUsingItem(false),
7131 health: Health(1.0),
7132 effect_particles: EffectParticles(Default::default()),
7133 effect_ambience: EffectAmbience(false),
7134 arrow_count: ArrowCount(0),
7135 stinger_count: StingerCount(0),
7136 sleeping_pos: SleepingPos(None),
7137 },
7138 no_ai: NoAi(false),
7139 left_handed: LeftHanded(false),
7140 aggressive: Aggressive(false),
7141 },
7142 },
7143 },
7144 abstract_piglin_immune_to_zombification: AbstractPiglinImmuneToZombification(false),
7145 },
7146 }
7147 }
7148}
7149
7150#[derive(Component, Deref, DerefMut, Clone)]
7151pub struct PillagerIsChargingCrossbow(pub bool);
7152#[derive(Component)]
7153pub struct Pillager;
7154impl Pillager {
7155 pub fn apply_metadata(
7156 entity: &mut bevy_ecs::system::EntityCommands,
7157 d: EntityDataItem,
7158 ) -> Result<(), UpdateMetadataError> {
7159 match d.index {
7160 0..=16 => AbstractRaider::apply_metadata(entity, d)?,
7161 17 => {
7162 entity.insert(PillagerIsChargingCrossbow(d.value.into_boolean()?));
7163 }
7164 _ => {}
7165 }
7166 Ok(())
7167 }
7168}
7169
7170#[derive(Bundle)]
7171pub struct PillagerMetadataBundle {
7172 _marker: Pillager,
7173 parent: AbstractRaiderMetadataBundle,
7174 pillager_is_charging_crossbow: PillagerIsChargingCrossbow,
7175}
7176impl Default for PillagerMetadataBundle {
7177 fn default() -> Self {
7178 Self {
7179 _marker: Pillager,
7180 parent: AbstractRaiderMetadataBundle {
7181 _marker: AbstractRaider,
7182 parent: AbstractMonsterMetadataBundle {
7183 _marker: AbstractMonster,
7184 parent: AbstractCreatureMetadataBundle {
7185 _marker: AbstractCreature,
7186 parent: AbstractInsentientMetadataBundle {
7187 _marker: AbstractInsentient,
7188 parent: AbstractLivingMetadataBundle {
7189 _marker: AbstractLiving,
7190 parent: AbstractEntityMetadataBundle {
7191 _marker: AbstractEntity,
7192 on_fire: OnFire(false),
7193 shift_key_down: ShiftKeyDown(false),
7194 sprinting: Sprinting(false),
7195 swimming: Swimming(false),
7196 currently_glowing: CurrentlyGlowing(false),
7197 invisible: Invisible(false),
7198 fall_flying: FallFlying(false),
7199 air_supply: AirSupply(Default::default()),
7200 custom_name: CustomName(Default::default()),
7201 custom_name_visible: CustomNameVisible(Default::default()),
7202 silent: Silent(Default::default()),
7203 no_gravity: NoGravity(Default::default()),
7204 pose: Pose::default(),
7205 ticks_frozen: TicksFrozen(Default::default()),
7206 },
7207 auto_spin_attack: AutoSpinAttack(false),
7208 abstract_living_using_item: AbstractLivingUsingItem(false),
7209 health: Health(1.0),
7210 effect_particles: EffectParticles(Default::default()),
7211 effect_ambience: EffectAmbience(false),
7212 arrow_count: ArrowCount(0),
7213 stinger_count: StingerCount(0),
7214 sleeping_pos: SleepingPos(None),
7215 },
7216 no_ai: NoAi(false),
7217 left_handed: LeftHanded(false),
7218 aggressive: Aggressive(false),
7219 },
7220 },
7221 },
7222 is_celebrating: IsCelebrating(false),
7223 },
7224 pillager_is_charging_crossbow: PillagerIsChargingCrossbow(false),
7225 }
7226 }
7227}
7228
7229#[derive(Component, Deref, DerefMut, Clone)]
7230pub struct PlayerAbsorption(pub f32);
7231#[derive(Component, Deref, DerefMut, Clone)]
7232pub struct Score(pub i32);
7233#[derive(Component, Deref, DerefMut, Clone)]
7234pub struct PlayerModeCustomisation(pub u8);
7235#[derive(Component, Deref, DerefMut, Clone)]
7236pub struct PlayerMainHand(pub u8);
7237#[derive(Component, Deref, DerefMut, Clone)]
7238pub struct ShoulderLeft(pub simdnbt::owned::NbtCompound);
7239#[derive(Component, Deref, DerefMut, Clone)]
7240pub struct ShoulderRight(pub simdnbt::owned::NbtCompound);
7241#[derive(Component)]
7242pub struct Player;
7243impl Player {
7244 pub fn apply_metadata(
7245 entity: &mut bevy_ecs::system::EntityCommands,
7246 d: EntityDataItem,
7247 ) -> Result<(), UpdateMetadataError> {
7248 match d.index {
7249 0..=14 => AbstractLiving::apply_metadata(entity, d)?,
7250 15 => {
7251 entity.insert(PlayerAbsorption(d.value.into_float()?));
7252 }
7253 16 => {
7254 entity.insert(Score(d.value.into_int()?));
7255 }
7256 17 => {
7257 entity.insert(PlayerModeCustomisation(d.value.into_byte()?));
7258 }
7259 18 => {
7260 entity.insert(PlayerMainHand(d.value.into_byte()?));
7261 }
7262 19 => {
7263 entity.insert(ShoulderLeft(d.value.into_compound_tag()?));
7264 }
7265 20 => {
7266 entity.insert(ShoulderRight(d.value.into_compound_tag()?));
7267 }
7268 _ => {}
7269 }
7270 Ok(())
7271 }
7272}
7273
7274#[derive(Bundle)]
7275pub struct PlayerMetadataBundle {
7276 _marker: Player,
7277 parent: AbstractLivingMetadataBundle,
7278 player_absorption: PlayerAbsorption,
7279 score: Score,
7280 player_mode_customisation: PlayerModeCustomisation,
7281 player_main_hand: PlayerMainHand,
7282 shoulder_left: ShoulderLeft,
7283 shoulder_right: ShoulderRight,
7284}
7285impl Default for PlayerMetadataBundle {
7286 fn default() -> Self {
7287 Self {
7288 _marker: Player,
7289 parent: AbstractLivingMetadataBundle {
7290 _marker: AbstractLiving,
7291 parent: AbstractEntityMetadataBundle {
7292 _marker: AbstractEntity,
7293 on_fire: OnFire(false),
7294 shift_key_down: ShiftKeyDown(false),
7295 sprinting: Sprinting(false),
7296 swimming: Swimming(false),
7297 currently_glowing: CurrentlyGlowing(false),
7298 invisible: Invisible(false),
7299 fall_flying: FallFlying(false),
7300 air_supply: AirSupply(Default::default()),
7301 custom_name: CustomName(Default::default()),
7302 custom_name_visible: CustomNameVisible(Default::default()),
7303 silent: Silent(Default::default()),
7304 no_gravity: NoGravity(Default::default()),
7305 pose: Pose::default(),
7306 ticks_frozen: TicksFrozen(Default::default()),
7307 },
7308 auto_spin_attack: AutoSpinAttack(false),
7309 abstract_living_using_item: AbstractLivingUsingItem(false),
7310 health: Health(1.0),
7311 effect_particles: EffectParticles(Default::default()),
7312 effect_ambience: EffectAmbience(false),
7313 arrow_count: ArrowCount(0),
7314 stinger_count: StingerCount(0),
7315 sleeping_pos: SleepingPos(None),
7316 },
7317 player_absorption: PlayerAbsorption(0.0),
7318 score: Score(0),
7319 player_mode_customisation: PlayerModeCustomisation(0),
7320 player_main_hand: PlayerMainHand(Default::default()),
7321 shoulder_left: ShoulderLeft(simdnbt::owned::NbtCompound::default()),
7322 shoulder_right: ShoulderRight(simdnbt::owned::NbtCompound::default()),
7323 }
7324 }
7325}
7326
7327#[derive(Component, Deref, DerefMut, Clone)]
7328pub struct PolarBearStanding(pub bool);
7329#[derive(Component)]
7330pub struct PolarBear;
7331impl PolarBear {
7332 pub fn apply_metadata(
7333 entity: &mut bevy_ecs::system::EntityCommands,
7334 d: EntityDataItem,
7335 ) -> Result<(), UpdateMetadataError> {
7336 match d.index {
7337 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
7338 17 => {
7339 entity.insert(PolarBearStanding(d.value.into_boolean()?));
7340 }
7341 _ => {}
7342 }
7343 Ok(())
7344 }
7345}
7346
7347#[derive(Bundle)]
7348pub struct PolarBearMetadataBundle {
7349 _marker: PolarBear,
7350 parent: AbstractAnimalMetadataBundle,
7351 polar_bear_standing: PolarBearStanding,
7352}
7353impl Default for PolarBearMetadataBundle {
7354 fn default() -> Self {
7355 Self {
7356 _marker: PolarBear,
7357 parent: AbstractAnimalMetadataBundle {
7358 _marker: AbstractAnimal,
7359 parent: AbstractAgeableMetadataBundle {
7360 _marker: AbstractAgeable,
7361 parent: AbstractCreatureMetadataBundle {
7362 _marker: AbstractCreature,
7363 parent: AbstractInsentientMetadataBundle {
7364 _marker: AbstractInsentient,
7365 parent: AbstractLivingMetadataBundle {
7366 _marker: AbstractLiving,
7367 parent: AbstractEntityMetadataBundle {
7368 _marker: AbstractEntity,
7369 on_fire: OnFire(false),
7370 shift_key_down: ShiftKeyDown(false),
7371 sprinting: Sprinting(false),
7372 swimming: Swimming(false),
7373 currently_glowing: CurrentlyGlowing(false),
7374 invisible: Invisible(false),
7375 fall_flying: FallFlying(false),
7376 air_supply: AirSupply(Default::default()),
7377 custom_name: CustomName(Default::default()),
7378 custom_name_visible: CustomNameVisible(Default::default()),
7379 silent: Silent(Default::default()),
7380 no_gravity: NoGravity(Default::default()),
7381 pose: Pose::default(),
7382 ticks_frozen: TicksFrozen(Default::default()),
7383 },
7384 auto_spin_attack: AutoSpinAttack(false),
7385 abstract_living_using_item: AbstractLivingUsingItem(false),
7386 health: Health(1.0),
7387 effect_particles: EffectParticles(Default::default()),
7388 effect_ambience: EffectAmbience(false),
7389 arrow_count: ArrowCount(0),
7390 stinger_count: StingerCount(0),
7391 sleeping_pos: SleepingPos(None),
7392 },
7393 no_ai: NoAi(false),
7394 left_handed: LeftHanded(false),
7395 aggressive: Aggressive(false),
7396 },
7397 },
7398 abstract_ageable_baby: AbstractAgeableBaby(false),
7399 },
7400 },
7401 polar_bear_standing: PolarBearStanding(false),
7402 }
7403 }
7404}
7405
7406#[derive(Component, Deref, DerefMut, Clone)]
7407pub struct PufferfishFromBucket(pub bool);
7408#[derive(Component, Deref, DerefMut, Clone)]
7409pub struct PuffState(pub i32);
7410#[derive(Component)]
7411pub struct Pufferfish;
7412impl Pufferfish {
7413 pub fn apply_metadata(
7414 entity: &mut bevy_ecs::system::EntityCommands,
7415 d: EntityDataItem,
7416 ) -> Result<(), UpdateMetadataError> {
7417 match d.index {
7418 0..=15 => AbstractCreature::apply_metadata(entity, d)?,
7419 16 => {
7420 entity.insert(PufferfishFromBucket(d.value.into_boolean()?));
7421 }
7422 17 => {
7423 entity.insert(PuffState(d.value.into_int()?));
7424 }
7425 _ => {}
7426 }
7427 Ok(())
7428 }
7429}
7430
7431#[derive(Bundle)]
7432pub struct PufferfishMetadataBundle {
7433 _marker: Pufferfish,
7434 parent: AbstractCreatureMetadataBundle,
7435 pufferfish_from_bucket: PufferfishFromBucket,
7436 puff_state: PuffState,
7437}
7438impl Default for PufferfishMetadataBundle {
7439 fn default() -> Self {
7440 Self {
7441 _marker: Pufferfish,
7442 parent: AbstractCreatureMetadataBundle {
7443 _marker: AbstractCreature,
7444 parent: AbstractInsentientMetadataBundle {
7445 _marker: AbstractInsentient,
7446 parent: AbstractLivingMetadataBundle {
7447 _marker: AbstractLiving,
7448 parent: AbstractEntityMetadataBundle {
7449 _marker: AbstractEntity,
7450 on_fire: OnFire(false),
7451 shift_key_down: ShiftKeyDown(false),
7452 sprinting: Sprinting(false),
7453 swimming: Swimming(false),
7454 currently_glowing: CurrentlyGlowing(false),
7455 invisible: Invisible(false),
7456 fall_flying: FallFlying(false),
7457 air_supply: AirSupply(Default::default()),
7458 custom_name: CustomName(Default::default()),
7459 custom_name_visible: CustomNameVisible(Default::default()),
7460 silent: Silent(Default::default()),
7461 no_gravity: NoGravity(Default::default()),
7462 pose: Pose::default(),
7463 ticks_frozen: TicksFrozen(Default::default()),
7464 },
7465 auto_spin_attack: AutoSpinAttack(false),
7466 abstract_living_using_item: AbstractLivingUsingItem(false),
7467 health: Health(1.0),
7468 effect_particles: EffectParticles(Default::default()),
7469 effect_ambience: EffectAmbience(false),
7470 arrow_count: ArrowCount(0),
7471 stinger_count: StingerCount(0),
7472 sleeping_pos: SleepingPos(None),
7473 },
7474 no_ai: NoAi(false),
7475 left_handed: LeftHanded(false),
7476 aggressive: Aggressive(false),
7477 },
7478 },
7479 pufferfish_from_bucket: PufferfishFromBucket(false),
7480 puff_state: PuffState(0),
7481 }
7482 }
7483}
7484
7485#[derive(Component, Deref, DerefMut, Clone)]
7486pub struct RabbitKind(pub i32);
7487#[derive(Component)]
7488pub struct Rabbit;
7489impl Rabbit {
7490 pub fn apply_metadata(
7491 entity: &mut bevy_ecs::system::EntityCommands,
7492 d: EntityDataItem,
7493 ) -> Result<(), UpdateMetadataError> {
7494 match d.index {
7495 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
7496 17 => {
7497 entity.insert(RabbitKind(d.value.into_int()?));
7498 }
7499 _ => {}
7500 }
7501 Ok(())
7502 }
7503}
7504
7505#[derive(Bundle)]
7506pub struct RabbitMetadataBundle {
7507 _marker: Rabbit,
7508 parent: AbstractAnimalMetadataBundle,
7509 rabbit_kind: RabbitKind,
7510}
7511impl Default for RabbitMetadataBundle {
7512 fn default() -> Self {
7513 Self {
7514 _marker: Rabbit,
7515 parent: AbstractAnimalMetadataBundle {
7516 _marker: AbstractAnimal,
7517 parent: AbstractAgeableMetadataBundle {
7518 _marker: AbstractAgeable,
7519 parent: AbstractCreatureMetadataBundle {
7520 _marker: AbstractCreature,
7521 parent: AbstractInsentientMetadataBundle {
7522 _marker: AbstractInsentient,
7523 parent: AbstractLivingMetadataBundle {
7524 _marker: AbstractLiving,
7525 parent: AbstractEntityMetadataBundle {
7526 _marker: AbstractEntity,
7527 on_fire: OnFire(false),
7528 shift_key_down: ShiftKeyDown(false),
7529 sprinting: Sprinting(false),
7530 swimming: Swimming(false),
7531 currently_glowing: CurrentlyGlowing(false),
7532 invisible: Invisible(false),
7533 fall_flying: FallFlying(false),
7534 air_supply: AirSupply(Default::default()),
7535 custom_name: CustomName(Default::default()),
7536 custom_name_visible: CustomNameVisible(Default::default()),
7537 silent: Silent(Default::default()),
7538 no_gravity: NoGravity(Default::default()),
7539 pose: Pose::default(),
7540 ticks_frozen: TicksFrozen(Default::default()),
7541 },
7542 auto_spin_attack: AutoSpinAttack(false),
7543 abstract_living_using_item: AbstractLivingUsingItem(false),
7544 health: Health(1.0),
7545 effect_particles: EffectParticles(Default::default()),
7546 effect_ambience: EffectAmbience(false),
7547 arrow_count: ArrowCount(0),
7548 stinger_count: StingerCount(0),
7549 sleeping_pos: SleepingPos(None),
7550 },
7551 no_ai: NoAi(false),
7552 left_handed: LeftHanded(false),
7553 aggressive: Aggressive(false),
7554 },
7555 },
7556 abstract_ageable_baby: AbstractAgeableBaby(false),
7557 },
7558 },
7559 rabbit_kind: RabbitKind(Default::default()),
7560 }
7561 }
7562}
7563
7564#[derive(Component)]
7565pub struct Ravager;
7566impl Ravager {
7567 pub fn apply_metadata(
7568 entity: &mut bevy_ecs::system::EntityCommands,
7569 d: EntityDataItem,
7570 ) -> Result<(), UpdateMetadataError> {
7571 match d.index {
7572 0..=16 => AbstractRaider::apply_metadata(entity, d)?,
7573 _ => {}
7574 }
7575 Ok(())
7576 }
7577}
7578
7579#[derive(Bundle)]
7580pub struct RavagerMetadataBundle {
7581 _marker: Ravager,
7582 parent: AbstractRaiderMetadataBundle,
7583}
7584impl Default for RavagerMetadataBundle {
7585 fn default() -> Self {
7586 Self {
7587 _marker: Ravager,
7588 parent: AbstractRaiderMetadataBundle {
7589 _marker: AbstractRaider,
7590 parent: AbstractMonsterMetadataBundle {
7591 _marker: AbstractMonster,
7592 parent: AbstractCreatureMetadataBundle {
7593 _marker: AbstractCreature,
7594 parent: AbstractInsentientMetadataBundle {
7595 _marker: AbstractInsentient,
7596 parent: AbstractLivingMetadataBundle {
7597 _marker: AbstractLiving,
7598 parent: AbstractEntityMetadataBundle {
7599 _marker: AbstractEntity,
7600 on_fire: OnFire(false),
7601 shift_key_down: ShiftKeyDown(false),
7602 sprinting: Sprinting(false),
7603 swimming: Swimming(false),
7604 currently_glowing: CurrentlyGlowing(false),
7605 invisible: Invisible(false),
7606 fall_flying: FallFlying(false),
7607 air_supply: AirSupply(Default::default()),
7608 custom_name: CustomName(Default::default()),
7609 custom_name_visible: CustomNameVisible(Default::default()),
7610 silent: Silent(Default::default()),
7611 no_gravity: NoGravity(Default::default()),
7612 pose: Pose::default(),
7613 ticks_frozen: TicksFrozen(Default::default()),
7614 },
7615 auto_spin_attack: AutoSpinAttack(false),
7616 abstract_living_using_item: AbstractLivingUsingItem(false),
7617 health: Health(1.0),
7618 effect_particles: EffectParticles(Default::default()),
7619 effect_ambience: EffectAmbience(false),
7620 arrow_count: ArrowCount(0),
7621 stinger_count: StingerCount(0),
7622 sleeping_pos: SleepingPos(None),
7623 },
7624 no_ai: NoAi(false),
7625 left_handed: LeftHanded(false),
7626 aggressive: Aggressive(false),
7627 },
7628 },
7629 },
7630 is_celebrating: IsCelebrating(false),
7631 },
7632 }
7633 }
7634}
7635
7636#[derive(Component, Deref, DerefMut, Clone)]
7637pub struct SalmonKind(pub i32);
7638#[derive(Component)]
7639pub struct Salmon;
7640impl Salmon {
7641 pub fn apply_metadata(
7642 entity: &mut bevy_ecs::system::EntityCommands,
7643 d: EntityDataItem,
7644 ) -> Result<(), UpdateMetadataError> {
7645 match d.index {
7646 0..=16 => AbstractFish::apply_metadata(entity, d)?,
7647 17 => {
7648 entity.insert(SalmonKind(d.value.into_int()?));
7649 }
7650 _ => {}
7651 }
7652 Ok(())
7653 }
7654}
7655
7656#[derive(Bundle)]
7657pub struct SalmonMetadataBundle {
7658 _marker: Salmon,
7659 parent: AbstractFishMetadataBundle,
7660 salmon_kind: SalmonKind,
7661}
7662impl Default for SalmonMetadataBundle {
7663 fn default() -> Self {
7664 Self {
7665 _marker: Salmon,
7666 parent: AbstractFishMetadataBundle {
7667 _marker: AbstractFish,
7668 parent: AbstractCreatureMetadataBundle {
7669 _marker: AbstractCreature,
7670 parent: AbstractInsentientMetadataBundle {
7671 _marker: AbstractInsentient,
7672 parent: AbstractLivingMetadataBundle {
7673 _marker: AbstractLiving,
7674 parent: AbstractEntityMetadataBundle {
7675 _marker: AbstractEntity,
7676 on_fire: OnFire(false),
7677 shift_key_down: ShiftKeyDown(false),
7678 sprinting: Sprinting(false),
7679 swimming: Swimming(false),
7680 currently_glowing: CurrentlyGlowing(false),
7681 invisible: Invisible(false),
7682 fall_flying: FallFlying(false),
7683 air_supply: AirSupply(Default::default()),
7684 custom_name: CustomName(Default::default()),
7685 custom_name_visible: CustomNameVisible(Default::default()),
7686 silent: Silent(Default::default()),
7687 no_gravity: NoGravity(Default::default()),
7688 pose: Pose::default(),
7689 ticks_frozen: TicksFrozen(Default::default()),
7690 },
7691 auto_spin_attack: AutoSpinAttack(false),
7692 abstract_living_using_item: AbstractLivingUsingItem(false),
7693 health: Health(1.0),
7694 effect_particles: EffectParticles(Default::default()),
7695 effect_ambience: EffectAmbience(false),
7696 arrow_count: ArrowCount(0),
7697 stinger_count: StingerCount(0),
7698 sleeping_pos: SleepingPos(None),
7699 },
7700 no_ai: NoAi(false),
7701 left_handed: LeftHanded(false),
7702 aggressive: Aggressive(false),
7703 },
7704 },
7705 abstract_fish_from_bucket: AbstractFishFromBucket(false),
7706 },
7707 salmon_kind: SalmonKind(Default::default()),
7708 }
7709 }
7710}
7711
7712#[derive(Component, Deref, DerefMut, Clone, Copy)]
7713pub struct SheepSheared(pub bool);
7714#[derive(Component)]
7715pub struct Sheep;
7716impl Sheep {
7717 pub fn apply_metadata(
7718 entity: &mut bevy_ecs::system::EntityCommands,
7719 d: EntityDataItem,
7720 ) -> Result<(), UpdateMetadataError> {
7721 match d.index {
7722 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
7723 17 => {
7724 let bitfield = d.value.into_byte()?;
7725 entity.insert(SheepSheared(bitfield & 0x10 != 0));
7726 }
7727 _ => {}
7728 }
7729 Ok(())
7730 }
7731}
7732
7733#[derive(Bundle)]
7734pub struct SheepMetadataBundle {
7735 _marker: Sheep,
7736 parent: AbstractAnimalMetadataBundle,
7737 sheep_sheared: SheepSheared,
7738}
7739impl Default for SheepMetadataBundle {
7740 fn default() -> Self {
7741 Self {
7742 _marker: Sheep,
7743 parent: AbstractAnimalMetadataBundle {
7744 _marker: AbstractAnimal,
7745 parent: AbstractAgeableMetadataBundle {
7746 _marker: AbstractAgeable,
7747 parent: AbstractCreatureMetadataBundle {
7748 _marker: AbstractCreature,
7749 parent: AbstractInsentientMetadataBundle {
7750 _marker: AbstractInsentient,
7751 parent: AbstractLivingMetadataBundle {
7752 _marker: AbstractLiving,
7753 parent: AbstractEntityMetadataBundle {
7754 _marker: AbstractEntity,
7755 on_fire: OnFire(false),
7756 shift_key_down: ShiftKeyDown(false),
7757 sprinting: Sprinting(false),
7758 swimming: Swimming(false),
7759 currently_glowing: CurrentlyGlowing(false),
7760 invisible: Invisible(false),
7761 fall_flying: FallFlying(false),
7762 air_supply: AirSupply(Default::default()),
7763 custom_name: CustomName(Default::default()),
7764 custom_name_visible: CustomNameVisible(Default::default()),
7765 silent: Silent(Default::default()),
7766 no_gravity: NoGravity(Default::default()),
7767 pose: Pose::default(),
7768 ticks_frozen: TicksFrozen(Default::default()),
7769 },
7770 auto_spin_attack: AutoSpinAttack(false),
7771 abstract_living_using_item: AbstractLivingUsingItem(false),
7772 health: Health(1.0),
7773 effect_particles: EffectParticles(Default::default()),
7774 effect_ambience: EffectAmbience(false),
7775 arrow_count: ArrowCount(0),
7776 stinger_count: StingerCount(0),
7777 sleeping_pos: SleepingPos(None),
7778 },
7779 no_ai: NoAi(false),
7780 left_handed: LeftHanded(false),
7781 aggressive: Aggressive(false),
7782 },
7783 },
7784 abstract_ageable_baby: AbstractAgeableBaby(false),
7785 },
7786 },
7787 sheep_sheared: SheepSheared(false),
7788 }
7789 }
7790}
7791
7792#[derive(Component, Deref, DerefMut, Clone)]
7793pub struct AttachFace(pub Direction);
7794#[derive(Component, Deref, DerefMut, Clone)]
7795pub struct Peek(pub u8);
7796#[derive(Component, Deref, DerefMut, Clone)]
7797pub struct Color(pub u8);
7798#[derive(Component)]
7799pub struct Shulker;
7800impl Shulker {
7801 pub fn apply_metadata(
7802 entity: &mut bevy_ecs::system::EntityCommands,
7803 d: EntityDataItem,
7804 ) -> Result<(), UpdateMetadataError> {
7805 match d.index {
7806 0..=15 => AbstractCreature::apply_metadata(entity, d)?,
7807 16 => {
7808 entity.insert(AttachFace(d.value.into_direction()?));
7809 }
7810 17 => {
7811 entity.insert(Peek(d.value.into_byte()?));
7812 }
7813 18 => {
7814 entity.insert(Color(d.value.into_byte()?));
7815 }
7816 _ => {}
7817 }
7818 Ok(())
7819 }
7820}
7821
7822#[derive(Bundle)]
7823pub struct ShulkerMetadataBundle {
7824 _marker: Shulker,
7825 parent: AbstractCreatureMetadataBundle,
7826 attach_face: AttachFace,
7827 peek: Peek,
7828 color: Color,
7829}
7830impl Default for ShulkerMetadataBundle {
7831 fn default() -> Self {
7832 Self {
7833 _marker: Shulker,
7834 parent: AbstractCreatureMetadataBundle {
7835 _marker: AbstractCreature,
7836 parent: AbstractInsentientMetadataBundle {
7837 _marker: AbstractInsentient,
7838 parent: AbstractLivingMetadataBundle {
7839 _marker: AbstractLiving,
7840 parent: AbstractEntityMetadataBundle {
7841 _marker: AbstractEntity,
7842 on_fire: OnFire(false),
7843 shift_key_down: ShiftKeyDown(false),
7844 sprinting: Sprinting(false),
7845 swimming: Swimming(false),
7846 currently_glowing: CurrentlyGlowing(false),
7847 invisible: Invisible(false),
7848 fall_flying: FallFlying(false),
7849 air_supply: AirSupply(Default::default()),
7850 custom_name: CustomName(Default::default()),
7851 custom_name_visible: CustomNameVisible(Default::default()),
7852 silent: Silent(Default::default()),
7853 no_gravity: NoGravity(Default::default()),
7854 pose: Pose::default(),
7855 ticks_frozen: TicksFrozen(Default::default()),
7856 },
7857 auto_spin_attack: AutoSpinAttack(false),
7858 abstract_living_using_item: AbstractLivingUsingItem(false),
7859 health: Health(1.0),
7860 effect_particles: EffectParticles(Default::default()),
7861 effect_ambience: EffectAmbience(false),
7862 arrow_count: ArrowCount(0),
7863 stinger_count: StingerCount(0),
7864 sleeping_pos: SleepingPos(None),
7865 },
7866 no_ai: NoAi(false),
7867 left_handed: LeftHanded(false),
7868 aggressive: Aggressive(false),
7869 },
7870 },
7871 attach_face: AttachFace(Default::default()),
7872 peek: Peek(0),
7873 color: Color(16),
7874 }
7875 }
7876}
7877
7878#[derive(Component)]
7879pub struct ShulkerBullet;
7880impl ShulkerBullet {
7881 pub fn apply_metadata(
7882 entity: &mut bevy_ecs::system::EntityCommands,
7883 d: EntityDataItem,
7884 ) -> Result<(), UpdateMetadataError> {
7885 match d.index {
7886 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
7887 _ => {}
7888 }
7889 Ok(())
7890 }
7891}
7892
7893#[derive(Bundle)]
7894pub struct ShulkerBulletMetadataBundle {
7895 _marker: ShulkerBullet,
7896 parent: AbstractEntityMetadataBundle,
7897}
7898impl Default for ShulkerBulletMetadataBundle {
7899 fn default() -> Self {
7900 Self {
7901 _marker: ShulkerBullet,
7902 parent: AbstractEntityMetadataBundle {
7903 _marker: AbstractEntity,
7904 on_fire: OnFire(false),
7905 shift_key_down: ShiftKeyDown(false),
7906 sprinting: Sprinting(false),
7907 swimming: Swimming(false),
7908 currently_glowing: CurrentlyGlowing(false),
7909 invisible: Invisible(false),
7910 fall_flying: FallFlying(false),
7911 air_supply: AirSupply(Default::default()),
7912 custom_name: CustomName(Default::default()),
7913 custom_name_visible: CustomNameVisible(Default::default()),
7914 silent: Silent(Default::default()),
7915 no_gravity: NoGravity(Default::default()),
7916 pose: Pose::default(),
7917 ticks_frozen: TicksFrozen(Default::default()),
7918 },
7919 }
7920 }
7921}
7922
7923#[derive(Component)]
7924pub struct Silverfish;
7925impl Silverfish {
7926 pub fn apply_metadata(
7927 entity: &mut bevy_ecs::system::EntityCommands,
7928 d: EntityDataItem,
7929 ) -> Result<(), UpdateMetadataError> {
7930 match d.index {
7931 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
7932 _ => {}
7933 }
7934 Ok(())
7935 }
7936}
7937
7938#[derive(Bundle)]
7939pub struct SilverfishMetadataBundle {
7940 _marker: Silverfish,
7941 parent: AbstractMonsterMetadataBundle,
7942}
7943impl Default for SilverfishMetadataBundle {
7944 fn default() -> Self {
7945 Self {
7946 _marker: Silverfish,
7947 parent: AbstractMonsterMetadataBundle {
7948 _marker: AbstractMonster,
7949 parent: AbstractCreatureMetadataBundle {
7950 _marker: AbstractCreature,
7951 parent: AbstractInsentientMetadataBundle {
7952 _marker: AbstractInsentient,
7953 parent: AbstractLivingMetadataBundle {
7954 _marker: AbstractLiving,
7955 parent: AbstractEntityMetadataBundle {
7956 _marker: AbstractEntity,
7957 on_fire: OnFire(false),
7958 shift_key_down: ShiftKeyDown(false),
7959 sprinting: Sprinting(false),
7960 swimming: Swimming(false),
7961 currently_glowing: CurrentlyGlowing(false),
7962 invisible: Invisible(false),
7963 fall_flying: FallFlying(false),
7964 air_supply: AirSupply(Default::default()),
7965 custom_name: CustomName(Default::default()),
7966 custom_name_visible: CustomNameVisible(Default::default()),
7967 silent: Silent(Default::default()),
7968 no_gravity: NoGravity(Default::default()),
7969 pose: Pose::default(),
7970 ticks_frozen: TicksFrozen(Default::default()),
7971 },
7972 auto_spin_attack: AutoSpinAttack(false),
7973 abstract_living_using_item: AbstractLivingUsingItem(false),
7974 health: Health(1.0),
7975 effect_particles: EffectParticles(Default::default()),
7976 effect_ambience: EffectAmbience(false),
7977 arrow_count: ArrowCount(0),
7978 stinger_count: StingerCount(0),
7979 sleeping_pos: SleepingPos(None),
7980 },
7981 no_ai: NoAi(false),
7982 left_handed: LeftHanded(false),
7983 aggressive: Aggressive(false),
7984 },
7985 },
7986 },
7987 }
7988 }
7989}
7990
7991#[derive(Component, Deref, DerefMut, Clone)]
7992pub struct StrayConversion(pub bool);
7993#[derive(Component)]
7994pub struct Skeleton;
7995impl Skeleton {
7996 pub fn apply_metadata(
7997 entity: &mut bevy_ecs::system::EntityCommands,
7998 d: EntityDataItem,
7999 ) -> Result<(), UpdateMetadataError> {
8000 match d.index {
8001 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
8002 16 => {
8003 entity.insert(StrayConversion(d.value.into_boolean()?));
8004 }
8005 _ => {}
8006 }
8007 Ok(())
8008 }
8009}
8010
8011#[derive(Bundle)]
8012pub struct SkeletonMetadataBundle {
8013 _marker: Skeleton,
8014 parent: AbstractMonsterMetadataBundle,
8015 stray_conversion: StrayConversion,
8016}
8017impl Default for SkeletonMetadataBundle {
8018 fn default() -> Self {
8019 Self {
8020 _marker: Skeleton,
8021 parent: AbstractMonsterMetadataBundle {
8022 _marker: AbstractMonster,
8023 parent: AbstractCreatureMetadataBundle {
8024 _marker: AbstractCreature,
8025 parent: AbstractInsentientMetadataBundle {
8026 _marker: AbstractInsentient,
8027 parent: AbstractLivingMetadataBundle {
8028 _marker: AbstractLiving,
8029 parent: AbstractEntityMetadataBundle {
8030 _marker: AbstractEntity,
8031 on_fire: OnFire(false),
8032 shift_key_down: ShiftKeyDown(false),
8033 sprinting: Sprinting(false),
8034 swimming: Swimming(false),
8035 currently_glowing: CurrentlyGlowing(false),
8036 invisible: Invisible(false),
8037 fall_flying: FallFlying(false),
8038 air_supply: AirSupply(Default::default()),
8039 custom_name: CustomName(Default::default()),
8040 custom_name_visible: CustomNameVisible(Default::default()),
8041 silent: Silent(Default::default()),
8042 no_gravity: NoGravity(Default::default()),
8043 pose: Pose::default(),
8044 ticks_frozen: TicksFrozen(Default::default()),
8045 },
8046 auto_spin_attack: AutoSpinAttack(false),
8047 abstract_living_using_item: AbstractLivingUsingItem(false),
8048 health: Health(1.0),
8049 effect_particles: EffectParticles(Default::default()),
8050 effect_ambience: EffectAmbience(false),
8051 arrow_count: ArrowCount(0),
8052 stinger_count: StingerCount(0),
8053 sleeping_pos: SleepingPos(None),
8054 },
8055 no_ai: NoAi(false),
8056 left_handed: LeftHanded(false),
8057 aggressive: Aggressive(false),
8058 },
8059 },
8060 },
8061 stray_conversion: StrayConversion(false),
8062 }
8063 }
8064}
8065
8066#[derive(Component)]
8067pub struct SkeletonHorse;
8068impl SkeletonHorse {
8069 pub fn apply_metadata(
8070 entity: &mut bevy_ecs::system::EntityCommands,
8071 d: EntityDataItem,
8072 ) -> Result<(), UpdateMetadataError> {
8073 match d.index {
8074 0..=17 => AbstractHorse::apply_metadata(entity, d)?,
8075 _ => {}
8076 }
8077 Ok(())
8078 }
8079}
8080
8081#[derive(Bundle)]
8082pub struct SkeletonHorseMetadataBundle {
8083 _marker: SkeletonHorse,
8084 parent: AbstractHorseMetadataBundle,
8085}
8086impl Default for SkeletonHorseMetadataBundle {
8087 fn default() -> Self {
8088 Self {
8089 _marker: SkeletonHorse,
8090 parent: AbstractHorseMetadataBundle {
8091 _marker: AbstractHorse,
8092 parent: AbstractAnimalMetadataBundle {
8093 _marker: AbstractAnimal,
8094 parent: AbstractAgeableMetadataBundle {
8095 _marker: AbstractAgeable,
8096 parent: AbstractCreatureMetadataBundle {
8097 _marker: AbstractCreature,
8098 parent: AbstractInsentientMetadataBundle {
8099 _marker: AbstractInsentient,
8100 parent: AbstractLivingMetadataBundle {
8101 _marker: AbstractLiving,
8102 parent: AbstractEntityMetadataBundle {
8103 _marker: AbstractEntity,
8104 on_fire: OnFire(false),
8105 shift_key_down: ShiftKeyDown(false),
8106 sprinting: Sprinting(false),
8107 swimming: Swimming(false),
8108 currently_glowing: CurrentlyGlowing(false),
8109 invisible: Invisible(false),
8110 fall_flying: FallFlying(false),
8111 air_supply: AirSupply(Default::default()),
8112 custom_name: CustomName(Default::default()),
8113 custom_name_visible: CustomNameVisible(Default::default()),
8114 silent: Silent(Default::default()),
8115 no_gravity: NoGravity(Default::default()),
8116 pose: Pose::default(),
8117 ticks_frozen: TicksFrozen(Default::default()),
8118 },
8119 auto_spin_attack: AutoSpinAttack(false),
8120 abstract_living_using_item: AbstractLivingUsingItem(false),
8121 health: Health(1.0),
8122 effect_particles: EffectParticles(Default::default()),
8123 effect_ambience: EffectAmbience(false),
8124 arrow_count: ArrowCount(0),
8125 stinger_count: StingerCount(0),
8126 sleeping_pos: SleepingPos(None),
8127 },
8128 no_ai: NoAi(false),
8129 left_handed: LeftHanded(false),
8130 aggressive: Aggressive(false),
8131 },
8132 },
8133 abstract_ageable_baby: AbstractAgeableBaby(false),
8134 },
8135 },
8136 tamed: Tamed(false),
8137 eating: Eating(false),
8138 abstract_horse_standing: AbstractHorseStanding(false),
8139 bred: Bred(false),
8140 },
8141 }
8142 }
8143}
8144
8145#[derive(Component)]
8146pub struct Slime;
8147impl Slime {
8148 pub fn apply_metadata(
8149 entity: &mut bevy_ecs::system::EntityCommands,
8150 d: EntityDataItem,
8151 ) -> Result<(), UpdateMetadataError> {
8152 match d.index {
8153 0..=15 => AbstractInsentient::apply_metadata(entity, d)?,
8154 16 => {
8155 entity.insert(SlimeSize(d.value.into_int()?));
8156 }
8157 _ => {}
8158 }
8159 Ok(())
8160 }
8161}
8162
8163#[derive(Bundle)]
8164pub struct SlimeMetadataBundle {
8165 _marker: Slime,
8166 parent: AbstractInsentientMetadataBundle,
8167 slime_size: SlimeSize,
8168}
8169impl Default for SlimeMetadataBundle {
8170 fn default() -> Self {
8171 Self {
8172 _marker: Slime,
8173 parent: AbstractInsentientMetadataBundle {
8174 _marker: AbstractInsentient,
8175 parent: AbstractLivingMetadataBundle {
8176 _marker: AbstractLiving,
8177 parent: AbstractEntityMetadataBundle {
8178 _marker: AbstractEntity,
8179 on_fire: OnFire(false),
8180 shift_key_down: ShiftKeyDown(false),
8181 sprinting: Sprinting(false),
8182 swimming: Swimming(false),
8183 currently_glowing: CurrentlyGlowing(false),
8184 invisible: Invisible(false),
8185 fall_flying: FallFlying(false),
8186 air_supply: AirSupply(Default::default()),
8187 custom_name: CustomName(Default::default()),
8188 custom_name_visible: CustomNameVisible(Default::default()),
8189 silent: Silent(Default::default()),
8190 no_gravity: NoGravity(Default::default()),
8191 pose: Pose::default(),
8192 ticks_frozen: TicksFrozen(Default::default()),
8193 },
8194 auto_spin_attack: AutoSpinAttack(false),
8195 abstract_living_using_item: AbstractLivingUsingItem(false),
8196 health: Health(1.0),
8197 effect_particles: EffectParticles(Default::default()),
8198 effect_ambience: EffectAmbience(false),
8199 arrow_count: ArrowCount(0),
8200 stinger_count: StingerCount(0),
8201 sleeping_pos: SleepingPos(None),
8202 },
8203 no_ai: NoAi(false),
8204 left_handed: LeftHanded(false),
8205 aggressive: Aggressive(false),
8206 },
8207 slime_size: SlimeSize(1),
8208 }
8209 }
8210}
8211
8212#[derive(Component, Deref, DerefMut, Clone)]
8213pub struct SmallFireballItemStack(pub ItemStack);
8214#[derive(Component)]
8215pub struct SmallFireball;
8216impl SmallFireball {
8217 pub fn apply_metadata(
8218 entity: &mut bevy_ecs::system::EntityCommands,
8219 d: EntityDataItem,
8220 ) -> Result<(), UpdateMetadataError> {
8221 match d.index {
8222 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
8223 8 => {
8224 entity.insert(SmallFireballItemStack(d.value.into_item_stack()?));
8225 }
8226 _ => {}
8227 }
8228 Ok(())
8229 }
8230}
8231
8232#[derive(Bundle)]
8233pub struct SmallFireballMetadataBundle {
8234 _marker: SmallFireball,
8235 parent: AbstractEntityMetadataBundle,
8236 small_fireball_item_stack: SmallFireballItemStack,
8237}
8238impl Default for SmallFireballMetadataBundle {
8239 fn default() -> Self {
8240 Self {
8241 _marker: SmallFireball,
8242 parent: AbstractEntityMetadataBundle {
8243 _marker: AbstractEntity,
8244 on_fire: OnFire(false),
8245 shift_key_down: ShiftKeyDown(false),
8246 sprinting: Sprinting(false),
8247 swimming: Swimming(false),
8248 currently_glowing: CurrentlyGlowing(false),
8249 invisible: Invisible(false),
8250 fall_flying: FallFlying(false),
8251 air_supply: AirSupply(Default::default()),
8252 custom_name: CustomName(Default::default()),
8253 custom_name_visible: CustomNameVisible(Default::default()),
8254 silent: Silent(Default::default()),
8255 no_gravity: NoGravity(Default::default()),
8256 pose: Pose::default(),
8257 ticks_frozen: TicksFrozen(Default::default()),
8258 },
8259 small_fireball_item_stack: SmallFireballItemStack(Default::default()),
8260 }
8261 }
8262}
8263
8264#[derive(Component, Deref, DerefMut, Clone)]
8265pub struct SnifferState(pub SnifferStateKind);
8266#[derive(Component, Deref, DerefMut, Clone)]
8267pub struct DropSeedAtTick(pub i32);
8268#[derive(Component)]
8269pub struct Sniffer;
8270impl Sniffer {
8271 pub fn apply_metadata(
8272 entity: &mut bevy_ecs::system::EntityCommands,
8273 d: EntityDataItem,
8274 ) -> Result<(), UpdateMetadataError> {
8275 match d.index {
8276 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
8277 17 => {
8278 entity.insert(SnifferState(d.value.into_sniffer_state()?));
8279 }
8280 18 => {
8281 entity.insert(DropSeedAtTick(d.value.into_int()?));
8282 }
8283 _ => {}
8284 }
8285 Ok(())
8286 }
8287}
8288
8289#[derive(Bundle)]
8290pub struct SnifferMetadataBundle {
8291 _marker: Sniffer,
8292 parent: AbstractAnimalMetadataBundle,
8293 sniffer_state: SnifferState,
8294 drop_seed_at_tick: DropSeedAtTick,
8295}
8296impl Default for SnifferMetadataBundle {
8297 fn default() -> Self {
8298 Self {
8299 _marker: Sniffer,
8300 parent: AbstractAnimalMetadataBundle {
8301 _marker: AbstractAnimal,
8302 parent: AbstractAgeableMetadataBundle {
8303 _marker: AbstractAgeable,
8304 parent: AbstractCreatureMetadataBundle {
8305 _marker: AbstractCreature,
8306 parent: AbstractInsentientMetadataBundle {
8307 _marker: AbstractInsentient,
8308 parent: AbstractLivingMetadataBundle {
8309 _marker: AbstractLiving,
8310 parent: AbstractEntityMetadataBundle {
8311 _marker: AbstractEntity,
8312 on_fire: OnFire(false),
8313 shift_key_down: ShiftKeyDown(false),
8314 sprinting: Sprinting(false),
8315 swimming: Swimming(false),
8316 currently_glowing: CurrentlyGlowing(false),
8317 invisible: Invisible(false),
8318 fall_flying: FallFlying(false),
8319 air_supply: AirSupply(Default::default()),
8320 custom_name: CustomName(Default::default()),
8321 custom_name_visible: CustomNameVisible(Default::default()),
8322 silent: Silent(Default::default()),
8323 no_gravity: NoGravity(Default::default()),
8324 pose: Pose::default(),
8325 ticks_frozen: TicksFrozen(Default::default()),
8326 },
8327 auto_spin_attack: AutoSpinAttack(false),
8328 abstract_living_using_item: AbstractLivingUsingItem(false),
8329 health: Health(1.0),
8330 effect_particles: EffectParticles(Default::default()),
8331 effect_ambience: EffectAmbience(false),
8332 arrow_count: ArrowCount(0),
8333 stinger_count: StingerCount(0),
8334 sleeping_pos: SleepingPos(None),
8335 },
8336 no_ai: NoAi(false),
8337 left_handed: LeftHanded(false),
8338 aggressive: Aggressive(false),
8339 },
8340 },
8341 abstract_ageable_baby: AbstractAgeableBaby(false),
8342 },
8343 },
8344 sniffer_state: SnifferState(Default::default()),
8345 drop_seed_at_tick: DropSeedAtTick(0),
8346 }
8347 }
8348}
8349
8350#[derive(Component, Deref, DerefMut, Clone, Copy)]
8351pub struct HasPumpkin(pub bool);
8352#[derive(Component)]
8353pub struct SnowGolem;
8354impl SnowGolem {
8355 pub fn apply_metadata(
8356 entity: &mut bevy_ecs::system::EntityCommands,
8357 d: EntityDataItem,
8358 ) -> Result<(), UpdateMetadataError> {
8359 match d.index {
8360 0..=15 => AbstractCreature::apply_metadata(entity, d)?,
8361 16 => {
8362 let bitfield = d.value.into_byte()?;
8363 entity.insert(HasPumpkin(bitfield & 0x10 != 0));
8364 }
8365 _ => {}
8366 }
8367 Ok(())
8368 }
8369}
8370
8371#[derive(Bundle)]
8372pub struct SnowGolemMetadataBundle {
8373 _marker: SnowGolem,
8374 parent: AbstractCreatureMetadataBundle,
8375 has_pumpkin: HasPumpkin,
8376}
8377impl Default for SnowGolemMetadataBundle {
8378 fn default() -> Self {
8379 Self {
8380 _marker: SnowGolem,
8381 parent: AbstractCreatureMetadataBundle {
8382 _marker: AbstractCreature,
8383 parent: AbstractInsentientMetadataBundle {
8384 _marker: AbstractInsentient,
8385 parent: AbstractLivingMetadataBundle {
8386 _marker: AbstractLiving,
8387 parent: AbstractEntityMetadataBundle {
8388 _marker: AbstractEntity,
8389 on_fire: OnFire(false),
8390 shift_key_down: ShiftKeyDown(false),
8391 sprinting: Sprinting(false),
8392 swimming: Swimming(false),
8393 currently_glowing: CurrentlyGlowing(false),
8394 invisible: Invisible(false),
8395 fall_flying: FallFlying(false),
8396 air_supply: AirSupply(Default::default()),
8397 custom_name: CustomName(Default::default()),
8398 custom_name_visible: CustomNameVisible(Default::default()),
8399 silent: Silent(Default::default()),
8400 no_gravity: NoGravity(Default::default()),
8401 pose: Pose::default(),
8402 ticks_frozen: TicksFrozen(Default::default()),
8403 },
8404 auto_spin_attack: AutoSpinAttack(false),
8405 abstract_living_using_item: AbstractLivingUsingItem(false),
8406 health: Health(1.0),
8407 effect_particles: EffectParticles(Default::default()),
8408 effect_ambience: EffectAmbience(false),
8409 arrow_count: ArrowCount(0),
8410 stinger_count: StingerCount(0),
8411 sleeping_pos: SleepingPos(None),
8412 },
8413 no_ai: NoAi(false),
8414 left_handed: LeftHanded(false),
8415 aggressive: Aggressive(false),
8416 },
8417 },
8418 has_pumpkin: HasPumpkin(true),
8419 }
8420 }
8421}
8422
8423#[derive(Component)]
8424pub struct Snowball;
8425impl Snowball {
8426 pub fn apply_metadata(
8427 entity: &mut bevy_ecs::system::EntityCommands,
8428 d: EntityDataItem,
8429 ) -> Result<(), UpdateMetadataError> {
8430 match d.index {
8431 0..=8 => AbstractThrownItemProjectile::apply_metadata(entity, d)?,
8432 _ => {}
8433 }
8434 Ok(())
8435 }
8436}
8437
8438#[derive(Bundle)]
8439pub struct SnowballMetadataBundle {
8440 _marker: Snowball,
8441 parent: AbstractThrownItemProjectileMetadataBundle,
8442}
8443impl Default for SnowballMetadataBundle {
8444 fn default() -> Self {
8445 Self {
8446 _marker: Snowball,
8447 parent: AbstractThrownItemProjectileMetadataBundle {
8448 _marker: AbstractThrownItemProjectile,
8449 parent: AbstractEntityMetadataBundle {
8450 _marker: AbstractEntity,
8451 on_fire: OnFire(false),
8452 shift_key_down: ShiftKeyDown(false),
8453 sprinting: Sprinting(false),
8454 swimming: Swimming(false),
8455 currently_glowing: CurrentlyGlowing(false),
8456 invisible: Invisible(false),
8457 fall_flying: FallFlying(false),
8458 air_supply: AirSupply(Default::default()),
8459 custom_name: CustomName(Default::default()),
8460 custom_name_visible: CustomNameVisible(Default::default()),
8461 silent: Silent(Default::default()),
8462 no_gravity: NoGravity(Default::default()),
8463 pose: Pose::default(),
8464 ticks_frozen: TicksFrozen(Default::default()),
8465 },
8466 abstract_thrown_item_projectile_item_stack: AbstractThrownItemProjectileItemStack(
8467 Default::default(),
8468 ),
8469 },
8470 }
8471 }
8472}
8473
8474#[derive(Component)]
8475pub struct SpawnerMinecart;
8476impl SpawnerMinecart {
8477 pub fn apply_metadata(
8478 entity: &mut bevy_ecs::system::EntityCommands,
8479 d: EntityDataItem,
8480 ) -> Result<(), UpdateMetadataError> {
8481 match d.index {
8482 0..=12 => AbstractMinecart::apply_metadata(entity, d)?,
8483 _ => {}
8484 }
8485 Ok(())
8486 }
8487}
8488
8489#[derive(Bundle)]
8490pub struct SpawnerMinecartMetadataBundle {
8491 _marker: SpawnerMinecart,
8492 parent: AbstractMinecartMetadataBundle,
8493}
8494impl Default for SpawnerMinecartMetadataBundle {
8495 fn default() -> Self {
8496 Self {
8497 _marker: SpawnerMinecart,
8498 parent: AbstractMinecartMetadataBundle {
8499 _marker: AbstractMinecart,
8500 parent: AbstractVehicleMetadataBundle {
8501 _marker: AbstractVehicle,
8502 parent: AbstractEntityMetadataBundle {
8503 _marker: AbstractEntity,
8504 on_fire: OnFire(false),
8505 shift_key_down: ShiftKeyDown(false),
8506 sprinting: Sprinting(false),
8507 swimming: Swimming(false),
8508 currently_glowing: CurrentlyGlowing(false),
8509 invisible: Invisible(false),
8510 fall_flying: FallFlying(false),
8511 air_supply: AirSupply(Default::default()),
8512 custom_name: CustomName(Default::default()),
8513 custom_name_visible: CustomNameVisible(Default::default()),
8514 silent: Silent(Default::default()),
8515 no_gravity: NoGravity(Default::default()),
8516 pose: Pose::default(),
8517 ticks_frozen: TicksFrozen(Default::default()),
8518 },
8519 hurt: Hurt(0),
8520 hurtdir: Hurtdir(1),
8521 damage: Damage(0.0),
8522 },
8523 custom_display_block: CustomDisplayBlock(azalea_block::BlockState::AIR),
8524 display_offset: DisplayOffset(Default::default()),
8525 },
8526 }
8527 }
8528}
8529
8530#[derive(Component)]
8531pub struct SpectralArrow;
8532impl SpectralArrow {
8533 pub fn apply_metadata(
8534 entity: &mut bevy_ecs::system::EntityCommands,
8535 d: EntityDataItem,
8536 ) -> Result<(), UpdateMetadataError> {
8537 match d.index {
8538 0..=10 => AbstractArrow::apply_metadata(entity, d)?,
8539 _ => {}
8540 }
8541 Ok(())
8542 }
8543}
8544
8545#[derive(Bundle)]
8546pub struct SpectralArrowMetadataBundle {
8547 _marker: SpectralArrow,
8548 parent: AbstractArrowMetadataBundle,
8549}
8550impl Default for SpectralArrowMetadataBundle {
8551 fn default() -> Self {
8552 Self {
8553 _marker: SpectralArrow,
8554 parent: AbstractArrowMetadataBundle {
8555 _marker: AbstractArrow,
8556 parent: AbstractEntityMetadataBundle {
8557 _marker: AbstractEntity,
8558 on_fire: OnFire(false),
8559 shift_key_down: ShiftKeyDown(false),
8560 sprinting: Sprinting(false),
8561 swimming: Swimming(false),
8562 currently_glowing: CurrentlyGlowing(false),
8563 invisible: Invisible(false),
8564 fall_flying: FallFlying(false),
8565 air_supply: AirSupply(Default::default()),
8566 custom_name: CustomName(Default::default()),
8567 custom_name_visible: CustomNameVisible(Default::default()),
8568 silent: Silent(Default::default()),
8569 no_gravity: NoGravity(Default::default()),
8570 pose: Pose::default(),
8571 ticks_frozen: TicksFrozen(Default::default()),
8572 },
8573 crit_arrow: CritArrow(false),
8574 no_physics: NoPhysics(false),
8575 pierce_level: PierceLevel(0),
8576 in_ground: InGround(false),
8577 },
8578 }
8579 }
8580}
8581
8582#[derive(Component)]
8583pub struct Spider;
8584impl Spider {
8585 pub fn apply_metadata(
8586 entity: &mut bevy_ecs::system::EntityCommands,
8587 d: EntityDataItem,
8588 ) -> Result<(), UpdateMetadataError> {
8589 match d.index {
8590 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
8591 16 => {
8592 let bitfield = d.value.into_byte()?;
8593 entity.insert(Climbing(bitfield & 0x1 != 0));
8594 }
8595 _ => {}
8596 }
8597 Ok(())
8598 }
8599}
8600
8601#[derive(Bundle)]
8602pub struct SpiderMetadataBundle {
8603 _marker: Spider,
8604 parent: AbstractMonsterMetadataBundle,
8605 climbing: Climbing,
8606}
8607impl Default for SpiderMetadataBundle {
8608 fn default() -> Self {
8609 Self {
8610 _marker: Spider,
8611 parent: AbstractMonsterMetadataBundle {
8612 _marker: AbstractMonster,
8613 parent: AbstractCreatureMetadataBundle {
8614 _marker: AbstractCreature,
8615 parent: AbstractInsentientMetadataBundle {
8616 _marker: AbstractInsentient,
8617 parent: AbstractLivingMetadataBundle {
8618 _marker: AbstractLiving,
8619 parent: AbstractEntityMetadataBundle {
8620 _marker: AbstractEntity,
8621 on_fire: OnFire(false),
8622 shift_key_down: ShiftKeyDown(false),
8623 sprinting: Sprinting(false),
8624 swimming: Swimming(false),
8625 currently_glowing: CurrentlyGlowing(false),
8626 invisible: Invisible(false),
8627 fall_flying: FallFlying(false),
8628 air_supply: AirSupply(Default::default()),
8629 custom_name: CustomName(Default::default()),
8630 custom_name_visible: CustomNameVisible(Default::default()),
8631 silent: Silent(Default::default()),
8632 no_gravity: NoGravity(Default::default()),
8633 pose: Pose::default(),
8634 ticks_frozen: TicksFrozen(Default::default()),
8635 },
8636 auto_spin_attack: AutoSpinAttack(false),
8637 abstract_living_using_item: AbstractLivingUsingItem(false),
8638 health: Health(1.0),
8639 effect_particles: EffectParticles(Default::default()),
8640 effect_ambience: EffectAmbience(false),
8641 arrow_count: ArrowCount(0),
8642 stinger_count: StingerCount(0),
8643 sleeping_pos: SleepingPos(None),
8644 },
8645 no_ai: NoAi(false),
8646 left_handed: LeftHanded(false),
8647 aggressive: Aggressive(false),
8648 },
8649 },
8650 },
8651 climbing: Climbing(false),
8652 }
8653 }
8654}
8655
8656#[derive(Component)]
8657pub struct SplashPotion;
8658impl SplashPotion {
8659 pub fn apply_metadata(
8660 entity: &mut bevy_ecs::system::EntityCommands,
8661 d: EntityDataItem,
8662 ) -> Result<(), UpdateMetadataError> {
8663 match d.index {
8664 0..=8 => AbstractThrownItemProjectile::apply_metadata(entity, d)?,
8665 _ => {}
8666 }
8667 Ok(())
8668 }
8669}
8670
8671#[derive(Bundle)]
8672pub struct SplashPotionMetadataBundle {
8673 _marker: SplashPotion,
8674 parent: AbstractThrownItemProjectileMetadataBundle,
8675}
8676impl Default for SplashPotionMetadataBundle {
8677 fn default() -> Self {
8678 Self {
8679 _marker: SplashPotion,
8680 parent: AbstractThrownItemProjectileMetadataBundle {
8681 _marker: AbstractThrownItemProjectile,
8682 parent: AbstractEntityMetadataBundle {
8683 _marker: AbstractEntity,
8684 on_fire: OnFire(false),
8685 shift_key_down: ShiftKeyDown(false),
8686 sprinting: Sprinting(false),
8687 swimming: Swimming(false),
8688 currently_glowing: CurrentlyGlowing(false),
8689 invisible: Invisible(false),
8690 fall_flying: FallFlying(false),
8691 air_supply: AirSupply(Default::default()),
8692 custom_name: CustomName(Default::default()),
8693 custom_name_visible: CustomNameVisible(Default::default()),
8694 silent: Silent(Default::default()),
8695 no_gravity: NoGravity(Default::default()),
8696 pose: Pose::default(),
8697 ticks_frozen: TicksFrozen(Default::default()),
8698 },
8699 abstract_thrown_item_projectile_item_stack: AbstractThrownItemProjectileItemStack(
8700 Default::default(),
8701 ),
8702 },
8703 }
8704 }
8705}
8706
8707#[derive(Component)]
8708pub struct SpruceBoat;
8709impl SpruceBoat {
8710 pub fn apply_metadata(
8711 entity: &mut bevy_ecs::system::EntityCommands,
8712 d: EntityDataItem,
8713 ) -> Result<(), UpdateMetadataError> {
8714 match d.index {
8715 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
8716 _ => {}
8717 }
8718 Ok(())
8719 }
8720}
8721
8722#[derive(Bundle)]
8723pub struct SpruceBoatMetadataBundle {
8724 _marker: SpruceBoat,
8725 parent: AbstractBoatMetadataBundle,
8726}
8727impl Default for SpruceBoatMetadataBundle {
8728 fn default() -> Self {
8729 Self {
8730 _marker: SpruceBoat,
8731 parent: AbstractBoatMetadataBundle {
8732 _marker: AbstractBoat,
8733 parent: AbstractVehicleMetadataBundle {
8734 _marker: AbstractVehicle,
8735 parent: AbstractEntityMetadataBundle {
8736 _marker: AbstractEntity,
8737 on_fire: OnFire(false),
8738 shift_key_down: ShiftKeyDown(false),
8739 sprinting: Sprinting(false),
8740 swimming: Swimming(false),
8741 currently_glowing: CurrentlyGlowing(false),
8742 invisible: Invisible(false),
8743 fall_flying: FallFlying(false),
8744 air_supply: AirSupply(Default::default()),
8745 custom_name: CustomName(Default::default()),
8746 custom_name_visible: CustomNameVisible(Default::default()),
8747 silent: Silent(Default::default()),
8748 no_gravity: NoGravity(Default::default()),
8749 pose: Pose::default(),
8750 ticks_frozen: TicksFrozen(Default::default()),
8751 },
8752 hurt: Hurt(0),
8753 hurtdir: Hurtdir(1),
8754 damage: Damage(0.0),
8755 },
8756 paddle_left: PaddleLeft(false),
8757 paddle_right: PaddleRight(false),
8758 bubble_time: BubbleTime(0),
8759 },
8760 }
8761 }
8762}
8763
8764#[derive(Component)]
8765pub struct SpruceChestBoat;
8766impl SpruceChestBoat {
8767 pub fn apply_metadata(
8768 entity: &mut bevy_ecs::system::EntityCommands,
8769 d: EntityDataItem,
8770 ) -> Result<(), UpdateMetadataError> {
8771 match d.index {
8772 0..=13 => AbstractBoat::apply_metadata(entity, d)?,
8773 _ => {}
8774 }
8775 Ok(())
8776 }
8777}
8778
8779#[derive(Bundle)]
8780pub struct SpruceChestBoatMetadataBundle {
8781 _marker: SpruceChestBoat,
8782 parent: AbstractBoatMetadataBundle,
8783}
8784impl Default for SpruceChestBoatMetadataBundle {
8785 fn default() -> Self {
8786 Self {
8787 _marker: SpruceChestBoat,
8788 parent: AbstractBoatMetadataBundle {
8789 _marker: AbstractBoat,
8790 parent: AbstractVehicleMetadataBundle {
8791 _marker: AbstractVehicle,
8792 parent: AbstractEntityMetadataBundle {
8793 _marker: AbstractEntity,
8794 on_fire: OnFire(false),
8795 shift_key_down: ShiftKeyDown(false),
8796 sprinting: Sprinting(false),
8797 swimming: Swimming(false),
8798 currently_glowing: CurrentlyGlowing(false),
8799 invisible: Invisible(false),
8800 fall_flying: FallFlying(false),
8801 air_supply: AirSupply(Default::default()),
8802 custom_name: CustomName(Default::default()),
8803 custom_name_visible: CustomNameVisible(Default::default()),
8804 silent: Silent(Default::default()),
8805 no_gravity: NoGravity(Default::default()),
8806 pose: Pose::default(),
8807 ticks_frozen: TicksFrozen(Default::default()),
8808 },
8809 hurt: Hurt(0),
8810 hurtdir: Hurtdir(1),
8811 damage: Damage(0.0),
8812 },
8813 paddle_left: PaddleLeft(false),
8814 paddle_right: PaddleRight(false),
8815 bubble_time: BubbleTime(0),
8816 },
8817 }
8818 }
8819}
8820
8821#[derive(Component)]
8822pub struct Squid;
8823impl Squid {
8824 pub fn apply_metadata(
8825 entity: &mut bevy_ecs::system::EntityCommands,
8826 d: EntityDataItem,
8827 ) -> Result<(), UpdateMetadataError> {
8828 match d.index {
8829 0..=16 => AbstractAgeable::apply_metadata(entity, d)?,
8830 _ => {}
8831 }
8832 Ok(())
8833 }
8834}
8835
8836#[derive(Bundle)]
8837pub struct SquidMetadataBundle {
8838 _marker: Squid,
8839 parent: AbstractAgeableMetadataBundle,
8840}
8841impl Default for SquidMetadataBundle {
8842 fn default() -> Self {
8843 Self {
8844 _marker: Squid,
8845 parent: AbstractAgeableMetadataBundle {
8846 _marker: AbstractAgeable,
8847 parent: AbstractCreatureMetadataBundle {
8848 _marker: AbstractCreature,
8849 parent: AbstractInsentientMetadataBundle {
8850 _marker: AbstractInsentient,
8851 parent: AbstractLivingMetadataBundle {
8852 _marker: AbstractLiving,
8853 parent: AbstractEntityMetadataBundle {
8854 _marker: AbstractEntity,
8855 on_fire: OnFire(false),
8856 shift_key_down: ShiftKeyDown(false),
8857 sprinting: Sprinting(false),
8858 swimming: Swimming(false),
8859 currently_glowing: CurrentlyGlowing(false),
8860 invisible: Invisible(false),
8861 fall_flying: FallFlying(false),
8862 air_supply: AirSupply(Default::default()),
8863 custom_name: CustomName(Default::default()),
8864 custom_name_visible: CustomNameVisible(Default::default()),
8865 silent: Silent(Default::default()),
8866 no_gravity: NoGravity(Default::default()),
8867 pose: Pose::default(),
8868 ticks_frozen: TicksFrozen(Default::default()),
8869 },
8870 auto_spin_attack: AutoSpinAttack(false),
8871 abstract_living_using_item: AbstractLivingUsingItem(false),
8872 health: Health(1.0),
8873 effect_particles: EffectParticles(Default::default()),
8874 effect_ambience: EffectAmbience(false),
8875 arrow_count: ArrowCount(0),
8876 stinger_count: StingerCount(0),
8877 sleeping_pos: SleepingPos(None),
8878 },
8879 no_ai: NoAi(false),
8880 left_handed: LeftHanded(false),
8881 aggressive: Aggressive(false),
8882 },
8883 },
8884 abstract_ageable_baby: AbstractAgeableBaby(false),
8885 },
8886 }
8887 }
8888}
8889
8890#[derive(Component)]
8891pub struct Stray;
8892impl Stray {
8893 pub fn apply_metadata(
8894 entity: &mut bevy_ecs::system::EntityCommands,
8895 d: EntityDataItem,
8896 ) -> Result<(), UpdateMetadataError> {
8897 match d.index {
8898 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
8899 _ => {}
8900 }
8901 Ok(())
8902 }
8903}
8904
8905#[derive(Bundle)]
8906pub struct StrayMetadataBundle {
8907 _marker: Stray,
8908 parent: AbstractMonsterMetadataBundle,
8909}
8910impl Default for StrayMetadataBundle {
8911 fn default() -> Self {
8912 Self {
8913 _marker: Stray,
8914 parent: AbstractMonsterMetadataBundle {
8915 _marker: AbstractMonster,
8916 parent: AbstractCreatureMetadataBundle {
8917 _marker: AbstractCreature,
8918 parent: AbstractInsentientMetadataBundle {
8919 _marker: AbstractInsentient,
8920 parent: AbstractLivingMetadataBundle {
8921 _marker: AbstractLiving,
8922 parent: AbstractEntityMetadataBundle {
8923 _marker: AbstractEntity,
8924 on_fire: OnFire(false),
8925 shift_key_down: ShiftKeyDown(false),
8926 sprinting: Sprinting(false),
8927 swimming: Swimming(false),
8928 currently_glowing: CurrentlyGlowing(false),
8929 invisible: Invisible(false),
8930 fall_flying: FallFlying(false),
8931 air_supply: AirSupply(Default::default()),
8932 custom_name: CustomName(Default::default()),
8933 custom_name_visible: CustomNameVisible(Default::default()),
8934 silent: Silent(Default::default()),
8935 no_gravity: NoGravity(Default::default()),
8936 pose: Pose::default(),
8937 ticks_frozen: TicksFrozen(Default::default()),
8938 },
8939 auto_spin_attack: AutoSpinAttack(false),
8940 abstract_living_using_item: AbstractLivingUsingItem(false),
8941 health: Health(1.0),
8942 effect_particles: EffectParticles(Default::default()),
8943 effect_ambience: EffectAmbience(false),
8944 arrow_count: ArrowCount(0),
8945 stinger_count: StingerCount(0),
8946 sleeping_pos: SleepingPos(None),
8947 },
8948 no_ai: NoAi(false),
8949 left_handed: LeftHanded(false),
8950 aggressive: Aggressive(false),
8951 },
8952 },
8953 },
8954 }
8955 }
8956}
8957
8958#[derive(Component, Deref, DerefMut, Clone)]
8959pub struct StriderBoostTime(pub i32);
8960#[derive(Component, Deref, DerefMut, Clone)]
8961pub struct Suffocating(pub bool);
8962#[derive(Component)]
8963pub struct Strider;
8964impl Strider {
8965 pub fn apply_metadata(
8966 entity: &mut bevy_ecs::system::EntityCommands,
8967 d: EntityDataItem,
8968 ) -> Result<(), UpdateMetadataError> {
8969 match d.index {
8970 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
8971 17 => {
8972 entity.insert(StriderBoostTime(d.value.into_int()?));
8973 }
8974 18 => {
8975 entity.insert(Suffocating(d.value.into_boolean()?));
8976 }
8977 _ => {}
8978 }
8979 Ok(())
8980 }
8981}
8982
8983#[derive(Bundle)]
8984pub struct StriderMetadataBundle {
8985 _marker: Strider,
8986 parent: AbstractAnimalMetadataBundle,
8987 strider_boost_time: StriderBoostTime,
8988 suffocating: Suffocating,
8989}
8990impl Default for StriderMetadataBundle {
8991 fn default() -> Self {
8992 Self {
8993 _marker: Strider,
8994 parent: AbstractAnimalMetadataBundle {
8995 _marker: AbstractAnimal,
8996 parent: AbstractAgeableMetadataBundle {
8997 _marker: AbstractAgeable,
8998 parent: AbstractCreatureMetadataBundle {
8999 _marker: AbstractCreature,
9000 parent: AbstractInsentientMetadataBundle {
9001 _marker: AbstractInsentient,
9002 parent: AbstractLivingMetadataBundle {
9003 _marker: AbstractLiving,
9004 parent: AbstractEntityMetadataBundle {
9005 _marker: AbstractEntity,
9006 on_fire: OnFire(false),
9007 shift_key_down: ShiftKeyDown(false),
9008 sprinting: Sprinting(false),
9009 swimming: Swimming(false),
9010 currently_glowing: CurrentlyGlowing(false),
9011 invisible: Invisible(false),
9012 fall_flying: FallFlying(false),
9013 air_supply: AirSupply(Default::default()),
9014 custom_name: CustomName(Default::default()),
9015 custom_name_visible: CustomNameVisible(Default::default()),
9016 silent: Silent(Default::default()),
9017 no_gravity: NoGravity(Default::default()),
9018 pose: Pose::default(),
9019 ticks_frozen: TicksFrozen(Default::default()),
9020 },
9021 auto_spin_attack: AutoSpinAttack(false),
9022 abstract_living_using_item: AbstractLivingUsingItem(false),
9023 health: Health(1.0),
9024 effect_particles: EffectParticles(Default::default()),
9025 effect_ambience: EffectAmbience(false),
9026 arrow_count: ArrowCount(0),
9027 stinger_count: StingerCount(0),
9028 sleeping_pos: SleepingPos(None),
9029 },
9030 no_ai: NoAi(false),
9031 left_handed: LeftHanded(false),
9032 aggressive: Aggressive(false),
9033 },
9034 },
9035 abstract_ageable_baby: AbstractAgeableBaby(false),
9036 },
9037 },
9038 strider_boost_time: StriderBoostTime(0),
9039 suffocating: Suffocating(false),
9040 }
9041 }
9042}
9043
9044#[derive(Component, Deref, DerefMut, Clone)]
9045pub struct TadpoleFromBucket(pub bool);
9046#[derive(Component)]
9047pub struct Tadpole;
9048impl Tadpole {
9049 pub fn apply_metadata(
9050 entity: &mut bevy_ecs::system::EntityCommands,
9051 d: EntityDataItem,
9052 ) -> Result<(), UpdateMetadataError> {
9053 match d.index {
9054 0..=15 => AbstractCreature::apply_metadata(entity, d)?,
9055 16 => {
9056 entity.insert(TadpoleFromBucket(d.value.into_boolean()?));
9057 }
9058 _ => {}
9059 }
9060 Ok(())
9061 }
9062}
9063
9064#[derive(Bundle)]
9065pub struct TadpoleMetadataBundle {
9066 _marker: Tadpole,
9067 parent: AbstractCreatureMetadataBundle,
9068 tadpole_from_bucket: TadpoleFromBucket,
9069}
9070impl Default for TadpoleMetadataBundle {
9071 fn default() -> Self {
9072 Self {
9073 _marker: Tadpole,
9074 parent: AbstractCreatureMetadataBundle {
9075 _marker: AbstractCreature,
9076 parent: AbstractInsentientMetadataBundle {
9077 _marker: AbstractInsentient,
9078 parent: AbstractLivingMetadataBundle {
9079 _marker: AbstractLiving,
9080 parent: AbstractEntityMetadataBundle {
9081 _marker: AbstractEntity,
9082 on_fire: OnFire(false),
9083 shift_key_down: ShiftKeyDown(false),
9084 sprinting: Sprinting(false),
9085 swimming: Swimming(false),
9086 currently_glowing: CurrentlyGlowing(false),
9087 invisible: Invisible(false),
9088 fall_flying: FallFlying(false),
9089 air_supply: AirSupply(Default::default()),
9090 custom_name: CustomName(Default::default()),
9091 custom_name_visible: CustomNameVisible(Default::default()),
9092 silent: Silent(Default::default()),
9093 no_gravity: NoGravity(Default::default()),
9094 pose: Pose::default(),
9095 ticks_frozen: TicksFrozen(Default::default()),
9096 },
9097 auto_spin_attack: AutoSpinAttack(false),
9098 abstract_living_using_item: AbstractLivingUsingItem(false),
9099 health: Health(1.0),
9100 effect_particles: EffectParticles(Default::default()),
9101 effect_ambience: EffectAmbience(false),
9102 arrow_count: ArrowCount(0),
9103 stinger_count: StingerCount(0),
9104 sleeping_pos: SleepingPos(None),
9105 },
9106 no_ai: NoAi(false),
9107 left_handed: LeftHanded(false),
9108 aggressive: Aggressive(false),
9109 },
9110 },
9111 tadpole_from_bucket: TadpoleFromBucket(false),
9112 }
9113 }
9114}
9115
9116#[derive(Component, Deref, DerefMut, Clone)]
9117pub struct Text(pub FormattedText);
9118#[derive(Component, Deref, DerefMut, Clone)]
9119pub struct LineWidth(pub i32);
9120#[derive(Component, Deref, DerefMut, Clone)]
9121pub struct BackgroundColor(pub i32);
9122#[derive(Component, Deref, DerefMut, Clone)]
9123pub struct TextOpacity(pub u8);
9124#[derive(Component, Deref, DerefMut, Clone)]
9125pub struct StyleFlags(pub u8);
9126#[derive(Component)]
9127pub struct TextDisplay;
9128impl TextDisplay {
9129 pub fn apply_metadata(
9130 entity: &mut bevy_ecs::system::EntityCommands,
9131 d: EntityDataItem,
9132 ) -> Result<(), UpdateMetadataError> {
9133 match d.index {
9134 0..=22 => AbstractDisplay::apply_metadata(entity, d)?,
9135 23 => {
9136 entity.insert(Text(d.value.into_formatted_text()?));
9137 }
9138 24 => {
9139 entity.insert(LineWidth(d.value.into_int()?));
9140 }
9141 25 => {
9142 entity.insert(BackgroundColor(d.value.into_int()?));
9143 }
9144 26 => {
9145 entity.insert(TextOpacity(d.value.into_byte()?));
9146 }
9147 27 => {
9148 entity.insert(StyleFlags(d.value.into_byte()?));
9149 }
9150 _ => {}
9151 }
9152 Ok(())
9153 }
9154}
9155
9156#[derive(Bundle)]
9157pub struct TextDisplayMetadataBundle {
9158 _marker: TextDisplay,
9159 parent: AbstractDisplayMetadataBundle,
9160 text: Text,
9161 line_width: LineWidth,
9162 background_color: BackgroundColor,
9163 text_opacity: TextOpacity,
9164 style_flags: StyleFlags,
9165}
9166impl Default for TextDisplayMetadataBundle {
9167 fn default() -> Self {
9168 Self {
9169 _marker: TextDisplay,
9170 parent: AbstractDisplayMetadataBundle {
9171 _marker: AbstractDisplay,
9172 parent: AbstractEntityMetadataBundle {
9173 _marker: AbstractEntity,
9174 on_fire: OnFire(false),
9175 shift_key_down: ShiftKeyDown(false),
9176 sprinting: Sprinting(false),
9177 swimming: Swimming(false),
9178 currently_glowing: CurrentlyGlowing(false),
9179 invisible: Invisible(false),
9180 fall_flying: FallFlying(false),
9181 air_supply: AirSupply(Default::default()),
9182 custom_name: CustomName(Default::default()),
9183 custom_name_visible: CustomNameVisible(Default::default()),
9184 silent: Silent(Default::default()),
9185 no_gravity: NoGravity(Default::default()),
9186 pose: Pose::default(),
9187 ticks_frozen: TicksFrozen(Default::default()),
9188 },
9189 transformation_interpolation_start_delta_ticks:
9190 TransformationInterpolationStartDeltaTicks(0),
9191 transformation_interpolation_duration: TransformationInterpolationDuration(0),
9192 pos_rot_interpolation_duration: PosRotInterpolationDuration(0),
9193 translation: Translation(Vec3 {
9194 x: 0.0,
9195 y: 0.0,
9196 z: 0.0,
9197 }),
9198 scale: Scale(Vec3 {
9199 x: 1.0,
9200 y: 1.0,
9201 z: 1.0,
9202 }),
9203 left_rotation: LeftRotation(Quaternion {
9204 x: 0.0,
9205 y: 0.0,
9206 z: 0.0,
9207 w: 1.0,
9208 }),
9209 right_rotation: RightRotation(Quaternion {
9210 x: 0.0,
9211 y: 0.0,
9212 z: 0.0,
9213 w: 1.0,
9214 }),
9215 billboard_render_constraints: BillboardRenderConstraints(Default::default()),
9216 brightness_override: BrightnessOverride(-1),
9217 view_range: ViewRange(1.0),
9218 shadow_radius: ShadowRadius(0.0),
9219 shadow_strength: ShadowStrength(1.0),
9220 abstract_display_width: AbstractDisplayWidth(0.0),
9221 abstract_display_height: AbstractDisplayHeight(0.0),
9222 glow_color_override: GlowColorOverride(-1),
9223 },
9224 text: Text(Default::default()),
9225 line_width: LineWidth(200),
9226 background_color: BackgroundColor(1073741824),
9227 text_opacity: TextOpacity(127),
9228 style_flags: StyleFlags(0),
9229 }
9230 }
9231}
9232
9233#[derive(Component, Deref, DerefMut, Clone)]
9234pub struct Fuse(pub i32);
9235#[derive(Component, Deref, DerefMut, Clone)]
9236pub struct TntBlockState(pub azalea_block::BlockState);
9237#[derive(Component)]
9238pub struct Tnt;
9239impl Tnt {
9240 pub fn apply_metadata(
9241 entity: &mut bevy_ecs::system::EntityCommands,
9242 d: EntityDataItem,
9243 ) -> Result<(), UpdateMetadataError> {
9244 match d.index {
9245 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
9246 8 => {
9247 entity.insert(Fuse(d.value.into_int()?));
9248 }
9249 9 => {
9250 entity.insert(TntBlockState(d.value.into_block_state()?));
9251 }
9252 _ => {}
9253 }
9254 Ok(())
9255 }
9256}
9257
9258#[derive(Bundle)]
9259pub struct TntMetadataBundle {
9260 _marker: Tnt,
9261 parent: AbstractEntityMetadataBundle,
9262 fuse: Fuse,
9263 tnt_block_state: TntBlockState,
9264}
9265impl Default for TntMetadataBundle {
9266 fn default() -> Self {
9267 Self {
9268 _marker: Tnt,
9269 parent: AbstractEntityMetadataBundle {
9270 _marker: AbstractEntity,
9271 on_fire: OnFire(false),
9272 shift_key_down: ShiftKeyDown(false),
9273 sprinting: Sprinting(false),
9274 swimming: Swimming(false),
9275 currently_glowing: CurrentlyGlowing(false),
9276 invisible: Invisible(false),
9277 fall_flying: FallFlying(false),
9278 air_supply: AirSupply(Default::default()),
9279 custom_name: CustomName(Default::default()),
9280 custom_name_visible: CustomNameVisible(Default::default()),
9281 silent: Silent(Default::default()),
9282 no_gravity: NoGravity(Default::default()),
9283 pose: Pose::default(),
9284 ticks_frozen: TicksFrozen(Default::default()),
9285 },
9286 fuse: Fuse(80),
9287 tnt_block_state: TntBlockState(Default::default()),
9288 }
9289 }
9290}
9291
9292#[derive(Component)]
9293pub struct TntMinecart;
9294impl TntMinecart {
9295 pub fn apply_metadata(
9296 entity: &mut bevy_ecs::system::EntityCommands,
9297 d: EntityDataItem,
9298 ) -> Result<(), UpdateMetadataError> {
9299 match d.index {
9300 0..=12 => AbstractMinecart::apply_metadata(entity, d)?,
9301 _ => {}
9302 }
9303 Ok(())
9304 }
9305}
9306
9307#[derive(Bundle)]
9308pub struct TntMinecartMetadataBundle {
9309 _marker: TntMinecart,
9310 parent: AbstractMinecartMetadataBundle,
9311}
9312impl Default for TntMinecartMetadataBundle {
9313 fn default() -> Self {
9314 Self {
9315 _marker: TntMinecart,
9316 parent: AbstractMinecartMetadataBundle {
9317 _marker: AbstractMinecart,
9318 parent: AbstractVehicleMetadataBundle {
9319 _marker: AbstractVehicle,
9320 parent: AbstractEntityMetadataBundle {
9321 _marker: AbstractEntity,
9322 on_fire: OnFire(false),
9323 shift_key_down: ShiftKeyDown(false),
9324 sprinting: Sprinting(false),
9325 swimming: Swimming(false),
9326 currently_glowing: CurrentlyGlowing(false),
9327 invisible: Invisible(false),
9328 fall_flying: FallFlying(false),
9329 air_supply: AirSupply(Default::default()),
9330 custom_name: CustomName(Default::default()),
9331 custom_name_visible: CustomNameVisible(Default::default()),
9332 silent: Silent(Default::default()),
9333 no_gravity: NoGravity(Default::default()),
9334 pose: Pose::default(),
9335 ticks_frozen: TicksFrozen(Default::default()),
9336 },
9337 hurt: Hurt(0),
9338 hurtdir: Hurtdir(1),
9339 damage: Damage(0.0),
9340 },
9341 custom_display_block: CustomDisplayBlock(azalea_block::BlockState::AIR),
9342 display_offset: DisplayOffset(Default::default()),
9343 },
9344 }
9345 }
9346}
9347
9348#[derive(Component)]
9349pub struct TraderLlama;
9350impl TraderLlama {
9351 pub fn apply_metadata(
9352 entity: &mut bevy_ecs::system::EntityCommands,
9353 d: EntityDataItem,
9354 ) -> Result<(), UpdateMetadataError> {
9355 match d.index {
9356 0..=20 => Llama::apply_metadata(entity, d)?,
9357 _ => {}
9358 }
9359 Ok(())
9360 }
9361}
9362
9363#[derive(Bundle)]
9364pub struct TraderLlamaMetadataBundle {
9365 _marker: TraderLlama,
9366 parent: LlamaMetadataBundle,
9367}
9368impl Default for TraderLlamaMetadataBundle {
9369 fn default() -> Self {
9370 Self {
9371 _marker: TraderLlama,
9372 parent: LlamaMetadataBundle {
9373 _marker: Llama,
9374 parent: AbstractChestedHorseMetadataBundle {
9375 _marker: AbstractChestedHorse,
9376 parent: AbstractHorseMetadataBundle {
9377 _marker: AbstractHorse,
9378 parent: AbstractAnimalMetadataBundle {
9379 _marker: AbstractAnimal,
9380 parent: AbstractAgeableMetadataBundle {
9381 _marker: AbstractAgeable,
9382 parent: AbstractCreatureMetadataBundle {
9383 _marker: AbstractCreature,
9384 parent: AbstractInsentientMetadataBundle {
9385 _marker: AbstractInsentient,
9386 parent: AbstractLivingMetadataBundle {
9387 _marker: AbstractLiving,
9388 parent: AbstractEntityMetadataBundle {
9389 _marker: AbstractEntity,
9390 on_fire: OnFire(false),
9391 shift_key_down: ShiftKeyDown(false),
9392 sprinting: Sprinting(false),
9393 swimming: Swimming(false),
9394 currently_glowing: CurrentlyGlowing(false),
9395 invisible: Invisible(false),
9396 fall_flying: FallFlying(false),
9397 air_supply: AirSupply(Default::default()),
9398 custom_name: CustomName(Default::default()),
9399 custom_name_visible: CustomNameVisible(
9400 Default::default(),
9401 ),
9402 silent: Silent(Default::default()),
9403 no_gravity: NoGravity(Default::default()),
9404 pose: Pose::default(),
9405 ticks_frozen: TicksFrozen(Default::default()),
9406 },
9407 auto_spin_attack: AutoSpinAttack(false),
9408 abstract_living_using_item: AbstractLivingUsingItem(
9409 false,
9410 ),
9411 health: Health(1.0),
9412 effect_particles: EffectParticles(Default::default()),
9413 effect_ambience: EffectAmbience(false),
9414 arrow_count: ArrowCount(0),
9415 stinger_count: StingerCount(0),
9416 sleeping_pos: SleepingPos(None),
9417 },
9418 no_ai: NoAi(false),
9419 left_handed: LeftHanded(false),
9420 aggressive: Aggressive(false),
9421 },
9422 },
9423 abstract_ageable_baby: AbstractAgeableBaby(false),
9424 },
9425 },
9426 tamed: Tamed(false),
9427 eating: Eating(false),
9428 abstract_horse_standing: AbstractHorseStanding(false),
9429 bred: Bred(false),
9430 },
9431 chest: Chest(false),
9432 },
9433 strength: Strength(0),
9434 llama_variant: LlamaVariant(0),
9435 },
9436 }
9437 }
9438}
9439
9440#[derive(Component, Deref, DerefMut, Clone)]
9441pub struct Loyalty(pub u8);
9442#[derive(Component, Deref, DerefMut, Clone)]
9443pub struct Foil(pub bool);
9444#[derive(Component)]
9445pub struct Trident;
9446impl Trident {
9447 pub fn apply_metadata(
9448 entity: &mut bevy_ecs::system::EntityCommands,
9449 d: EntityDataItem,
9450 ) -> Result<(), UpdateMetadataError> {
9451 match d.index {
9452 0..=10 => AbstractArrow::apply_metadata(entity, d)?,
9453 11 => {
9454 entity.insert(Loyalty(d.value.into_byte()?));
9455 }
9456 12 => {
9457 entity.insert(Foil(d.value.into_boolean()?));
9458 }
9459 _ => {}
9460 }
9461 Ok(())
9462 }
9463}
9464
9465#[derive(Bundle)]
9466pub struct TridentMetadataBundle {
9467 _marker: Trident,
9468 parent: AbstractArrowMetadataBundle,
9469 loyalty: Loyalty,
9470 foil: Foil,
9471}
9472impl Default for TridentMetadataBundle {
9473 fn default() -> Self {
9474 Self {
9475 _marker: Trident,
9476 parent: AbstractArrowMetadataBundle {
9477 _marker: AbstractArrow,
9478 parent: AbstractEntityMetadataBundle {
9479 _marker: AbstractEntity,
9480 on_fire: OnFire(false),
9481 shift_key_down: ShiftKeyDown(false),
9482 sprinting: Sprinting(false),
9483 swimming: Swimming(false),
9484 currently_glowing: CurrentlyGlowing(false),
9485 invisible: Invisible(false),
9486 fall_flying: FallFlying(false),
9487 air_supply: AirSupply(Default::default()),
9488 custom_name: CustomName(Default::default()),
9489 custom_name_visible: CustomNameVisible(Default::default()),
9490 silent: Silent(Default::default()),
9491 no_gravity: NoGravity(Default::default()),
9492 pose: Pose::default(),
9493 ticks_frozen: TicksFrozen(Default::default()),
9494 },
9495 crit_arrow: CritArrow(false),
9496 no_physics: NoPhysics(false),
9497 pierce_level: PierceLevel(0),
9498 in_ground: InGround(false),
9499 },
9500 loyalty: Loyalty(0),
9501 foil: Foil(false),
9502 }
9503 }
9504}
9505
9506#[derive(Component, Deref, DerefMut, Clone)]
9507pub struct TropicalFishTypeVariant(pub i32);
9508#[derive(Component)]
9509pub struct TropicalFish;
9510impl TropicalFish {
9511 pub fn apply_metadata(
9512 entity: &mut bevy_ecs::system::EntityCommands,
9513 d: EntityDataItem,
9514 ) -> Result<(), UpdateMetadataError> {
9515 match d.index {
9516 0..=16 => AbstractFish::apply_metadata(entity, d)?,
9517 17 => {
9518 entity.insert(TropicalFishTypeVariant(d.value.into_int()?));
9519 }
9520 _ => {}
9521 }
9522 Ok(())
9523 }
9524}
9525
9526#[derive(Bundle)]
9527pub struct TropicalFishMetadataBundle {
9528 _marker: TropicalFish,
9529 parent: AbstractFishMetadataBundle,
9530 tropical_fish_type_variant: TropicalFishTypeVariant,
9531}
9532impl Default for TropicalFishMetadataBundle {
9533 fn default() -> Self {
9534 Self {
9535 _marker: TropicalFish,
9536 parent: AbstractFishMetadataBundle {
9537 _marker: AbstractFish,
9538 parent: AbstractCreatureMetadataBundle {
9539 _marker: AbstractCreature,
9540 parent: AbstractInsentientMetadataBundle {
9541 _marker: AbstractInsentient,
9542 parent: AbstractLivingMetadataBundle {
9543 _marker: AbstractLiving,
9544 parent: AbstractEntityMetadataBundle {
9545 _marker: AbstractEntity,
9546 on_fire: OnFire(false),
9547 shift_key_down: ShiftKeyDown(false),
9548 sprinting: Sprinting(false),
9549 swimming: Swimming(false),
9550 currently_glowing: CurrentlyGlowing(false),
9551 invisible: Invisible(false),
9552 fall_flying: FallFlying(false),
9553 air_supply: AirSupply(Default::default()),
9554 custom_name: CustomName(Default::default()),
9555 custom_name_visible: CustomNameVisible(Default::default()),
9556 silent: Silent(Default::default()),
9557 no_gravity: NoGravity(Default::default()),
9558 pose: Pose::default(),
9559 ticks_frozen: TicksFrozen(Default::default()),
9560 },
9561 auto_spin_attack: AutoSpinAttack(false),
9562 abstract_living_using_item: AbstractLivingUsingItem(false),
9563 health: Health(1.0),
9564 effect_particles: EffectParticles(Default::default()),
9565 effect_ambience: EffectAmbience(false),
9566 arrow_count: ArrowCount(0),
9567 stinger_count: StingerCount(0),
9568 sleeping_pos: SleepingPos(None),
9569 },
9570 no_ai: NoAi(false),
9571 left_handed: LeftHanded(false),
9572 aggressive: Aggressive(false),
9573 },
9574 },
9575 abstract_fish_from_bucket: AbstractFishFromBucket(false),
9576 },
9577 tropical_fish_type_variant: TropicalFishTypeVariant(Default::default()),
9578 }
9579 }
9580}
9581
9582#[derive(Component, Deref, DerefMut, Clone)]
9583pub struct HasEgg(pub bool);
9584#[derive(Component, Deref, DerefMut, Clone)]
9585pub struct LayingEgg(pub bool);
9586#[derive(Component)]
9587pub struct Turtle;
9588impl Turtle {
9589 pub fn apply_metadata(
9590 entity: &mut bevy_ecs::system::EntityCommands,
9591 d: EntityDataItem,
9592 ) -> Result<(), UpdateMetadataError> {
9593 match d.index {
9594 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
9595 17 => {
9596 entity.insert(HasEgg(d.value.into_boolean()?));
9597 }
9598 18 => {
9599 entity.insert(LayingEgg(d.value.into_boolean()?));
9600 }
9601 _ => {}
9602 }
9603 Ok(())
9604 }
9605}
9606
9607#[derive(Bundle)]
9608pub struct TurtleMetadataBundle {
9609 _marker: Turtle,
9610 parent: AbstractAnimalMetadataBundle,
9611 has_egg: HasEgg,
9612 laying_egg: LayingEgg,
9613}
9614impl Default for TurtleMetadataBundle {
9615 fn default() -> Self {
9616 Self {
9617 _marker: Turtle,
9618 parent: AbstractAnimalMetadataBundle {
9619 _marker: AbstractAnimal,
9620 parent: AbstractAgeableMetadataBundle {
9621 _marker: AbstractAgeable,
9622 parent: AbstractCreatureMetadataBundle {
9623 _marker: AbstractCreature,
9624 parent: AbstractInsentientMetadataBundle {
9625 _marker: AbstractInsentient,
9626 parent: AbstractLivingMetadataBundle {
9627 _marker: AbstractLiving,
9628 parent: AbstractEntityMetadataBundle {
9629 _marker: AbstractEntity,
9630 on_fire: OnFire(false),
9631 shift_key_down: ShiftKeyDown(false),
9632 sprinting: Sprinting(false),
9633 swimming: Swimming(false),
9634 currently_glowing: CurrentlyGlowing(false),
9635 invisible: Invisible(false),
9636 fall_flying: FallFlying(false),
9637 air_supply: AirSupply(Default::default()),
9638 custom_name: CustomName(Default::default()),
9639 custom_name_visible: CustomNameVisible(Default::default()),
9640 silent: Silent(Default::default()),
9641 no_gravity: NoGravity(Default::default()),
9642 pose: Pose::default(),
9643 ticks_frozen: TicksFrozen(Default::default()),
9644 },
9645 auto_spin_attack: AutoSpinAttack(false),
9646 abstract_living_using_item: AbstractLivingUsingItem(false),
9647 health: Health(1.0),
9648 effect_particles: EffectParticles(Default::default()),
9649 effect_ambience: EffectAmbience(false),
9650 arrow_count: ArrowCount(0),
9651 stinger_count: StingerCount(0),
9652 sleeping_pos: SleepingPos(None),
9653 },
9654 no_ai: NoAi(false),
9655 left_handed: LeftHanded(false),
9656 aggressive: Aggressive(false),
9657 },
9658 },
9659 abstract_ageable_baby: AbstractAgeableBaby(false),
9660 },
9661 },
9662 has_egg: HasEgg(false),
9663 laying_egg: LayingEgg(false),
9664 }
9665 }
9666}
9667
9668#[derive(Component, Deref, DerefMut, Clone)]
9669pub struct VexFlags(pub u8);
9670#[derive(Component)]
9671pub struct Vex;
9672impl Vex {
9673 pub fn apply_metadata(
9674 entity: &mut bevy_ecs::system::EntityCommands,
9675 d: EntityDataItem,
9676 ) -> Result<(), UpdateMetadataError> {
9677 match d.index {
9678 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
9679 16 => {
9680 entity.insert(VexFlags(d.value.into_byte()?));
9681 }
9682 _ => {}
9683 }
9684 Ok(())
9685 }
9686}
9687
9688#[derive(Bundle)]
9689pub struct VexMetadataBundle {
9690 _marker: Vex,
9691 parent: AbstractMonsterMetadataBundle,
9692 vex_flags: VexFlags,
9693}
9694impl Default for VexMetadataBundle {
9695 fn default() -> Self {
9696 Self {
9697 _marker: Vex,
9698 parent: AbstractMonsterMetadataBundle {
9699 _marker: AbstractMonster,
9700 parent: AbstractCreatureMetadataBundle {
9701 _marker: AbstractCreature,
9702 parent: AbstractInsentientMetadataBundle {
9703 _marker: AbstractInsentient,
9704 parent: AbstractLivingMetadataBundle {
9705 _marker: AbstractLiving,
9706 parent: AbstractEntityMetadataBundle {
9707 _marker: AbstractEntity,
9708 on_fire: OnFire(false),
9709 shift_key_down: ShiftKeyDown(false),
9710 sprinting: Sprinting(false),
9711 swimming: Swimming(false),
9712 currently_glowing: CurrentlyGlowing(false),
9713 invisible: Invisible(false),
9714 fall_flying: FallFlying(false),
9715 air_supply: AirSupply(Default::default()),
9716 custom_name: CustomName(Default::default()),
9717 custom_name_visible: CustomNameVisible(Default::default()),
9718 silent: Silent(Default::default()),
9719 no_gravity: NoGravity(Default::default()),
9720 pose: Pose::default(),
9721 ticks_frozen: TicksFrozen(Default::default()),
9722 },
9723 auto_spin_attack: AutoSpinAttack(false),
9724 abstract_living_using_item: AbstractLivingUsingItem(false),
9725 health: Health(1.0),
9726 effect_particles: EffectParticles(Default::default()),
9727 effect_ambience: EffectAmbience(false),
9728 arrow_count: ArrowCount(0),
9729 stinger_count: StingerCount(0),
9730 sleeping_pos: SleepingPos(None),
9731 },
9732 no_ai: NoAi(false),
9733 left_handed: LeftHanded(false),
9734 aggressive: Aggressive(false),
9735 },
9736 },
9737 },
9738 vex_flags: VexFlags(0),
9739 }
9740 }
9741}
9742
9743#[derive(Component, Deref, DerefMut, Clone)]
9744pub struct AbstractVillagerUnhappyCounter(pub i32);
9745#[derive(Component, Deref, DerefMut, Clone)]
9746pub struct VillagerVillagerData(pub VillagerData);
9747#[derive(Component)]
9748pub struct Villager;
9749impl Villager {
9750 pub fn apply_metadata(
9751 entity: &mut bevy_ecs::system::EntityCommands,
9752 d: EntityDataItem,
9753 ) -> Result<(), UpdateMetadataError> {
9754 match d.index {
9755 0..=17 => AbstractVillager::apply_metadata(entity, d)?,
9756 18 => {
9757 entity.insert(VillagerVillagerData(d.value.into_villager_data()?));
9758 }
9759 _ => {}
9760 }
9761 Ok(())
9762 }
9763}
9764
9765#[derive(Bundle)]
9766pub struct VillagerMetadataBundle {
9767 _marker: Villager,
9768 parent: AbstractVillagerMetadataBundle,
9769 villager_villager_data: VillagerVillagerData,
9770}
9771impl Default for VillagerMetadataBundle {
9772 fn default() -> Self {
9773 Self {
9774 _marker: Villager,
9775 parent: AbstractVillagerMetadataBundle {
9776 _marker: AbstractVillager,
9777 parent: AbstractAgeableMetadataBundle {
9778 _marker: AbstractAgeable,
9779 parent: AbstractCreatureMetadataBundle {
9780 _marker: AbstractCreature,
9781 parent: AbstractInsentientMetadataBundle {
9782 _marker: AbstractInsentient,
9783 parent: AbstractLivingMetadataBundle {
9784 _marker: AbstractLiving,
9785 parent: AbstractEntityMetadataBundle {
9786 _marker: AbstractEntity,
9787 on_fire: OnFire(false),
9788 shift_key_down: ShiftKeyDown(false),
9789 sprinting: Sprinting(false),
9790 swimming: Swimming(false),
9791 currently_glowing: CurrentlyGlowing(false),
9792 invisible: Invisible(false),
9793 fall_flying: FallFlying(false),
9794 air_supply: AirSupply(Default::default()),
9795 custom_name: CustomName(Default::default()),
9796 custom_name_visible: CustomNameVisible(Default::default()),
9797 silent: Silent(Default::default()),
9798 no_gravity: NoGravity(Default::default()),
9799 pose: Pose::default(),
9800 ticks_frozen: TicksFrozen(Default::default()),
9801 },
9802 auto_spin_attack: AutoSpinAttack(false),
9803 abstract_living_using_item: AbstractLivingUsingItem(false),
9804 health: Health(1.0),
9805 effect_particles: EffectParticles(Default::default()),
9806 effect_ambience: EffectAmbience(false),
9807 arrow_count: ArrowCount(0),
9808 stinger_count: StingerCount(0),
9809 sleeping_pos: SleepingPos(None),
9810 },
9811 no_ai: NoAi(false),
9812 left_handed: LeftHanded(false),
9813 aggressive: Aggressive(false),
9814 },
9815 },
9816 abstract_ageable_baby: AbstractAgeableBaby(false),
9817 },
9818 abstract_villager_unhappy_counter: AbstractVillagerUnhappyCounter(0),
9819 },
9820 villager_villager_data: VillagerVillagerData(VillagerData {
9821 kind: azalea_registry::VillagerKind::Plains,
9822 profession: azalea_registry::VillagerProfession::None,
9823 level: 0,
9824 }),
9825 }
9826 }
9827}
9828
9829#[derive(Component)]
9830pub struct Vindicator;
9831impl Vindicator {
9832 pub fn apply_metadata(
9833 entity: &mut bevy_ecs::system::EntityCommands,
9834 d: EntityDataItem,
9835 ) -> Result<(), UpdateMetadataError> {
9836 match d.index {
9837 0..=16 => AbstractRaider::apply_metadata(entity, d)?,
9838 _ => {}
9839 }
9840 Ok(())
9841 }
9842}
9843
9844#[derive(Bundle)]
9845pub struct VindicatorMetadataBundle {
9846 _marker: Vindicator,
9847 parent: AbstractRaiderMetadataBundle,
9848}
9849impl Default for VindicatorMetadataBundle {
9850 fn default() -> Self {
9851 Self {
9852 _marker: Vindicator,
9853 parent: AbstractRaiderMetadataBundle {
9854 _marker: AbstractRaider,
9855 parent: AbstractMonsterMetadataBundle {
9856 _marker: AbstractMonster,
9857 parent: AbstractCreatureMetadataBundle {
9858 _marker: AbstractCreature,
9859 parent: AbstractInsentientMetadataBundle {
9860 _marker: AbstractInsentient,
9861 parent: AbstractLivingMetadataBundle {
9862 _marker: AbstractLiving,
9863 parent: AbstractEntityMetadataBundle {
9864 _marker: AbstractEntity,
9865 on_fire: OnFire(false),
9866 shift_key_down: ShiftKeyDown(false),
9867 sprinting: Sprinting(false),
9868 swimming: Swimming(false),
9869 currently_glowing: CurrentlyGlowing(false),
9870 invisible: Invisible(false),
9871 fall_flying: FallFlying(false),
9872 air_supply: AirSupply(Default::default()),
9873 custom_name: CustomName(Default::default()),
9874 custom_name_visible: CustomNameVisible(Default::default()),
9875 silent: Silent(Default::default()),
9876 no_gravity: NoGravity(Default::default()),
9877 pose: Pose::default(),
9878 ticks_frozen: TicksFrozen(Default::default()),
9879 },
9880 auto_spin_attack: AutoSpinAttack(false),
9881 abstract_living_using_item: AbstractLivingUsingItem(false),
9882 health: Health(1.0),
9883 effect_particles: EffectParticles(Default::default()),
9884 effect_ambience: EffectAmbience(false),
9885 arrow_count: ArrowCount(0),
9886 stinger_count: StingerCount(0),
9887 sleeping_pos: SleepingPos(None),
9888 },
9889 no_ai: NoAi(false),
9890 left_handed: LeftHanded(false),
9891 aggressive: Aggressive(false),
9892 },
9893 },
9894 },
9895 is_celebrating: IsCelebrating(false),
9896 },
9897 }
9898 }
9899}
9900
9901#[derive(Component)]
9902pub struct WanderingTrader;
9903impl WanderingTrader {
9904 pub fn apply_metadata(
9905 entity: &mut bevy_ecs::system::EntityCommands,
9906 d: EntityDataItem,
9907 ) -> Result<(), UpdateMetadataError> {
9908 match d.index {
9909 0..=17 => AbstractVillager::apply_metadata(entity, d)?,
9910 _ => {}
9911 }
9912 Ok(())
9913 }
9914}
9915
9916#[derive(Bundle)]
9917pub struct WanderingTraderMetadataBundle {
9918 _marker: WanderingTrader,
9919 parent: AbstractVillagerMetadataBundle,
9920}
9921impl Default for WanderingTraderMetadataBundle {
9922 fn default() -> Self {
9923 Self {
9924 _marker: WanderingTrader,
9925 parent: AbstractVillagerMetadataBundle {
9926 _marker: AbstractVillager,
9927 parent: AbstractAgeableMetadataBundle {
9928 _marker: AbstractAgeable,
9929 parent: AbstractCreatureMetadataBundle {
9930 _marker: AbstractCreature,
9931 parent: AbstractInsentientMetadataBundle {
9932 _marker: AbstractInsentient,
9933 parent: AbstractLivingMetadataBundle {
9934 _marker: AbstractLiving,
9935 parent: AbstractEntityMetadataBundle {
9936 _marker: AbstractEntity,
9937 on_fire: OnFire(false),
9938 shift_key_down: ShiftKeyDown(false),
9939 sprinting: Sprinting(false),
9940 swimming: Swimming(false),
9941 currently_glowing: CurrentlyGlowing(false),
9942 invisible: Invisible(false),
9943 fall_flying: FallFlying(false),
9944 air_supply: AirSupply(Default::default()),
9945 custom_name: CustomName(Default::default()),
9946 custom_name_visible: CustomNameVisible(Default::default()),
9947 silent: Silent(Default::default()),
9948 no_gravity: NoGravity(Default::default()),
9949 pose: Pose::default(),
9950 ticks_frozen: TicksFrozen(Default::default()),
9951 },
9952 auto_spin_attack: AutoSpinAttack(false),
9953 abstract_living_using_item: AbstractLivingUsingItem(false),
9954 health: Health(1.0),
9955 effect_particles: EffectParticles(Default::default()),
9956 effect_ambience: EffectAmbience(false),
9957 arrow_count: ArrowCount(0),
9958 stinger_count: StingerCount(0),
9959 sleeping_pos: SleepingPos(None),
9960 },
9961 no_ai: NoAi(false),
9962 left_handed: LeftHanded(false),
9963 aggressive: Aggressive(false),
9964 },
9965 },
9966 abstract_ageable_baby: AbstractAgeableBaby(false),
9967 },
9968 abstract_villager_unhappy_counter: AbstractVillagerUnhappyCounter(0),
9969 },
9970 }
9971 }
9972}
9973
9974#[derive(Component, Deref, DerefMut, Clone)]
9975pub struct ClientAngerLevel(pub i32);
9976#[derive(Component)]
9977pub struct Warden;
9978impl Warden {
9979 pub fn apply_metadata(
9980 entity: &mut bevy_ecs::system::EntityCommands,
9981 d: EntityDataItem,
9982 ) -> Result<(), UpdateMetadataError> {
9983 match d.index {
9984 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
9985 16 => {
9986 entity.insert(ClientAngerLevel(d.value.into_int()?));
9987 }
9988 _ => {}
9989 }
9990 Ok(())
9991 }
9992}
9993
9994#[derive(Bundle)]
9995pub struct WardenMetadataBundle {
9996 _marker: Warden,
9997 parent: AbstractMonsterMetadataBundle,
9998 client_anger_level: ClientAngerLevel,
9999}
10000impl Default for WardenMetadataBundle {
10001 fn default() -> Self {
10002 Self {
10003 _marker: Warden,
10004 parent: AbstractMonsterMetadataBundle {
10005 _marker: AbstractMonster,
10006 parent: AbstractCreatureMetadataBundle {
10007 _marker: AbstractCreature,
10008 parent: AbstractInsentientMetadataBundle {
10009 _marker: AbstractInsentient,
10010 parent: AbstractLivingMetadataBundle {
10011 _marker: AbstractLiving,
10012 parent: AbstractEntityMetadataBundle {
10013 _marker: AbstractEntity,
10014 on_fire: OnFire(false),
10015 shift_key_down: ShiftKeyDown(false),
10016 sprinting: Sprinting(false),
10017 swimming: Swimming(false),
10018 currently_glowing: CurrentlyGlowing(false),
10019 invisible: Invisible(false),
10020 fall_flying: FallFlying(false),
10021 air_supply: AirSupply(Default::default()),
10022 custom_name: CustomName(Default::default()),
10023 custom_name_visible: CustomNameVisible(Default::default()),
10024 silent: Silent(Default::default()),
10025 no_gravity: NoGravity(Default::default()),
10026 pose: Pose::default(),
10027 ticks_frozen: TicksFrozen(Default::default()),
10028 },
10029 auto_spin_attack: AutoSpinAttack(false),
10030 abstract_living_using_item: AbstractLivingUsingItem(false),
10031 health: Health(1.0),
10032 effect_particles: EffectParticles(Default::default()),
10033 effect_ambience: EffectAmbience(false),
10034 arrow_count: ArrowCount(0),
10035 stinger_count: StingerCount(0),
10036 sleeping_pos: SleepingPos(None),
10037 },
10038 no_ai: NoAi(false),
10039 left_handed: LeftHanded(false),
10040 aggressive: Aggressive(false),
10041 },
10042 },
10043 },
10044 client_anger_level: ClientAngerLevel(0),
10045 }
10046 }
10047}
10048
10049#[derive(Component)]
10050pub struct WindCharge;
10051impl WindCharge {
10052 pub fn apply_metadata(
10053 entity: &mut bevy_ecs::system::EntityCommands,
10054 d: EntityDataItem,
10055 ) -> Result<(), UpdateMetadataError> {
10056 match d.index {
10057 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
10058 _ => {}
10059 }
10060 Ok(())
10061 }
10062}
10063
10064#[derive(Bundle)]
10065pub struct WindChargeMetadataBundle {
10066 _marker: WindCharge,
10067 parent: AbstractEntityMetadataBundle,
10068}
10069impl Default for WindChargeMetadataBundle {
10070 fn default() -> Self {
10071 Self {
10072 _marker: WindCharge,
10073 parent: AbstractEntityMetadataBundle {
10074 _marker: AbstractEntity,
10075 on_fire: OnFire(false),
10076 shift_key_down: ShiftKeyDown(false),
10077 sprinting: Sprinting(false),
10078 swimming: Swimming(false),
10079 currently_glowing: CurrentlyGlowing(false),
10080 invisible: Invisible(false),
10081 fall_flying: FallFlying(false),
10082 air_supply: AirSupply(Default::default()),
10083 custom_name: CustomName(Default::default()),
10084 custom_name_visible: CustomNameVisible(Default::default()),
10085 silent: Silent(Default::default()),
10086 no_gravity: NoGravity(Default::default()),
10087 pose: Pose::default(),
10088 ticks_frozen: TicksFrozen(Default::default()),
10089 },
10090 }
10091 }
10092}
10093
10094#[derive(Component, Deref, DerefMut, Clone)]
10095pub struct WitchUsingItem(pub bool);
10096#[derive(Component)]
10097pub struct Witch;
10098impl Witch {
10099 pub fn apply_metadata(
10100 entity: &mut bevy_ecs::system::EntityCommands,
10101 d: EntityDataItem,
10102 ) -> Result<(), UpdateMetadataError> {
10103 match d.index {
10104 0..=16 => AbstractRaider::apply_metadata(entity, d)?,
10105 17 => {
10106 entity.insert(WitchUsingItem(d.value.into_boolean()?));
10107 }
10108 _ => {}
10109 }
10110 Ok(())
10111 }
10112}
10113
10114#[derive(Bundle)]
10115pub struct WitchMetadataBundle {
10116 _marker: Witch,
10117 parent: AbstractRaiderMetadataBundle,
10118 witch_using_item: WitchUsingItem,
10119}
10120impl Default for WitchMetadataBundle {
10121 fn default() -> Self {
10122 Self {
10123 _marker: Witch,
10124 parent: AbstractRaiderMetadataBundle {
10125 _marker: AbstractRaider,
10126 parent: AbstractMonsterMetadataBundle {
10127 _marker: AbstractMonster,
10128 parent: AbstractCreatureMetadataBundle {
10129 _marker: AbstractCreature,
10130 parent: AbstractInsentientMetadataBundle {
10131 _marker: AbstractInsentient,
10132 parent: AbstractLivingMetadataBundle {
10133 _marker: AbstractLiving,
10134 parent: AbstractEntityMetadataBundle {
10135 _marker: AbstractEntity,
10136 on_fire: OnFire(false),
10137 shift_key_down: ShiftKeyDown(false),
10138 sprinting: Sprinting(false),
10139 swimming: Swimming(false),
10140 currently_glowing: CurrentlyGlowing(false),
10141 invisible: Invisible(false),
10142 fall_flying: FallFlying(false),
10143 air_supply: AirSupply(Default::default()),
10144 custom_name: CustomName(Default::default()),
10145 custom_name_visible: CustomNameVisible(Default::default()),
10146 silent: Silent(Default::default()),
10147 no_gravity: NoGravity(Default::default()),
10148 pose: Pose::default(),
10149 ticks_frozen: TicksFrozen(Default::default()),
10150 },
10151 auto_spin_attack: AutoSpinAttack(false),
10152 abstract_living_using_item: AbstractLivingUsingItem(false),
10153 health: Health(1.0),
10154 effect_particles: EffectParticles(Default::default()),
10155 effect_ambience: EffectAmbience(false),
10156 arrow_count: ArrowCount(0),
10157 stinger_count: StingerCount(0),
10158 sleeping_pos: SleepingPos(None),
10159 },
10160 no_ai: NoAi(false),
10161 left_handed: LeftHanded(false),
10162 aggressive: Aggressive(false),
10163 },
10164 },
10165 },
10166 is_celebrating: IsCelebrating(false),
10167 },
10168 witch_using_item: WitchUsingItem(false),
10169 }
10170 }
10171}
10172
10173#[derive(Component, Deref, DerefMut, Clone)]
10174pub struct TargetA(pub i32);
10175#[derive(Component, Deref, DerefMut, Clone)]
10176pub struct TargetB(pub i32);
10177#[derive(Component, Deref, DerefMut, Clone)]
10178pub struct TargetC(pub i32);
10179#[derive(Component, Deref, DerefMut, Clone)]
10180pub struct Inv(pub i32);
10181#[derive(Component)]
10182pub struct Wither;
10183impl Wither {
10184 pub fn apply_metadata(
10185 entity: &mut bevy_ecs::system::EntityCommands,
10186 d: EntityDataItem,
10187 ) -> Result<(), UpdateMetadataError> {
10188 match d.index {
10189 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
10190 16 => {
10191 entity.insert(TargetA(d.value.into_int()?));
10192 }
10193 17 => {
10194 entity.insert(TargetB(d.value.into_int()?));
10195 }
10196 18 => {
10197 entity.insert(TargetC(d.value.into_int()?));
10198 }
10199 19 => {
10200 entity.insert(Inv(d.value.into_int()?));
10201 }
10202 _ => {}
10203 }
10204 Ok(())
10205 }
10206}
10207
10208#[derive(Bundle)]
10209pub struct WitherMetadataBundle {
10210 _marker: Wither,
10211 parent: AbstractMonsterMetadataBundle,
10212 target_a: TargetA,
10213 target_b: TargetB,
10214 target_c: TargetC,
10215 inv: Inv,
10216}
10217impl Default for WitherMetadataBundle {
10218 fn default() -> Self {
10219 Self {
10220 _marker: Wither,
10221 parent: AbstractMonsterMetadataBundle {
10222 _marker: AbstractMonster,
10223 parent: AbstractCreatureMetadataBundle {
10224 _marker: AbstractCreature,
10225 parent: AbstractInsentientMetadataBundle {
10226 _marker: AbstractInsentient,
10227 parent: AbstractLivingMetadataBundle {
10228 _marker: AbstractLiving,
10229 parent: AbstractEntityMetadataBundle {
10230 _marker: AbstractEntity,
10231 on_fire: OnFire(false),
10232 shift_key_down: ShiftKeyDown(false),
10233 sprinting: Sprinting(false),
10234 swimming: Swimming(false),
10235 currently_glowing: CurrentlyGlowing(false),
10236 invisible: Invisible(false),
10237 fall_flying: FallFlying(false),
10238 air_supply: AirSupply(Default::default()),
10239 custom_name: CustomName(Default::default()),
10240 custom_name_visible: CustomNameVisible(Default::default()),
10241 silent: Silent(Default::default()),
10242 no_gravity: NoGravity(Default::default()),
10243 pose: Pose::default(),
10244 ticks_frozen: TicksFrozen(Default::default()),
10245 },
10246 auto_spin_attack: AutoSpinAttack(false),
10247 abstract_living_using_item: AbstractLivingUsingItem(false),
10248 health: Health(1.0),
10249 effect_particles: EffectParticles(Default::default()),
10250 effect_ambience: EffectAmbience(false),
10251 arrow_count: ArrowCount(0),
10252 stinger_count: StingerCount(0),
10253 sleeping_pos: SleepingPos(None),
10254 },
10255 no_ai: NoAi(false),
10256 left_handed: LeftHanded(false),
10257 aggressive: Aggressive(false),
10258 },
10259 },
10260 },
10261 target_a: TargetA(0),
10262 target_b: TargetB(0),
10263 target_c: TargetC(0),
10264 inv: Inv(0),
10265 }
10266 }
10267}
10268
10269#[derive(Component)]
10270pub struct WitherSkeleton;
10271impl WitherSkeleton {
10272 pub fn apply_metadata(
10273 entity: &mut bevy_ecs::system::EntityCommands,
10274 d: EntityDataItem,
10275 ) -> Result<(), UpdateMetadataError> {
10276 match d.index {
10277 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
10278 _ => {}
10279 }
10280 Ok(())
10281 }
10282}
10283
10284#[derive(Bundle)]
10285pub struct WitherSkeletonMetadataBundle {
10286 _marker: WitherSkeleton,
10287 parent: AbstractMonsterMetadataBundle,
10288}
10289impl Default for WitherSkeletonMetadataBundle {
10290 fn default() -> Self {
10291 Self {
10292 _marker: WitherSkeleton,
10293 parent: AbstractMonsterMetadataBundle {
10294 _marker: AbstractMonster,
10295 parent: AbstractCreatureMetadataBundle {
10296 _marker: AbstractCreature,
10297 parent: AbstractInsentientMetadataBundle {
10298 _marker: AbstractInsentient,
10299 parent: AbstractLivingMetadataBundle {
10300 _marker: AbstractLiving,
10301 parent: AbstractEntityMetadataBundle {
10302 _marker: AbstractEntity,
10303 on_fire: OnFire(false),
10304 shift_key_down: ShiftKeyDown(false),
10305 sprinting: Sprinting(false),
10306 swimming: Swimming(false),
10307 currently_glowing: CurrentlyGlowing(false),
10308 invisible: Invisible(false),
10309 fall_flying: FallFlying(false),
10310 air_supply: AirSupply(Default::default()),
10311 custom_name: CustomName(Default::default()),
10312 custom_name_visible: CustomNameVisible(Default::default()),
10313 silent: Silent(Default::default()),
10314 no_gravity: NoGravity(Default::default()),
10315 pose: Pose::default(),
10316 ticks_frozen: TicksFrozen(Default::default()),
10317 },
10318 auto_spin_attack: AutoSpinAttack(false),
10319 abstract_living_using_item: AbstractLivingUsingItem(false),
10320 health: Health(1.0),
10321 effect_particles: EffectParticles(Default::default()),
10322 effect_ambience: EffectAmbience(false),
10323 arrow_count: ArrowCount(0),
10324 stinger_count: StingerCount(0),
10325 sleeping_pos: SleepingPos(None),
10326 },
10327 no_ai: NoAi(false),
10328 left_handed: LeftHanded(false),
10329 aggressive: Aggressive(false),
10330 },
10331 },
10332 },
10333 }
10334 }
10335}
10336
10337#[derive(Component, Deref, DerefMut, Clone)]
10338pub struct Dangerous(pub bool);
10339#[derive(Component)]
10340pub struct WitherSkull;
10341impl WitherSkull {
10342 pub fn apply_metadata(
10343 entity: &mut bevy_ecs::system::EntityCommands,
10344 d: EntityDataItem,
10345 ) -> Result<(), UpdateMetadataError> {
10346 match d.index {
10347 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
10348 8 => {
10349 entity.insert(Dangerous(d.value.into_boolean()?));
10350 }
10351 _ => {}
10352 }
10353 Ok(())
10354 }
10355}
10356
10357#[derive(Bundle)]
10358pub struct WitherSkullMetadataBundle {
10359 _marker: WitherSkull,
10360 parent: AbstractEntityMetadataBundle,
10361 dangerous: Dangerous,
10362}
10363impl Default for WitherSkullMetadataBundle {
10364 fn default() -> Self {
10365 Self {
10366 _marker: WitherSkull,
10367 parent: AbstractEntityMetadataBundle {
10368 _marker: AbstractEntity,
10369 on_fire: OnFire(false),
10370 shift_key_down: ShiftKeyDown(false),
10371 sprinting: Sprinting(false),
10372 swimming: Swimming(false),
10373 currently_glowing: CurrentlyGlowing(false),
10374 invisible: Invisible(false),
10375 fall_flying: FallFlying(false),
10376 air_supply: AirSupply(Default::default()),
10377 custom_name: CustomName(Default::default()),
10378 custom_name_visible: CustomNameVisible(Default::default()),
10379 silent: Silent(Default::default()),
10380 no_gravity: NoGravity(Default::default()),
10381 pose: Pose::default(),
10382 ticks_frozen: TicksFrozen(Default::default()),
10383 },
10384 dangerous: Dangerous(false),
10385 }
10386 }
10387}
10388
10389#[derive(Component, Deref, DerefMut, Clone)]
10390pub struct WolfInterested(pub bool);
10391#[derive(Component, Deref, DerefMut, Clone)]
10392pub struct WolfCollarColor(pub i32);
10393#[derive(Component, Deref, DerefMut, Clone)]
10394pub struct WolfRemainingAngerTime(pub i32);
10395#[derive(Component, Deref, DerefMut, Clone)]
10396pub struct WolfVariant(pub azalea_registry::CowVariant);
10397#[derive(Component, Deref, DerefMut, Clone)]
10398pub struct SoundVariant(pub azalea_registry::WolfVariant);
10399#[derive(Component)]
10400pub struct Wolf;
10401impl Wolf {
10402 pub fn apply_metadata(
10403 entity: &mut bevy_ecs::system::EntityCommands,
10404 d: EntityDataItem,
10405 ) -> Result<(), UpdateMetadataError> {
10406 match d.index {
10407 0..=18 => AbstractTameable::apply_metadata(entity, d)?,
10408 19 => {
10409 entity.insert(WolfInterested(d.value.into_boolean()?));
10410 }
10411 20 => {
10412 entity.insert(WolfCollarColor(d.value.into_int()?));
10413 }
10414 21 => {
10415 entity.insert(WolfRemainingAngerTime(d.value.into_int()?));
10416 }
10417 22 => {
10418 entity.insert(WolfVariant(d.value.into_cow_variant()?));
10419 }
10420 23 => {
10421 entity.insert(SoundVariant(d.value.into_wolf_variant()?));
10422 }
10423 _ => {}
10424 }
10425 Ok(())
10426 }
10427}
10428
10429#[derive(Bundle)]
10430pub struct WolfMetadataBundle {
10431 _marker: Wolf,
10432 parent: AbstractTameableMetadataBundle,
10433 wolf_interested: WolfInterested,
10434 wolf_collar_color: WolfCollarColor,
10435 wolf_remaining_anger_time: WolfRemainingAngerTime,
10436 wolf_variant: WolfVariant,
10437 sound_variant: SoundVariant,
10438}
10439impl Default for WolfMetadataBundle {
10440 fn default() -> Self {
10441 Self {
10442 _marker: Wolf,
10443 parent: AbstractTameableMetadataBundle {
10444 _marker: AbstractTameable,
10445 parent: AbstractAnimalMetadataBundle {
10446 _marker: AbstractAnimal,
10447 parent: AbstractAgeableMetadataBundle {
10448 _marker: AbstractAgeable,
10449 parent: AbstractCreatureMetadataBundle {
10450 _marker: AbstractCreature,
10451 parent: AbstractInsentientMetadataBundle {
10452 _marker: AbstractInsentient,
10453 parent: AbstractLivingMetadataBundle {
10454 _marker: AbstractLiving,
10455 parent: AbstractEntityMetadataBundle {
10456 _marker: AbstractEntity,
10457 on_fire: OnFire(false),
10458 shift_key_down: ShiftKeyDown(false),
10459 sprinting: Sprinting(false),
10460 swimming: Swimming(false),
10461 currently_glowing: CurrentlyGlowing(false),
10462 invisible: Invisible(false),
10463 fall_flying: FallFlying(false),
10464 air_supply: AirSupply(Default::default()),
10465 custom_name: CustomName(Default::default()),
10466 custom_name_visible: CustomNameVisible(Default::default()),
10467 silent: Silent(Default::default()),
10468 no_gravity: NoGravity(Default::default()),
10469 pose: Pose::default(),
10470 ticks_frozen: TicksFrozen(Default::default()),
10471 },
10472 auto_spin_attack: AutoSpinAttack(false),
10473 abstract_living_using_item: AbstractLivingUsingItem(false),
10474 health: Health(1.0),
10475 effect_particles: EffectParticles(Default::default()),
10476 effect_ambience: EffectAmbience(false),
10477 arrow_count: ArrowCount(0),
10478 stinger_count: StingerCount(0),
10479 sleeping_pos: SleepingPos(None),
10480 },
10481 no_ai: NoAi(false),
10482 left_handed: LeftHanded(false),
10483 aggressive: Aggressive(false),
10484 },
10485 },
10486 abstract_ageable_baby: AbstractAgeableBaby(false),
10487 },
10488 },
10489 tame: Tame(false),
10490 in_sitting_pose: InSittingPose(false),
10491 owneruuid: Owneruuid(None),
10492 },
10493 wolf_interested: WolfInterested(false),
10494 wolf_collar_color: WolfCollarColor(Default::default()),
10495 wolf_remaining_anger_time: WolfRemainingAngerTime(0),
10496 wolf_variant: WolfVariant(azalea_registry::CowVariant::new_raw(0)),
10497 sound_variant: SoundVariant(azalea_registry::WolfVariant::new_raw(0)),
10498 }
10499 }
10500}
10501
10502#[derive(Component, Deref, DerefMut, Clone)]
10503pub struct ZoglinBaby(pub bool);
10504#[derive(Component)]
10505pub struct Zoglin;
10506impl Zoglin {
10507 pub fn apply_metadata(
10508 entity: &mut bevy_ecs::system::EntityCommands,
10509 d: EntityDataItem,
10510 ) -> Result<(), UpdateMetadataError> {
10511 match d.index {
10512 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
10513 16 => {
10514 entity.insert(ZoglinBaby(d.value.into_boolean()?));
10515 }
10516 _ => {}
10517 }
10518 Ok(())
10519 }
10520}
10521
10522#[derive(Bundle)]
10523pub struct ZoglinMetadataBundle {
10524 _marker: Zoglin,
10525 parent: AbstractMonsterMetadataBundle,
10526 zoglin_baby: ZoglinBaby,
10527}
10528impl Default for ZoglinMetadataBundle {
10529 fn default() -> Self {
10530 Self {
10531 _marker: Zoglin,
10532 parent: AbstractMonsterMetadataBundle {
10533 _marker: AbstractMonster,
10534 parent: AbstractCreatureMetadataBundle {
10535 _marker: AbstractCreature,
10536 parent: AbstractInsentientMetadataBundle {
10537 _marker: AbstractInsentient,
10538 parent: AbstractLivingMetadataBundle {
10539 _marker: AbstractLiving,
10540 parent: AbstractEntityMetadataBundle {
10541 _marker: AbstractEntity,
10542 on_fire: OnFire(false),
10543 shift_key_down: ShiftKeyDown(false),
10544 sprinting: Sprinting(false),
10545 swimming: Swimming(false),
10546 currently_glowing: CurrentlyGlowing(false),
10547 invisible: Invisible(false),
10548 fall_flying: FallFlying(false),
10549 air_supply: AirSupply(Default::default()),
10550 custom_name: CustomName(Default::default()),
10551 custom_name_visible: CustomNameVisible(Default::default()),
10552 silent: Silent(Default::default()),
10553 no_gravity: NoGravity(Default::default()),
10554 pose: Pose::default(),
10555 ticks_frozen: TicksFrozen(Default::default()),
10556 },
10557 auto_spin_attack: AutoSpinAttack(false),
10558 abstract_living_using_item: AbstractLivingUsingItem(false),
10559 health: Health(1.0),
10560 effect_particles: EffectParticles(Default::default()),
10561 effect_ambience: EffectAmbience(false),
10562 arrow_count: ArrowCount(0),
10563 stinger_count: StingerCount(0),
10564 sleeping_pos: SleepingPos(None),
10565 },
10566 no_ai: NoAi(false),
10567 left_handed: LeftHanded(false),
10568 aggressive: Aggressive(false),
10569 },
10570 },
10571 },
10572 zoglin_baby: ZoglinBaby(false),
10573 }
10574 }
10575}
10576
10577#[derive(Component)]
10578pub struct Zombie;
10579impl Zombie {
10580 pub fn apply_metadata(
10581 entity: &mut bevy_ecs::system::EntityCommands,
10582 d: EntityDataItem,
10583 ) -> Result<(), UpdateMetadataError> {
10584 match d.index {
10585 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
10586 16 => {
10587 entity.insert(ZombieBaby(d.value.into_boolean()?));
10588 }
10589 17 => {
10590 entity.insert(SpecialType(d.value.into_int()?));
10591 }
10592 18 => {
10593 entity.insert(DrownedConversion(d.value.into_boolean()?));
10594 }
10595 _ => {}
10596 }
10597 Ok(())
10598 }
10599}
10600
10601#[derive(Bundle)]
10602pub struct ZombieMetadataBundle {
10603 _marker: Zombie,
10604 parent: AbstractMonsterMetadataBundle,
10605 zombie_baby: ZombieBaby,
10606 special_type: SpecialType,
10607 drowned_conversion: DrownedConversion,
10608}
10609impl Default for ZombieMetadataBundle {
10610 fn default() -> Self {
10611 Self {
10612 _marker: Zombie,
10613 parent: AbstractMonsterMetadataBundle {
10614 _marker: AbstractMonster,
10615 parent: AbstractCreatureMetadataBundle {
10616 _marker: AbstractCreature,
10617 parent: AbstractInsentientMetadataBundle {
10618 _marker: AbstractInsentient,
10619 parent: AbstractLivingMetadataBundle {
10620 _marker: AbstractLiving,
10621 parent: AbstractEntityMetadataBundle {
10622 _marker: AbstractEntity,
10623 on_fire: OnFire(false),
10624 shift_key_down: ShiftKeyDown(false),
10625 sprinting: Sprinting(false),
10626 swimming: Swimming(false),
10627 currently_glowing: CurrentlyGlowing(false),
10628 invisible: Invisible(false),
10629 fall_flying: FallFlying(false),
10630 air_supply: AirSupply(Default::default()),
10631 custom_name: CustomName(Default::default()),
10632 custom_name_visible: CustomNameVisible(Default::default()),
10633 silent: Silent(Default::default()),
10634 no_gravity: NoGravity(Default::default()),
10635 pose: Pose::default(),
10636 ticks_frozen: TicksFrozen(Default::default()),
10637 },
10638 auto_spin_attack: AutoSpinAttack(false),
10639 abstract_living_using_item: AbstractLivingUsingItem(false),
10640 health: Health(1.0),
10641 effect_particles: EffectParticles(Default::default()),
10642 effect_ambience: EffectAmbience(false),
10643 arrow_count: ArrowCount(0),
10644 stinger_count: StingerCount(0),
10645 sleeping_pos: SleepingPos(None),
10646 },
10647 no_ai: NoAi(false),
10648 left_handed: LeftHanded(false),
10649 aggressive: Aggressive(false),
10650 },
10651 },
10652 },
10653 zombie_baby: ZombieBaby(false),
10654 special_type: SpecialType(0),
10655 drowned_conversion: DrownedConversion(false),
10656 }
10657 }
10658}
10659
10660#[derive(Component)]
10661pub struct ZombieHorse;
10662impl ZombieHorse {
10663 pub fn apply_metadata(
10664 entity: &mut bevy_ecs::system::EntityCommands,
10665 d: EntityDataItem,
10666 ) -> Result<(), UpdateMetadataError> {
10667 match d.index {
10668 0..=17 => AbstractHorse::apply_metadata(entity, d)?,
10669 _ => {}
10670 }
10671 Ok(())
10672 }
10673}
10674
10675#[derive(Bundle)]
10676pub struct ZombieHorseMetadataBundle {
10677 _marker: ZombieHorse,
10678 parent: AbstractHorseMetadataBundle,
10679}
10680impl Default for ZombieHorseMetadataBundle {
10681 fn default() -> Self {
10682 Self {
10683 _marker: ZombieHorse,
10684 parent: AbstractHorseMetadataBundle {
10685 _marker: AbstractHorse,
10686 parent: AbstractAnimalMetadataBundle {
10687 _marker: AbstractAnimal,
10688 parent: AbstractAgeableMetadataBundle {
10689 _marker: AbstractAgeable,
10690 parent: AbstractCreatureMetadataBundle {
10691 _marker: AbstractCreature,
10692 parent: AbstractInsentientMetadataBundle {
10693 _marker: AbstractInsentient,
10694 parent: AbstractLivingMetadataBundle {
10695 _marker: AbstractLiving,
10696 parent: AbstractEntityMetadataBundle {
10697 _marker: AbstractEntity,
10698 on_fire: OnFire(false),
10699 shift_key_down: ShiftKeyDown(false),
10700 sprinting: Sprinting(false),
10701 swimming: Swimming(false),
10702 currently_glowing: CurrentlyGlowing(false),
10703 invisible: Invisible(false),
10704 fall_flying: FallFlying(false),
10705 air_supply: AirSupply(Default::default()),
10706 custom_name: CustomName(Default::default()),
10707 custom_name_visible: CustomNameVisible(Default::default()),
10708 silent: Silent(Default::default()),
10709 no_gravity: NoGravity(Default::default()),
10710 pose: Pose::default(),
10711 ticks_frozen: TicksFrozen(Default::default()),
10712 },
10713 auto_spin_attack: AutoSpinAttack(false),
10714 abstract_living_using_item: AbstractLivingUsingItem(false),
10715 health: Health(1.0),
10716 effect_particles: EffectParticles(Default::default()),
10717 effect_ambience: EffectAmbience(false),
10718 arrow_count: ArrowCount(0),
10719 stinger_count: StingerCount(0),
10720 sleeping_pos: SleepingPos(None),
10721 },
10722 no_ai: NoAi(false),
10723 left_handed: LeftHanded(false),
10724 aggressive: Aggressive(false),
10725 },
10726 },
10727 abstract_ageable_baby: AbstractAgeableBaby(false),
10728 },
10729 },
10730 tamed: Tamed(false),
10731 eating: Eating(false),
10732 abstract_horse_standing: AbstractHorseStanding(false),
10733 bred: Bred(false),
10734 },
10735 }
10736 }
10737}
10738
10739#[derive(Component, Deref, DerefMut, Clone)]
10740pub struct Converting(pub bool);
10741#[derive(Component, Deref, DerefMut, Clone)]
10742pub struct ZombieVillagerVillagerData(pub VillagerData);
10743#[derive(Component)]
10744pub struct ZombieVillager;
10745impl ZombieVillager {
10746 pub fn apply_metadata(
10747 entity: &mut bevy_ecs::system::EntityCommands,
10748 d: EntityDataItem,
10749 ) -> Result<(), UpdateMetadataError> {
10750 match d.index {
10751 0..=18 => Zombie::apply_metadata(entity, d)?,
10752 19 => {
10753 entity.insert(Converting(d.value.into_boolean()?));
10754 }
10755 20 => {
10756 entity.insert(ZombieVillagerVillagerData(d.value.into_villager_data()?));
10757 }
10758 _ => {}
10759 }
10760 Ok(())
10761 }
10762}
10763
10764#[derive(Bundle)]
10765pub struct ZombieVillagerMetadataBundle {
10766 _marker: ZombieVillager,
10767 parent: ZombieMetadataBundle,
10768 converting: Converting,
10769 zombie_villager_villager_data: ZombieVillagerVillagerData,
10770}
10771impl Default for ZombieVillagerMetadataBundle {
10772 fn default() -> Self {
10773 Self {
10774 _marker: ZombieVillager,
10775 parent: ZombieMetadataBundle {
10776 _marker: Zombie,
10777 parent: AbstractMonsterMetadataBundle {
10778 _marker: AbstractMonster,
10779 parent: AbstractCreatureMetadataBundle {
10780 _marker: AbstractCreature,
10781 parent: AbstractInsentientMetadataBundle {
10782 _marker: AbstractInsentient,
10783 parent: AbstractLivingMetadataBundle {
10784 _marker: AbstractLiving,
10785 parent: AbstractEntityMetadataBundle {
10786 _marker: AbstractEntity,
10787 on_fire: OnFire(false),
10788 shift_key_down: ShiftKeyDown(false),
10789 sprinting: Sprinting(false),
10790 swimming: Swimming(false),
10791 currently_glowing: CurrentlyGlowing(false),
10792 invisible: Invisible(false),
10793 fall_flying: FallFlying(false),
10794 air_supply: AirSupply(Default::default()),
10795 custom_name: CustomName(Default::default()),
10796 custom_name_visible: CustomNameVisible(Default::default()),
10797 silent: Silent(Default::default()),
10798 no_gravity: NoGravity(Default::default()),
10799 pose: Pose::default(),
10800 ticks_frozen: TicksFrozen(Default::default()),
10801 },
10802 auto_spin_attack: AutoSpinAttack(false),
10803 abstract_living_using_item: AbstractLivingUsingItem(false),
10804 health: Health(1.0),
10805 effect_particles: EffectParticles(Default::default()),
10806 effect_ambience: EffectAmbience(false),
10807 arrow_count: ArrowCount(0),
10808 stinger_count: StingerCount(0),
10809 sleeping_pos: SleepingPos(None),
10810 },
10811 no_ai: NoAi(false),
10812 left_handed: LeftHanded(false),
10813 aggressive: Aggressive(false),
10814 },
10815 },
10816 },
10817 zombie_baby: ZombieBaby(false),
10818 special_type: SpecialType(0),
10819 drowned_conversion: DrownedConversion(false),
10820 },
10821 converting: Converting(false),
10822 zombie_villager_villager_data: ZombieVillagerVillagerData(VillagerData {
10823 kind: azalea_registry::VillagerKind::Plains,
10824 profession: azalea_registry::VillagerProfession::None,
10825 level: 0,
10826 }),
10827 }
10828 }
10829}
10830
10831#[derive(Component)]
10832pub struct ZombifiedPiglin;
10833impl ZombifiedPiglin {
10834 pub fn apply_metadata(
10835 entity: &mut bevy_ecs::system::EntityCommands,
10836 d: EntityDataItem,
10837 ) -> Result<(), UpdateMetadataError> {
10838 match d.index {
10839 0..=18 => Zombie::apply_metadata(entity, d)?,
10840 _ => {}
10841 }
10842 Ok(())
10843 }
10844}
10845
10846#[derive(Bundle)]
10847pub struct ZombifiedPiglinMetadataBundle {
10848 _marker: ZombifiedPiglin,
10849 parent: ZombieMetadataBundle,
10850}
10851impl Default for ZombifiedPiglinMetadataBundle {
10852 fn default() -> Self {
10853 Self {
10854 _marker: ZombifiedPiglin,
10855 parent: ZombieMetadataBundle {
10856 _marker: Zombie,
10857 parent: AbstractMonsterMetadataBundle {
10858 _marker: AbstractMonster,
10859 parent: AbstractCreatureMetadataBundle {
10860 _marker: AbstractCreature,
10861 parent: AbstractInsentientMetadataBundle {
10862 _marker: AbstractInsentient,
10863 parent: AbstractLivingMetadataBundle {
10864 _marker: AbstractLiving,
10865 parent: AbstractEntityMetadataBundle {
10866 _marker: AbstractEntity,
10867 on_fire: OnFire(false),
10868 shift_key_down: ShiftKeyDown(false),
10869 sprinting: Sprinting(false),
10870 swimming: Swimming(false),
10871 currently_glowing: CurrentlyGlowing(false),
10872 invisible: Invisible(false),
10873 fall_flying: FallFlying(false),
10874 air_supply: AirSupply(Default::default()),
10875 custom_name: CustomName(Default::default()),
10876 custom_name_visible: CustomNameVisible(Default::default()),
10877 silent: Silent(Default::default()),
10878 no_gravity: NoGravity(Default::default()),
10879 pose: Pose::default(),
10880 ticks_frozen: TicksFrozen(Default::default()),
10881 },
10882 auto_spin_attack: AutoSpinAttack(false),
10883 abstract_living_using_item: AbstractLivingUsingItem(false),
10884 health: Health(1.0),
10885 effect_particles: EffectParticles(Default::default()),
10886 effect_ambience: EffectAmbience(false),
10887 arrow_count: ArrowCount(0),
10888 stinger_count: StingerCount(0),
10889 sleeping_pos: SleepingPos(None),
10890 },
10891 no_ai: NoAi(false),
10892 left_handed: LeftHanded(false),
10893 aggressive: Aggressive(false),
10894 },
10895 },
10896 },
10897 zombie_baby: ZombieBaby(false),
10898 special_type: SpecialType(0),
10899 drowned_conversion: DrownedConversion(false),
10900 },
10901 }
10902 }
10903}
10904
10905#[derive(Component)]
10906pub struct AbstractAgeable;
10907impl AbstractAgeable {
10908 pub fn apply_metadata(
10909 entity: &mut bevy_ecs::system::EntityCommands,
10910 d: EntityDataItem,
10911 ) -> Result<(), UpdateMetadataError> {
10912 match d.index {
10913 0..=15 => AbstractCreature::apply_metadata(entity, d)?,
10914 16 => {
10915 entity.insert(AbstractAgeableBaby(d.value.into_boolean()?));
10916 }
10917 _ => {}
10918 }
10919 Ok(())
10920 }
10921}
10922
10923#[derive(Bundle)]
10924pub struct AbstractAgeableMetadataBundle {
10925 _marker: AbstractAgeable,
10926 parent: AbstractCreatureMetadataBundle,
10927 abstract_ageable_baby: AbstractAgeableBaby,
10928}
10929impl Default for AbstractAgeableMetadataBundle {
10930 fn default() -> Self {
10931 Self {
10932 _marker: AbstractAgeable,
10933 parent: AbstractCreatureMetadataBundle {
10934 _marker: AbstractCreature,
10935 parent: AbstractInsentientMetadataBundle {
10936 _marker: AbstractInsentient,
10937 parent: AbstractLivingMetadataBundle {
10938 _marker: AbstractLiving,
10939 parent: AbstractEntityMetadataBundle {
10940 _marker: AbstractEntity,
10941 on_fire: OnFire(false),
10942 shift_key_down: ShiftKeyDown(false),
10943 sprinting: Sprinting(false),
10944 swimming: Swimming(false),
10945 currently_glowing: CurrentlyGlowing(false),
10946 invisible: Invisible(false),
10947 fall_flying: FallFlying(false),
10948 air_supply: AirSupply(Default::default()),
10949 custom_name: CustomName(Default::default()),
10950 custom_name_visible: CustomNameVisible(Default::default()),
10951 silent: Silent(Default::default()),
10952 no_gravity: NoGravity(Default::default()),
10953 pose: Pose::default(),
10954 ticks_frozen: TicksFrozen(Default::default()),
10955 },
10956 auto_spin_attack: AutoSpinAttack(false),
10957 abstract_living_using_item: AbstractLivingUsingItem(false),
10958 health: Health(1.0),
10959 effect_particles: EffectParticles(Default::default()),
10960 effect_ambience: EffectAmbience(false),
10961 arrow_count: ArrowCount(0),
10962 stinger_count: StingerCount(0),
10963 sleeping_pos: SleepingPos(None),
10964 },
10965 no_ai: NoAi(false),
10966 left_handed: LeftHanded(false),
10967 aggressive: Aggressive(false),
10968 },
10969 },
10970 abstract_ageable_baby: AbstractAgeableBaby(false),
10971 }
10972 }
10973}
10974
10975#[derive(Component)]
10976pub struct AbstractAnimal;
10977impl AbstractAnimal {
10978 pub fn apply_metadata(
10979 entity: &mut bevy_ecs::system::EntityCommands,
10980 d: EntityDataItem,
10981 ) -> Result<(), UpdateMetadataError> {
10982 match d.index {
10983 0..=16 => AbstractAgeable::apply_metadata(entity, d)?,
10984 _ => {}
10985 }
10986 Ok(())
10987 }
10988}
10989
10990#[derive(Bundle)]
10991pub struct AbstractAnimalMetadataBundle {
10992 _marker: AbstractAnimal,
10993 parent: AbstractAgeableMetadataBundle,
10994}
10995impl Default for AbstractAnimalMetadataBundle {
10996 fn default() -> Self {
10997 Self {
10998 _marker: AbstractAnimal,
10999 parent: AbstractAgeableMetadataBundle {
11000 _marker: AbstractAgeable,
11001 parent: AbstractCreatureMetadataBundle {
11002 _marker: AbstractCreature,
11003 parent: AbstractInsentientMetadataBundle {
11004 _marker: AbstractInsentient,
11005 parent: AbstractLivingMetadataBundle {
11006 _marker: AbstractLiving,
11007 parent: AbstractEntityMetadataBundle {
11008 _marker: AbstractEntity,
11009 on_fire: OnFire(false),
11010 shift_key_down: ShiftKeyDown(false),
11011 sprinting: Sprinting(false),
11012 swimming: Swimming(false),
11013 currently_glowing: CurrentlyGlowing(false),
11014 invisible: Invisible(false),
11015 fall_flying: FallFlying(false),
11016 air_supply: AirSupply(Default::default()),
11017 custom_name: CustomName(Default::default()),
11018 custom_name_visible: CustomNameVisible(Default::default()),
11019 silent: Silent(Default::default()),
11020 no_gravity: NoGravity(Default::default()),
11021 pose: Pose::default(),
11022 ticks_frozen: TicksFrozen(Default::default()),
11023 },
11024 auto_spin_attack: AutoSpinAttack(false),
11025 abstract_living_using_item: AbstractLivingUsingItem(false),
11026 health: Health(1.0),
11027 effect_particles: EffectParticles(Default::default()),
11028 effect_ambience: EffectAmbience(false),
11029 arrow_count: ArrowCount(0),
11030 stinger_count: StingerCount(0),
11031 sleeping_pos: SleepingPos(None),
11032 },
11033 no_ai: NoAi(false),
11034 left_handed: LeftHanded(false),
11035 aggressive: Aggressive(false),
11036 },
11037 },
11038 abstract_ageable_baby: AbstractAgeableBaby(false),
11039 },
11040 }
11041 }
11042}
11043
11044#[derive(Component)]
11045pub struct AbstractArrow;
11046impl AbstractArrow {
11047 pub fn apply_metadata(
11048 entity: &mut bevy_ecs::system::EntityCommands,
11049 d: EntityDataItem,
11050 ) -> Result<(), UpdateMetadataError> {
11051 match d.index {
11052 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
11053 8 => {
11054 let bitfield = d.value.into_byte()?;
11055 entity.insert(CritArrow(bitfield & 0x1 != 0));
11056 entity.insert(NoPhysics(bitfield & 0x2 != 0));
11057 }
11058 9 => {
11059 entity.insert(PierceLevel(d.value.into_byte()?));
11060 }
11061 10 => {
11062 entity.insert(InGround(d.value.into_boolean()?));
11063 }
11064 _ => {}
11065 }
11066 Ok(())
11067 }
11068}
11069
11070#[derive(Bundle)]
11071pub struct AbstractArrowMetadataBundle {
11072 _marker: AbstractArrow,
11073 parent: AbstractEntityMetadataBundle,
11074 crit_arrow: CritArrow,
11075 no_physics: NoPhysics,
11076 pierce_level: PierceLevel,
11077 in_ground: InGround,
11078}
11079impl Default for AbstractArrowMetadataBundle {
11080 fn default() -> Self {
11081 Self {
11082 _marker: AbstractArrow,
11083 parent: AbstractEntityMetadataBundle {
11084 _marker: AbstractEntity,
11085 on_fire: OnFire(false),
11086 shift_key_down: ShiftKeyDown(false),
11087 sprinting: Sprinting(false),
11088 swimming: Swimming(false),
11089 currently_glowing: CurrentlyGlowing(false),
11090 invisible: Invisible(false),
11091 fall_flying: FallFlying(false),
11092 air_supply: AirSupply(Default::default()),
11093 custom_name: CustomName(Default::default()),
11094 custom_name_visible: CustomNameVisible(Default::default()),
11095 silent: Silent(Default::default()),
11096 no_gravity: NoGravity(Default::default()),
11097 pose: Pose::default(),
11098 ticks_frozen: TicksFrozen(Default::default()),
11099 },
11100 crit_arrow: CritArrow(false),
11101 no_physics: NoPhysics(false),
11102 pierce_level: PierceLevel(0),
11103 in_ground: InGround(false),
11104 }
11105 }
11106}
11107
11108#[derive(Component)]
11109pub struct AbstractBoat;
11110impl AbstractBoat {
11111 pub fn apply_metadata(
11112 entity: &mut bevy_ecs::system::EntityCommands,
11113 d: EntityDataItem,
11114 ) -> Result<(), UpdateMetadataError> {
11115 match d.index {
11116 0..=10 => AbstractVehicle::apply_metadata(entity, d)?,
11117 11 => {
11118 entity.insert(PaddleLeft(d.value.into_boolean()?));
11119 }
11120 12 => {
11121 entity.insert(PaddleRight(d.value.into_boolean()?));
11122 }
11123 13 => {
11124 entity.insert(BubbleTime(d.value.into_int()?));
11125 }
11126 _ => {}
11127 }
11128 Ok(())
11129 }
11130}
11131
11132#[derive(Bundle)]
11133pub struct AbstractBoatMetadataBundle {
11134 _marker: AbstractBoat,
11135 parent: AbstractVehicleMetadataBundle,
11136 paddle_left: PaddleLeft,
11137 paddle_right: PaddleRight,
11138 bubble_time: BubbleTime,
11139}
11140impl Default for AbstractBoatMetadataBundle {
11141 fn default() -> Self {
11142 Self {
11143 _marker: AbstractBoat,
11144 parent: AbstractVehicleMetadataBundle {
11145 _marker: AbstractVehicle,
11146 parent: AbstractEntityMetadataBundle {
11147 _marker: AbstractEntity,
11148 on_fire: OnFire(false),
11149 shift_key_down: ShiftKeyDown(false),
11150 sprinting: Sprinting(false),
11151 swimming: Swimming(false),
11152 currently_glowing: CurrentlyGlowing(false),
11153 invisible: Invisible(false),
11154 fall_flying: FallFlying(false),
11155 air_supply: AirSupply(Default::default()),
11156 custom_name: CustomName(Default::default()),
11157 custom_name_visible: CustomNameVisible(Default::default()),
11158 silent: Silent(Default::default()),
11159 no_gravity: NoGravity(Default::default()),
11160 pose: Pose::default(),
11161 ticks_frozen: TicksFrozen(Default::default()),
11162 },
11163 hurt: Hurt(0),
11164 hurtdir: Hurtdir(1),
11165 damage: Damage(0.0),
11166 },
11167 paddle_left: PaddleLeft(false),
11168 paddle_right: PaddleRight(false),
11169 bubble_time: BubbleTime(0),
11170 }
11171 }
11172}
11173
11174#[derive(Component)]
11175pub struct AbstractChestedHorse;
11176impl AbstractChestedHorse {
11177 pub fn apply_metadata(
11178 entity: &mut bevy_ecs::system::EntityCommands,
11179 d: EntityDataItem,
11180 ) -> Result<(), UpdateMetadataError> {
11181 match d.index {
11182 0..=17 => AbstractHorse::apply_metadata(entity, d)?,
11183 18 => {
11184 entity.insert(Chest(d.value.into_boolean()?));
11185 }
11186 _ => {}
11187 }
11188 Ok(())
11189 }
11190}
11191
11192#[derive(Bundle)]
11193pub struct AbstractChestedHorseMetadataBundle {
11194 _marker: AbstractChestedHorse,
11195 parent: AbstractHorseMetadataBundle,
11196 chest: Chest,
11197}
11198impl Default for AbstractChestedHorseMetadataBundle {
11199 fn default() -> Self {
11200 Self {
11201 _marker: AbstractChestedHorse,
11202 parent: AbstractHorseMetadataBundle {
11203 _marker: AbstractHorse,
11204 parent: AbstractAnimalMetadataBundle {
11205 _marker: AbstractAnimal,
11206 parent: AbstractAgeableMetadataBundle {
11207 _marker: AbstractAgeable,
11208 parent: AbstractCreatureMetadataBundle {
11209 _marker: AbstractCreature,
11210 parent: AbstractInsentientMetadataBundle {
11211 _marker: AbstractInsentient,
11212 parent: AbstractLivingMetadataBundle {
11213 _marker: AbstractLiving,
11214 parent: AbstractEntityMetadataBundle {
11215 _marker: AbstractEntity,
11216 on_fire: OnFire(false),
11217 shift_key_down: ShiftKeyDown(false),
11218 sprinting: Sprinting(false),
11219 swimming: Swimming(false),
11220 currently_glowing: CurrentlyGlowing(false),
11221 invisible: Invisible(false),
11222 fall_flying: FallFlying(false),
11223 air_supply: AirSupply(Default::default()),
11224 custom_name: CustomName(Default::default()),
11225 custom_name_visible: CustomNameVisible(Default::default()),
11226 silent: Silent(Default::default()),
11227 no_gravity: NoGravity(Default::default()),
11228 pose: Pose::default(),
11229 ticks_frozen: TicksFrozen(Default::default()),
11230 },
11231 auto_spin_attack: AutoSpinAttack(false),
11232 abstract_living_using_item: AbstractLivingUsingItem(false),
11233 health: Health(1.0),
11234 effect_particles: EffectParticles(Default::default()),
11235 effect_ambience: EffectAmbience(false),
11236 arrow_count: ArrowCount(0),
11237 stinger_count: StingerCount(0),
11238 sleeping_pos: SleepingPos(None),
11239 },
11240 no_ai: NoAi(false),
11241 left_handed: LeftHanded(false),
11242 aggressive: Aggressive(false),
11243 },
11244 },
11245 abstract_ageable_baby: AbstractAgeableBaby(false),
11246 },
11247 },
11248 tamed: Tamed(false),
11249 eating: Eating(false),
11250 abstract_horse_standing: AbstractHorseStanding(false),
11251 bred: Bred(false),
11252 },
11253 chest: Chest(false),
11254 }
11255 }
11256}
11257
11258#[derive(Component)]
11259pub struct AbstractCreature;
11260impl AbstractCreature {
11261 pub fn apply_metadata(
11262 entity: &mut bevy_ecs::system::EntityCommands,
11263 d: EntityDataItem,
11264 ) -> Result<(), UpdateMetadataError> {
11265 match d.index {
11266 0..=15 => AbstractInsentient::apply_metadata(entity, d)?,
11267 _ => {}
11268 }
11269 Ok(())
11270 }
11271}
11272
11273#[derive(Bundle)]
11274pub struct AbstractCreatureMetadataBundle {
11275 _marker: AbstractCreature,
11276 parent: AbstractInsentientMetadataBundle,
11277}
11278impl Default for AbstractCreatureMetadataBundle {
11279 fn default() -> Self {
11280 Self {
11281 _marker: AbstractCreature,
11282 parent: AbstractInsentientMetadataBundle {
11283 _marker: AbstractInsentient,
11284 parent: AbstractLivingMetadataBundle {
11285 _marker: AbstractLiving,
11286 parent: AbstractEntityMetadataBundle {
11287 _marker: AbstractEntity,
11288 on_fire: OnFire(false),
11289 shift_key_down: ShiftKeyDown(false),
11290 sprinting: Sprinting(false),
11291 swimming: Swimming(false),
11292 currently_glowing: CurrentlyGlowing(false),
11293 invisible: Invisible(false),
11294 fall_flying: FallFlying(false),
11295 air_supply: AirSupply(Default::default()),
11296 custom_name: CustomName(Default::default()),
11297 custom_name_visible: CustomNameVisible(Default::default()),
11298 silent: Silent(Default::default()),
11299 no_gravity: NoGravity(Default::default()),
11300 pose: Pose::default(),
11301 ticks_frozen: TicksFrozen(Default::default()),
11302 },
11303 auto_spin_attack: AutoSpinAttack(false),
11304 abstract_living_using_item: AbstractLivingUsingItem(false),
11305 health: Health(1.0),
11306 effect_particles: EffectParticles(Default::default()),
11307 effect_ambience: EffectAmbience(false),
11308 arrow_count: ArrowCount(0),
11309 stinger_count: StingerCount(0),
11310 sleeping_pos: SleepingPos(None),
11311 },
11312 no_ai: NoAi(false),
11313 left_handed: LeftHanded(false),
11314 aggressive: Aggressive(false),
11315 },
11316 }
11317 }
11318}
11319
11320#[derive(Component)]
11321pub struct AbstractDisplay;
11322impl AbstractDisplay {
11323 pub fn apply_metadata(
11324 entity: &mut bevy_ecs::system::EntityCommands,
11325 d: EntityDataItem,
11326 ) -> Result<(), UpdateMetadataError> {
11327 match d.index {
11328 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
11329 8 => {
11330 entity.insert(TransformationInterpolationStartDeltaTicks(
11331 d.value.into_int()?,
11332 ));
11333 }
11334 9 => {
11335 entity.insert(TransformationInterpolationDuration(d.value.into_int()?));
11336 }
11337 10 => {
11338 entity.insert(PosRotInterpolationDuration(d.value.into_int()?));
11339 }
11340 11 => {
11341 entity.insert(Translation(d.value.into_vector3()?));
11342 }
11343 12 => {
11344 entity.insert(Scale(d.value.into_vector3()?));
11345 }
11346 13 => {
11347 entity.insert(LeftRotation(d.value.into_quaternion()?));
11348 }
11349 14 => {
11350 entity.insert(RightRotation(d.value.into_quaternion()?));
11351 }
11352 15 => {
11353 entity.insert(BillboardRenderConstraints(d.value.into_byte()?));
11354 }
11355 16 => {
11356 entity.insert(BrightnessOverride(d.value.into_int()?));
11357 }
11358 17 => {
11359 entity.insert(ViewRange(d.value.into_float()?));
11360 }
11361 18 => {
11362 entity.insert(ShadowRadius(d.value.into_float()?));
11363 }
11364 19 => {
11365 entity.insert(ShadowStrength(d.value.into_float()?));
11366 }
11367 20 => {
11368 entity.insert(AbstractDisplayWidth(d.value.into_float()?));
11369 }
11370 21 => {
11371 entity.insert(AbstractDisplayHeight(d.value.into_float()?));
11372 }
11373 22 => {
11374 entity.insert(GlowColorOverride(d.value.into_int()?));
11375 }
11376 _ => {}
11377 }
11378 Ok(())
11379 }
11380}
11381
11382#[derive(Bundle)]
11383pub struct AbstractDisplayMetadataBundle {
11384 _marker: AbstractDisplay,
11385 parent: AbstractEntityMetadataBundle,
11386 transformation_interpolation_start_delta_ticks: TransformationInterpolationStartDeltaTicks,
11387 transformation_interpolation_duration: TransformationInterpolationDuration,
11388 pos_rot_interpolation_duration: PosRotInterpolationDuration,
11389 translation: Translation,
11390 scale: Scale,
11391 left_rotation: LeftRotation,
11392 right_rotation: RightRotation,
11393 billboard_render_constraints: BillboardRenderConstraints,
11394 brightness_override: BrightnessOverride,
11395 view_range: ViewRange,
11396 shadow_radius: ShadowRadius,
11397 shadow_strength: ShadowStrength,
11398 abstract_display_width: AbstractDisplayWidth,
11399 abstract_display_height: AbstractDisplayHeight,
11400 glow_color_override: GlowColorOverride,
11401}
11402impl Default for AbstractDisplayMetadataBundle {
11403 fn default() -> Self {
11404 Self {
11405 _marker: AbstractDisplay,
11406 parent: AbstractEntityMetadataBundle {
11407 _marker: AbstractEntity,
11408 on_fire: OnFire(false),
11409 shift_key_down: ShiftKeyDown(false),
11410 sprinting: Sprinting(false),
11411 swimming: Swimming(false),
11412 currently_glowing: CurrentlyGlowing(false),
11413 invisible: Invisible(false),
11414 fall_flying: FallFlying(false),
11415 air_supply: AirSupply(Default::default()),
11416 custom_name: CustomName(Default::default()),
11417 custom_name_visible: CustomNameVisible(Default::default()),
11418 silent: Silent(Default::default()),
11419 no_gravity: NoGravity(Default::default()),
11420 pose: Pose::default(),
11421 ticks_frozen: TicksFrozen(Default::default()),
11422 },
11423 transformation_interpolation_start_delta_ticks:
11424 TransformationInterpolationStartDeltaTicks(0),
11425 transformation_interpolation_duration: TransformationInterpolationDuration(0),
11426 pos_rot_interpolation_duration: PosRotInterpolationDuration(0),
11427 translation: Translation(Vec3 {
11428 x: 0.0,
11429 y: 0.0,
11430 z: 0.0,
11431 }),
11432 scale: Scale(Vec3 {
11433 x: 1.0,
11434 y: 1.0,
11435 z: 1.0,
11436 }),
11437 left_rotation: LeftRotation(Quaternion {
11438 x: 0.0,
11439 y: 0.0,
11440 z: 0.0,
11441 w: 1.0,
11442 }),
11443 right_rotation: RightRotation(Quaternion {
11444 x: 0.0,
11445 y: 0.0,
11446 z: 0.0,
11447 w: 1.0,
11448 }),
11449 billboard_render_constraints: BillboardRenderConstraints(Default::default()),
11450 brightness_override: BrightnessOverride(-1),
11451 view_range: ViewRange(1.0),
11452 shadow_radius: ShadowRadius(0.0),
11453 shadow_strength: ShadowStrength(1.0),
11454 abstract_display_width: AbstractDisplayWidth(0.0),
11455 abstract_display_height: AbstractDisplayHeight(0.0),
11456 glow_color_override: GlowColorOverride(-1),
11457 }
11458 }
11459}
11460
11461#[derive(Component)]
11462pub struct AbstractEntity;
11463impl AbstractEntity {
11464 pub fn apply_metadata(
11465 entity: &mut bevy_ecs::system::EntityCommands,
11466 d: EntityDataItem,
11467 ) -> Result<(), UpdateMetadataError> {
11468 match d.index {
11469 0 => {
11470 let bitfield = d.value.into_byte()?;
11471 entity.insert(OnFire(bitfield & 0x1 != 0));
11472 entity.insert(ShiftKeyDown(bitfield & 0x2 != 0));
11473 entity.insert(Sprinting(bitfield & 0x8 != 0));
11474 entity.insert(Swimming(bitfield & 0x10 != 0));
11475 entity.insert(CurrentlyGlowing(bitfield & 0x40 != 0));
11476 entity.insert(Invisible(bitfield & 0x20 != 0));
11477 entity.insert(FallFlying(bitfield & 0x80 != 0));
11478 }
11479 1 => {
11480 entity.insert(AirSupply(d.value.into_int()?));
11481 }
11482 2 => {
11483 entity.insert(CustomName(d.value.into_optional_formatted_text()?));
11484 }
11485 3 => {
11486 entity.insert(CustomNameVisible(d.value.into_boolean()?));
11487 }
11488 4 => {
11489 entity.insert(Silent(d.value.into_boolean()?));
11490 }
11491 5 => {
11492 entity.insert(NoGravity(d.value.into_boolean()?));
11493 }
11494 6 => {
11495 entity.insert(d.value.into_pose()?);
11496 }
11497 7 => {
11498 entity.insert(TicksFrozen(d.value.into_int()?));
11499 }
11500 _ => {}
11501 }
11502 Ok(())
11503 }
11504}
11505
11506#[derive(Bundle)]
11507pub struct AbstractEntityMetadataBundle {
11508 _marker: AbstractEntity,
11509 on_fire: OnFire,
11510 shift_key_down: ShiftKeyDown,
11511 sprinting: Sprinting,
11512 swimming: Swimming,
11513 currently_glowing: CurrentlyGlowing,
11514 invisible: Invisible,
11515 fall_flying: FallFlying,
11516 air_supply: AirSupply,
11517 custom_name: CustomName,
11518 custom_name_visible: CustomNameVisible,
11519 silent: Silent,
11520 no_gravity: NoGravity,
11521 pose: Pose,
11522 ticks_frozen: TicksFrozen,
11523}
11524impl Default for AbstractEntityMetadataBundle {
11525 fn default() -> Self {
11526 Self {
11527 _marker: AbstractEntity,
11528 on_fire: OnFire(false),
11529 shift_key_down: ShiftKeyDown(false),
11530 sprinting: Sprinting(false),
11531 swimming: Swimming(false),
11532 currently_glowing: CurrentlyGlowing(false),
11533 invisible: Invisible(false),
11534 fall_flying: FallFlying(false),
11535 air_supply: AirSupply(Default::default()),
11536 custom_name: CustomName(Default::default()),
11537 custom_name_visible: CustomNameVisible(Default::default()),
11538 silent: Silent(Default::default()),
11539 no_gravity: NoGravity(Default::default()),
11540 pose: Pose::default(),
11541 ticks_frozen: TicksFrozen(Default::default()),
11542 }
11543 }
11544}
11545
11546#[derive(Component)]
11547pub struct AbstractFish;
11548impl AbstractFish {
11549 pub fn apply_metadata(
11550 entity: &mut bevy_ecs::system::EntityCommands,
11551 d: EntityDataItem,
11552 ) -> Result<(), UpdateMetadataError> {
11553 match d.index {
11554 0..=15 => AbstractCreature::apply_metadata(entity, d)?,
11555 16 => {
11556 entity.insert(AbstractFishFromBucket(d.value.into_boolean()?));
11557 }
11558 _ => {}
11559 }
11560 Ok(())
11561 }
11562}
11563
11564#[derive(Bundle)]
11565pub struct AbstractFishMetadataBundle {
11566 _marker: AbstractFish,
11567 parent: AbstractCreatureMetadataBundle,
11568 abstract_fish_from_bucket: AbstractFishFromBucket,
11569}
11570impl Default for AbstractFishMetadataBundle {
11571 fn default() -> Self {
11572 Self {
11573 _marker: AbstractFish,
11574 parent: AbstractCreatureMetadataBundle {
11575 _marker: AbstractCreature,
11576 parent: AbstractInsentientMetadataBundle {
11577 _marker: AbstractInsentient,
11578 parent: AbstractLivingMetadataBundle {
11579 _marker: AbstractLiving,
11580 parent: AbstractEntityMetadataBundle {
11581 _marker: AbstractEntity,
11582 on_fire: OnFire(false),
11583 shift_key_down: ShiftKeyDown(false),
11584 sprinting: Sprinting(false),
11585 swimming: Swimming(false),
11586 currently_glowing: CurrentlyGlowing(false),
11587 invisible: Invisible(false),
11588 fall_flying: FallFlying(false),
11589 air_supply: AirSupply(Default::default()),
11590 custom_name: CustomName(Default::default()),
11591 custom_name_visible: CustomNameVisible(Default::default()),
11592 silent: Silent(Default::default()),
11593 no_gravity: NoGravity(Default::default()),
11594 pose: Pose::default(),
11595 ticks_frozen: TicksFrozen(Default::default()),
11596 },
11597 auto_spin_attack: AutoSpinAttack(false),
11598 abstract_living_using_item: AbstractLivingUsingItem(false),
11599 health: Health(1.0),
11600 effect_particles: EffectParticles(Default::default()),
11601 effect_ambience: EffectAmbience(false),
11602 arrow_count: ArrowCount(0),
11603 stinger_count: StingerCount(0),
11604 sleeping_pos: SleepingPos(None),
11605 },
11606 no_ai: NoAi(false),
11607 left_handed: LeftHanded(false),
11608 aggressive: Aggressive(false),
11609 },
11610 },
11611 abstract_fish_from_bucket: AbstractFishFromBucket(false),
11612 }
11613 }
11614}
11615
11616#[derive(Component)]
11617pub struct AbstractHorse;
11618impl AbstractHorse {
11619 pub fn apply_metadata(
11620 entity: &mut bevy_ecs::system::EntityCommands,
11621 d: EntityDataItem,
11622 ) -> Result<(), UpdateMetadataError> {
11623 match d.index {
11624 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
11625 17 => {
11626 let bitfield = d.value.into_byte()?;
11627 entity.insert(Tamed(bitfield & 0x2 != 0));
11628 entity.insert(Eating(bitfield & 0x10 != 0));
11629 entity.insert(AbstractHorseStanding(bitfield & 0x20 != 0));
11630 entity.insert(Bred(bitfield & 0x8 != 0));
11631 }
11632 _ => {}
11633 }
11634 Ok(())
11635 }
11636}
11637
11638#[derive(Bundle)]
11639pub struct AbstractHorseMetadataBundle {
11640 _marker: AbstractHorse,
11641 parent: AbstractAnimalMetadataBundle,
11642 tamed: Tamed,
11643 eating: Eating,
11644 abstract_horse_standing: AbstractHorseStanding,
11645 bred: Bred,
11646}
11647impl Default for AbstractHorseMetadataBundle {
11648 fn default() -> Self {
11649 Self {
11650 _marker: AbstractHorse,
11651 parent: AbstractAnimalMetadataBundle {
11652 _marker: AbstractAnimal,
11653 parent: AbstractAgeableMetadataBundle {
11654 _marker: AbstractAgeable,
11655 parent: AbstractCreatureMetadataBundle {
11656 _marker: AbstractCreature,
11657 parent: AbstractInsentientMetadataBundle {
11658 _marker: AbstractInsentient,
11659 parent: AbstractLivingMetadataBundle {
11660 _marker: AbstractLiving,
11661 parent: AbstractEntityMetadataBundle {
11662 _marker: AbstractEntity,
11663 on_fire: OnFire(false),
11664 shift_key_down: ShiftKeyDown(false),
11665 sprinting: Sprinting(false),
11666 swimming: Swimming(false),
11667 currently_glowing: CurrentlyGlowing(false),
11668 invisible: Invisible(false),
11669 fall_flying: FallFlying(false),
11670 air_supply: AirSupply(Default::default()),
11671 custom_name: CustomName(Default::default()),
11672 custom_name_visible: CustomNameVisible(Default::default()),
11673 silent: Silent(Default::default()),
11674 no_gravity: NoGravity(Default::default()),
11675 pose: Pose::default(),
11676 ticks_frozen: TicksFrozen(Default::default()),
11677 },
11678 auto_spin_attack: AutoSpinAttack(false),
11679 abstract_living_using_item: AbstractLivingUsingItem(false),
11680 health: Health(1.0),
11681 effect_particles: EffectParticles(Default::default()),
11682 effect_ambience: EffectAmbience(false),
11683 arrow_count: ArrowCount(0),
11684 stinger_count: StingerCount(0),
11685 sleeping_pos: SleepingPos(None),
11686 },
11687 no_ai: NoAi(false),
11688 left_handed: LeftHanded(false),
11689 aggressive: Aggressive(false),
11690 },
11691 },
11692 abstract_ageable_baby: AbstractAgeableBaby(false),
11693 },
11694 },
11695 tamed: Tamed(false),
11696 eating: Eating(false),
11697 abstract_horse_standing: AbstractHorseStanding(false),
11698 bred: Bred(false),
11699 }
11700 }
11701}
11702
11703#[derive(Component)]
11704pub struct AbstractInsentient;
11705impl AbstractInsentient {
11706 pub fn apply_metadata(
11707 entity: &mut bevy_ecs::system::EntityCommands,
11708 d: EntityDataItem,
11709 ) -> Result<(), UpdateMetadataError> {
11710 match d.index {
11711 0..=14 => AbstractLiving::apply_metadata(entity, d)?,
11712 15 => {
11713 let bitfield = d.value.into_byte()?;
11714 entity.insert(NoAi(bitfield & 0x1 != 0));
11715 entity.insert(LeftHanded(bitfield & 0x2 != 0));
11716 entity.insert(Aggressive(bitfield & 0x4 != 0));
11717 }
11718 _ => {}
11719 }
11720 Ok(())
11721 }
11722}
11723
11724#[derive(Bundle)]
11725pub struct AbstractInsentientMetadataBundle {
11726 _marker: AbstractInsentient,
11727 parent: AbstractLivingMetadataBundle,
11728 no_ai: NoAi,
11729 left_handed: LeftHanded,
11730 aggressive: Aggressive,
11731}
11732impl Default for AbstractInsentientMetadataBundle {
11733 fn default() -> Self {
11734 Self {
11735 _marker: AbstractInsentient,
11736 parent: AbstractLivingMetadataBundle {
11737 _marker: AbstractLiving,
11738 parent: AbstractEntityMetadataBundle {
11739 _marker: AbstractEntity,
11740 on_fire: OnFire(false),
11741 shift_key_down: ShiftKeyDown(false),
11742 sprinting: Sprinting(false),
11743 swimming: Swimming(false),
11744 currently_glowing: CurrentlyGlowing(false),
11745 invisible: Invisible(false),
11746 fall_flying: FallFlying(false),
11747 air_supply: AirSupply(Default::default()),
11748 custom_name: CustomName(Default::default()),
11749 custom_name_visible: CustomNameVisible(Default::default()),
11750 silent: Silent(Default::default()),
11751 no_gravity: NoGravity(Default::default()),
11752 pose: Pose::default(),
11753 ticks_frozen: TicksFrozen(Default::default()),
11754 },
11755 auto_spin_attack: AutoSpinAttack(false),
11756 abstract_living_using_item: AbstractLivingUsingItem(false),
11757 health: Health(1.0),
11758 effect_particles: EffectParticles(Default::default()),
11759 effect_ambience: EffectAmbience(false),
11760 arrow_count: ArrowCount(0),
11761 stinger_count: StingerCount(0),
11762 sleeping_pos: SleepingPos(None),
11763 },
11764 no_ai: NoAi(false),
11765 left_handed: LeftHanded(false),
11766 aggressive: Aggressive(false),
11767 }
11768 }
11769}
11770
11771#[derive(Component)]
11772pub struct AbstractLiving;
11773impl AbstractLiving {
11774 pub fn apply_metadata(
11775 entity: &mut bevy_ecs::system::EntityCommands,
11776 d: EntityDataItem,
11777 ) -> Result<(), UpdateMetadataError> {
11778 match d.index {
11779 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
11780 8 => {
11781 let bitfield = d.value.into_byte()?;
11782 entity.insert(AutoSpinAttack(bitfield & 0x4 != 0));
11783 entity.insert(AbstractLivingUsingItem(bitfield & 0x1 != 0));
11784 }
11785 9 => {
11786 entity.insert(Health(d.value.into_float()?));
11787 }
11788 10 => {
11789 entity.insert(EffectParticles(d.value.into_particles()?));
11790 }
11791 11 => {
11792 entity.insert(EffectAmbience(d.value.into_boolean()?));
11793 }
11794 12 => {
11795 entity.insert(ArrowCount(d.value.into_int()?));
11796 }
11797 13 => {
11798 entity.insert(StingerCount(d.value.into_int()?));
11799 }
11800 14 => {
11801 entity.insert(SleepingPos(d.value.into_optional_block_pos()?));
11802 }
11803 _ => {}
11804 }
11805 Ok(())
11806 }
11807}
11808
11809#[derive(Bundle)]
11810pub struct AbstractLivingMetadataBundle {
11811 _marker: AbstractLiving,
11812 parent: AbstractEntityMetadataBundle,
11813 auto_spin_attack: AutoSpinAttack,
11814 abstract_living_using_item: AbstractLivingUsingItem,
11815 health: Health,
11816 effect_particles: EffectParticles,
11817 effect_ambience: EffectAmbience,
11818 arrow_count: ArrowCount,
11819 stinger_count: StingerCount,
11820 sleeping_pos: SleepingPos,
11821}
11822impl Default for AbstractLivingMetadataBundle {
11823 fn default() -> Self {
11824 Self {
11825 _marker: AbstractLiving,
11826 parent: AbstractEntityMetadataBundle {
11827 _marker: AbstractEntity,
11828 on_fire: OnFire(false),
11829 shift_key_down: ShiftKeyDown(false),
11830 sprinting: Sprinting(false),
11831 swimming: Swimming(false),
11832 currently_glowing: CurrentlyGlowing(false),
11833 invisible: Invisible(false),
11834 fall_flying: FallFlying(false),
11835 air_supply: AirSupply(Default::default()),
11836 custom_name: CustomName(Default::default()),
11837 custom_name_visible: CustomNameVisible(Default::default()),
11838 silent: Silent(Default::default()),
11839 no_gravity: NoGravity(Default::default()),
11840 pose: Pose::default(),
11841 ticks_frozen: TicksFrozen(Default::default()),
11842 },
11843 auto_spin_attack: AutoSpinAttack(false),
11844 abstract_living_using_item: AbstractLivingUsingItem(false),
11845 health: Health(1.0),
11846 effect_particles: EffectParticles(Default::default()),
11847 effect_ambience: EffectAmbience(false),
11848 arrow_count: ArrowCount(0),
11849 stinger_count: StingerCount(0),
11850 sleeping_pos: SleepingPos(None),
11851 }
11852 }
11853}
11854
11855#[derive(Component)]
11856pub struct AbstractMinecart;
11857impl AbstractMinecart {
11858 pub fn apply_metadata(
11859 entity: &mut bevy_ecs::system::EntityCommands,
11860 d: EntityDataItem,
11861 ) -> Result<(), UpdateMetadataError> {
11862 match d.index {
11863 0..=10 => AbstractVehicle::apply_metadata(entity, d)?,
11864 11 => {
11865 entity.insert(CustomDisplayBlock(d.value.into_optional_block_state()?));
11866 }
11867 12 => {
11868 entity.insert(DisplayOffset(d.value.into_int()?));
11869 }
11870 _ => {}
11871 }
11872 Ok(())
11873 }
11874}
11875
11876#[derive(Bundle)]
11877pub struct AbstractMinecartMetadataBundle {
11878 _marker: AbstractMinecart,
11879 parent: AbstractVehicleMetadataBundle,
11880 custom_display_block: CustomDisplayBlock,
11881 display_offset: DisplayOffset,
11882}
11883impl Default for AbstractMinecartMetadataBundle {
11884 fn default() -> Self {
11885 Self {
11886 _marker: AbstractMinecart,
11887 parent: AbstractVehicleMetadataBundle {
11888 _marker: AbstractVehicle,
11889 parent: AbstractEntityMetadataBundle {
11890 _marker: AbstractEntity,
11891 on_fire: OnFire(false),
11892 shift_key_down: ShiftKeyDown(false),
11893 sprinting: Sprinting(false),
11894 swimming: Swimming(false),
11895 currently_glowing: CurrentlyGlowing(false),
11896 invisible: Invisible(false),
11897 fall_flying: FallFlying(false),
11898 air_supply: AirSupply(Default::default()),
11899 custom_name: CustomName(Default::default()),
11900 custom_name_visible: CustomNameVisible(Default::default()),
11901 silent: Silent(Default::default()),
11902 no_gravity: NoGravity(Default::default()),
11903 pose: Pose::default(),
11904 ticks_frozen: TicksFrozen(Default::default()),
11905 },
11906 hurt: Hurt(0),
11907 hurtdir: Hurtdir(1),
11908 damage: Damage(0.0),
11909 },
11910 custom_display_block: CustomDisplayBlock(azalea_block::BlockState::AIR),
11911 display_offset: DisplayOffset(Default::default()),
11912 }
11913 }
11914}
11915
11916#[derive(Component)]
11917pub struct AbstractMonster;
11918impl AbstractMonster {
11919 pub fn apply_metadata(
11920 entity: &mut bevy_ecs::system::EntityCommands,
11921 d: EntityDataItem,
11922 ) -> Result<(), UpdateMetadataError> {
11923 match d.index {
11924 0..=15 => AbstractCreature::apply_metadata(entity, d)?,
11925 _ => {}
11926 }
11927 Ok(())
11928 }
11929}
11930
11931#[derive(Bundle)]
11932pub struct AbstractMonsterMetadataBundle {
11933 _marker: AbstractMonster,
11934 parent: AbstractCreatureMetadataBundle,
11935}
11936impl Default for AbstractMonsterMetadataBundle {
11937 fn default() -> Self {
11938 Self {
11939 _marker: AbstractMonster,
11940 parent: AbstractCreatureMetadataBundle {
11941 _marker: AbstractCreature,
11942 parent: AbstractInsentientMetadataBundle {
11943 _marker: AbstractInsentient,
11944 parent: AbstractLivingMetadataBundle {
11945 _marker: AbstractLiving,
11946 parent: AbstractEntityMetadataBundle {
11947 _marker: AbstractEntity,
11948 on_fire: OnFire(false),
11949 shift_key_down: ShiftKeyDown(false),
11950 sprinting: Sprinting(false),
11951 swimming: Swimming(false),
11952 currently_glowing: CurrentlyGlowing(false),
11953 invisible: Invisible(false),
11954 fall_flying: FallFlying(false),
11955 air_supply: AirSupply(Default::default()),
11956 custom_name: CustomName(Default::default()),
11957 custom_name_visible: CustomNameVisible(Default::default()),
11958 silent: Silent(Default::default()),
11959 no_gravity: NoGravity(Default::default()),
11960 pose: Pose::default(),
11961 ticks_frozen: TicksFrozen(Default::default()),
11962 },
11963 auto_spin_attack: AutoSpinAttack(false),
11964 abstract_living_using_item: AbstractLivingUsingItem(false),
11965 health: Health(1.0),
11966 effect_particles: EffectParticles(Default::default()),
11967 effect_ambience: EffectAmbience(false),
11968 arrow_count: ArrowCount(0),
11969 stinger_count: StingerCount(0),
11970 sleeping_pos: SleepingPos(None),
11971 },
11972 no_ai: NoAi(false),
11973 left_handed: LeftHanded(false),
11974 aggressive: Aggressive(false),
11975 },
11976 },
11977 }
11978 }
11979}
11980
11981#[derive(Component)]
11982pub struct AbstractPiglin;
11983impl AbstractPiglin {
11984 pub fn apply_metadata(
11985 entity: &mut bevy_ecs::system::EntityCommands,
11986 d: EntityDataItem,
11987 ) -> Result<(), UpdateMetadataError> {
11988 match d.index {
11989 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
11990 16 => {
11991 entity.insert(AbstractPiglinImmuneToZombification(d.value.into_boolean()?));
11992 }
11993 _ => {}
11994 }
11995 Ok(())
11996 }
11997}
11998
11999#[derive(Bundle)]
12000pub struct AbstractPiglinMetadataBundle {
12001 _marker: AbstractPiglin,
12002 parent: AbstractMonsterMetadataBundle,
12003 abstract_piglin_immune_to_zombification: AbstractPiglinImmuneToZombification,
12004}
12005impl Default for AbstractPiglinMetadataBundle {
12006 fn default() -> Self {
12007 Self {
12008 _marker: AbstractPiglin,
12009 parent: AbstractMonsterMetadataBundle {
12010 _marker: AbstractMonster,
12011 parent: AbstractCreatureMetadataBundle {
12012 _marker: AbstractCreature,
12013 parent: AbstractInsentientMetadataBundle {
12014 _marker: AbstractInsentient,
12015 parent: AbstractLivingMetadataBundle {
12016 _marker: AbstractLiving,
12017 parent: AbstractEntityMetadataBundle {
12018 _marker: AbstractEntity,
12019 on_fire: OnFire(false),
12020 shift_key_down: ShiftKeyDown(false),
12021 sprinting: Sprinting(false),
12022 swimming: Swimming(false),
12023 currently_glowing: CurrentlyGlowing(false),
12024 invisible: Invisible(false),
12025 fall_flying: FallFlying(false),
12026 air_supply: AirSupply(Default::default()),
12027 custom_name: CustomName(Default::default()),
12028 custom_name_visible: CustomNameVisible(Default::default()),
12029 silent: Silent(Default::default()),
12030 no_gravity: NoGravity(Default::default()),
12031 pose: Pose::default(),
12032 ticks_frozen: TicksFrozen(Default::default()),
12033 },
12034 auto_spin_attack: AutoSpinAttack(false),
12035 abstract_living_using_item: AbstractLivingUsingItem(false),
12036 health: Health(1.0),
12037 effect_particles: EffectParticles(Default::default()),
12038 effect_ambience: EffectAmbience(false),
12039 arrow_count: ArrowCount(0),
12040 stinger_count: StingerCount(0),
12041 sleeping_pos: SleepingPos(None),
12042 },
12043 no_ai: NoAi(false),
12044 left_handed: LeftHanded(false),
12045 aggressive: Aggressive(false),
12046 },
12047 },
12048 },
12049 abstract_piglin_immune_to_zombification: AbstractPiglinImmuneToZombification(false),
12050 }
12051 }
12052}
12053
12054#[derive(Component)]
12055pub struct AbstractRaider;
12056impl AbstractRaider {
12057 pub fn apply_metadata(
12058 entity: &mut bevy_ecs::system::EntityCommands,
12059 d: EntityDataItem,
12060 ) -> Result<(), UpdateMetadataError> {
12061 match d.index {
12062 0..=15 => AbstractMonster::apply_metadata(entity, d)?,
12063 16 => {
12064 entity.insert(IsCelebrating(d.value.into_boolean()?));
12065 }
12066 _ => {}
12067 }
12068 Ok(())
12069 }
12070}
12071
12072#[derive(Bundle)]
12073pub struct AbstractRaiderMetadataBundle {
12074 _marker: AbstractRaider,
12075 parent: AbstractMonsterMetadataBundle,
12076 is_celebrating: IsCelebrating,
12077}
12078impl Default for AbstractRaiderMetadataBundle {
12079 fn default() -> Self {
12080 Self {
12081 _marker: AbstractRaider,
12082 parent: AbstractMonsterMetadataBundle {
12083 _marker: AbstractMonster,
12084 parent: AbstractCreatureMetadataBundle {
12085 _marker: AbstractCreature,
12086 parent: AbstractInsentientMetadataBundle {
12087 _marker: AbstractInsentient,
12088 parent: AbstractLivingMetadataBundle {
12089 _marker: AbstractLiving,
12090 parent: AbstractEntityMetadataBundle {
12091 _marker: AbstractEntity,
12092 on_fire: OnFire(false),
12093 shift_key_down: ShiftKeyDown(false),
12094 sprinting: Sprinting(false),
12095 swimming: Swimming(false),
12096 currently_glowing: CurrentlyGlowing(false),
12097 invisible: Invisible(false),
12098 fall_flying: FallFlying(false),
12099 air_supply: AirSupply(Default::default()),
12100 custom_name: CustomName(Default::default()),
12101 custom_name_visible: CustomNameVisible(Default::default()),
12102 silent: Silent(Default::default()),
12103 no_gravity: NoGravity(Default::default()),
12104 pose: Pose::default(),
12105 ticks_frozen: TicksFrozen(Default::default()),
12106 },
12107 auto_spin_attack: AutoSpinAttack(false),
12108 abstract_living_using_item: AbstractLivingUsingItem(false),
12109 health: Health(1.0),
12110 effect_particles: EffectParticles(Default::default()),
12111 effect_ambience: EffectAmbience(false),
12112 arrow_count: ArrowCount(0),
12113 stinger_count: StingerCount(0),
12114 sleeping_pos: SleepingPos(None),
12115 },
12116 no_ai: NoAi(false),
12117 left_handed: LeftHanded(false),
12118 aggressive: Aggressive(false),
12119 },
12120 },
12121 },
12122 is_celebrating: IsCelebrating(false),
12123 }
12124 }
12125}
12126
12127#[derive(Component)]
12128pub struct AbstractSpellcasterIllager;
12129impl AbstractSpellcasterIllager {
12130 pub fn apply_metadata(
12131 entity: &mut bevy_ecs::system::EntityCommands,
12132 d: EntityDataItem,
12133 ) -> Result<(), UpdateMetadataError> {
12134 match d.index {
12135 0..=16 => AbstractRaider::apply_metadata(entity, d)?,
12136 17 => {
12137 entity.insert(SpellCasting(d.value.into_byte()?));
12138 }
12139 _ => {}
12140 }
12141 Ok(())
12142 }
12143}
12144
12145#[derive(Bundle)]
12146pub struct AbstractSpellcasterIllagerMetadataBundle {
12147 _marker: AbstractSpellcasterIllager,
12148 parent: AbstractRaiderMetadataBundle,
12149 spell_casting: SpellCasting,
12150}
12151impl Default for AbstractSpellcasterIllagerMetadataBundle {
12152 fn default() -> Self {
12153 Self {
12154 _marker: AbstractSpellcasterIllager,
12155 parent: AbstractRaiderMetadataBundle {
12156 _marker: AbstractRaider,
12157 parent: AbstractMonsterMetadataBundle {
12158 _marker: AbstractMonster,
12159 parent: AbstractCreatureMetadataBundle {
12160 _marker: AbstractCreature,
12161 parent: AbstractInsentientMetadataBundle {
12162 _marker: AbstractInsentient,
12163 parent: AbstractLivingMetadataBundle {
12164 _marker: AbstractLiving,
12165 parent: AbstractEntityMetadataBundle {
12166 _marker: AbstractEntity,
12167 on_fire: OnFire(false),
12168 shift_key_down: ShiftKeyDown(false),
12169 sprinting: Sprinting(false),
12170 swimming: Swimming(false),
12171 currently_glowing: CurrentlyGlowing(false),
12172 invisible: Invisible(false),
12173 fall_flying: FallFlying(false),
12174 air_supply: AirSupply(Default::default()),
12175 custom_name: CustomName(Default::default()),
12176 custom_name_visible: CustomNameVisible(Default::default()),
12177 silent: Silent(Default::default()),
12178 no_gravity: NoGravity(Default::default()),
12179 pose: Pose::default(),
12180 ticks_frozen: TicksFrozen(Default::default()),
12181 },
12182 auto_spin_attack: AutoSpinAttack(false),
12183 abstract_living_using_item: AbstractLivingUsingItem(false),
12184 health: Health(1.0),
12185 effect_particles: EffectParticles(Default::default()),
12186 effect_ambience: EffectAmbience(false),
12187 arrow_count: ArrowCount(0),
12188 stinger_count: StingerCount(0),
12189 sleeping_pos: SleepingPos(None),
12190 },
12191 no_ai: NoAi(false),
12192 left_handed: LeftHanded(false),
12193 aggressive: Aggressive(false),
12194 },
12195 },
12196 },
12197 is_celebrating: IsCelebrating(false),
12198 },
12199 spell_casting: SpellCasting(0),
12200 }
12201 }
12202}
12203
12204#[derive(Component)]
12205pub struct AbstractTameable;
12206impl AbstractTameable {
12207 pub fn apply_metadata(
12208 entity: &mut bevy_ecs::system::EntityCommands,
12209 d: EntityDataItem,
12210 ) -> Result<(), UpdateMetadataError> {
12211 match d.index {
12212 0..=16 => AbstractAnimal::apply_metadata(entity, d)?,
12213 17 => {
12214 let bitfield = d.value.into_byte()?;
12215 entity.insert(Tame(bitfield & 0x4 != 0));
12216 entity.insert(InSittingPose(bitfield & 0x1 != 0));
12217 }
12218 18 => {
12219 entity.insert(Owneruuid(d.value.into_optional_living_entity_reference()?));
12220 }
12221 _ => {}
12222 }
12223 Ok(())
12224 }
12225}
12226
12227#[derive(Bundle)]
12228pub struct AbstractTameableMetadataBundle {
12229 _marker: AbstractTameable,
12230 parent: AbstractAnimalMetadataBundle,
12231 tame: Tame,
12232 in_sitting_pose: InSittingPose,
12233 owneruuid: Owneruuid,
12234}
12235impl Default for AbstractTameableMetadataBundle {
12236 fn default() -> Self {
12237 Self {
12238 _marker: AbstractTameable,
12239 parent: AbstractAnimalMetadataBundle {
12240 _marker: AbstractAnimal,
12241 parent: AbstractAgeableMetadataBundle {
12242 _marker: AbstractAgeable,
12243 parent: AbstractCreatureMetadataBundle {
12244 _marker: AbstractCreature,
12245 parent: AbstractInsentientMetadataBundle {
12246 _marker: AbstractInsentient,
12247 parent: AbstractLivingMetadataBundle {
12248 _marker: AbstractLiving,
12249 parent: AbstractEntityMetadataBundle {
12250 _marker: AbstractEntity,
12251 on_fire: OnFire(false),
12252 shift_key_down: ShiftKeyDown(false),
12253 sprinting: Sprinting(false),
12254 swimming: Swimming(false),
12255 currently_glowing: CurrentlyGlowing(false),
12256 invisible: Invisible(false),
12257 fall_flying: FallFlying(false),
12258 air_supply: AirSupply(Default::default()),
12259 custom_name: CustomName(Default::default()),
12260 custom_name_visible: CustomNameVisible(Default::default()),
12261 silent: Silent(Default::default()),
12262 no_gravity: NoGravity(Default::default()),
12263 pose: Pose::default(),
12264 ticks_frozen: TicksFrozen(Default::default()),
12265 },
12266 auto_spin_attack: AutoSpinAttack(false),
12267 abstract_living_using_item: AbstractLivingUsingItem(false),
12268 health: Health(1.0),
12269 effect_particles: EffectParticles(Default::default()),
12270 effect_ambience: EffectAmbience(false),
12271 arrow_count: ArrowCount(0),
12272 stinger_count: StingerCount(0),
12273 sleeping_pos: SleepingPos(None),
12274 },
12275 no_ai: NoAi(false),
12276 left_handed: LeftHanded(false),
12277 aggressive: Aggressive(false),
12278 },
12279 },
12280 abstract_ageable_baby: AbstractAgeableBaby(false),
12281 },
12282 },
12283 tame: Tame(false),
12284 in_sitting_pose: InSittingPose(false),
12285 owneruuid: Owneruuid(None),
12286 }
12287 }
12288}
12289
12290#[derive(Component)]
12291pub struct AbstractThrownItemProjectile;
12292impl AbstractThrownItemProjectile {
12293 pub fn apply_metadata(
12294 entity: &mut bevy_ecs::system::EntityCommands,
12295 d: EntityDataItem,
12296 ) -> Result<(), UpdateMetadataError> {
12297 match d.index {
12298 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
12299 8 => {
12300 entity.insert(AbstractThrownItemProjectileItemStack(
12301 d.value.into_item_stack()?,
12302 ));
12303 }
12304 _ => {}
12305 }
12306 Ok(())
12307 }
12308}
12309
12310#[derive(Bundle)]
12311pub struct AbstractThrownItemProjectileMetadataBundle {
12312 _marker: AbstractThrownItemProjectile,
12313 parent: AbstractEntityMetadataBundle,
12314 abstract_thrown_item_projectile_item_stack: AbstractThrownItemProjectileItemStack,
12315}
12316impl Default for AbstractThrownItemProjectileMetadataBundle {
12317 fn default() -> Self {
12318 Self {
12319 _marker: AbstractThrownItemProjectile,
12320 parent: AbstractEntityMetadataBundle {
12321 _marker: AbstractEntity,
12322 on_fire: OnFire(false),
12323 shift_key_down: ShiftKeyDown(false),
12324 sprinting: Sprinting(false),
12325 swimming: Swimming(false),
12326 currently_glowing: CurrentlyGlowing(false),
12327 invisible: Invisible(false),
12328 fall_flying: FallFlying(false),
12329 air_supply: AirSupply(Default::default()),
12330 custom_name: CustomName(Default::default()),
12331 custom_name_visible: CustomNameVisible(Default::default()),
12332 silent: Silent(Default::default()),
12333 no_gravity: NoGravity(Default::default()),
12334 pose: Pose::default(),
12335 ticks_frozen: TicksFrozen(Default::default()),
12336 },
12337 abstract_thrown_item_projectile_item_stack: AbstractThrownItemProjectileItemStack(
12338 Default::default(),
12339 ),
12340 }
12341 }
12342}
12343
12344#[derive(Component)]
12345pub struct AbstractVehicle;
12346impl AbstractVehicle {
12347 pub fn apply_metadata(
12348 entity: &mut bevy_ecs::system::EntityCommands,
12349 d: EntityDataItem,
12350 ) -> Result<(), UpdateMetadataError> {
12351 match d.index {
12352 0..=7 => AbstractEntity::apply_metadata(entity, d)?,
12353 8 => {
12354 entity.insert(Hurt(d.value.into_int()?));
12355 }
12356 9 => {
12357 entity.insert(Hurtdir(d.value.into_int()?));
12358 }
12359 10 => {
12360 entity.insert(Damage(d.value.into_float()?));
12361 }
12362 _ => {}
12363 }
12364 Ok(())
12365 }
12366}
12367
12368#[derive(Bundle)]
12369pub struct AbstractVehicleMetadataBundle {
12370 _marker: AbstractVehicle,
12371 parent: AbstractEntityMetadataBundle,
12372 hurt: Hurt,
12373 hurtdir: Hurtdir,
12374 damage: Damage,
12375}
12376impl Default for AbstractVehicleMetadataBundle {
12377 fn default() -> Self {
12378 Self {
12379 _marker: AbstractVehicle,
12380 parent: AbstractEntityMetadataBundle {
12381 _marker: AbstractEntity,
12382 on_fire: OnFire(false),
12383 shift_key_down: ShiftKeyDown(false),
12384 sprinting: Sprinting(false),
12385 swimming: Swimming(false),
12386 currently_glowing: CurrentlyGlowing(false),
12387 invisible: Invisible(false),
12388 fall_flying: FallFlying(false),
12389 air_supply: AirSupply(Default::default()),
12390 custom_name: CustomName(Default::default()),
12391 custom_name_visible: CustomNameVisible(Default::default()),
12392 silent: Silent(Default::default()),
12393 no_gravity: NoGravity(Default::default()),
12394 pose: Pose::default(),
12395 ticks_frozen: TicksFrozen(Default::default()),
12396 },
12397 hurt: Hurt(0),
12398 hurtdir: Hurtdir(1),
12399 damage: Damage(0.0),
12400 }
12401 }
12402}
12403
12404#[derive(Component)]
12405pub struct AbstractVillager;
12406impl AbstractVillager {
12407 pub fn apply_metadata(
12408 entity: &mut bevy_ecs::system::EntityCommands,
12409 d: EntityDataItem,
12410 ) -> Result<(), UpdateMetadataError> {
12411 match d.index {
12412 0..=16 => AbstractAgeable::apply_metadata(entity, d)?,
12413 17 => {
12414 entity.insert(AbstractVillagerUnhappyCounter(d.value.into_int()?));
12415 }
12416 _ => {}
12417 }
12418 Ok(())
12419 }
12420}
12421
12422#[derive(Bundle)]
12423pub struct AbstractVillagerMetadataBundle {
12424 _marker: AbstractVillager,
12425 parent: AbstractAgeableMetadataBundle,
12426 abstract_villager_unhappy_counter: AbstractVillagerUnhappyCounter,
12427}
12428impl Default for AbstractVillagerMetadataBundle {
12429 fn default() -> Self {
12430 Self {
12431 _marker: AbstractVillager,
12432 parent: AbstractAgeableMetadataBundle {
12433 _marker: AbstractAgeable,
12434 parent: AbstractCreatureMetadataBundle {
12435 _marker: AbstractCreature,
12436 parent: AbstractInsentientMetadataBundle {
12437 _marker: AbstractInsentient,
12438 parent: AbstractLivingMetadataBundle {
12439 _marker: AbstractLiving,
12440 parent: AbstractEntityMetadataBundle {
12441 _marker: AbstractEntity,
12442 on_fire: OnFire(false),
12443 shift_key_down: ShiftKeyDown(false),
12444 sprinting: Sprinting(false),
12445 swimming: Swimming(false),
12446 currently_glowing: CurrentlyGlowing(false),
12447 invisible: Invisible(false),
12448 fall_flying: FallFlying(false),
12449 air_supply: AirSupply(Default::default()),
12450 custom_name: CustomName(Default::default()),
12451 custom_name_visible: CustomNameVisible(Default::default()),
12452 silent: Silent(Default::default()),
12453 no_gravity: NoGravity(Default::default()),
12454 pose: Pose::default(),
12455 ticks_frozen: TicksFrozen(Default::default()),
12456 },
12457 auto_spin_attack: AutoSpinAttack(false),
12458 abstract_living_using_item: AbstractLivingUsingItem(false),
12459 health: Health(1.0),
12460 effect_particles: EffectParticles(Default::default()),
12461 effect_ambience: EffectAmbience(false),
12462 arrow_count: ArrowCount(0),
12463 stinger_count: StingerCount(0),
12464 sleeping_pos: SleepingPos(None),
12465 },
12466 no_ai: NoAi(false),
12467 left_handed: LeftHanded(false),
12468 aggressive: Aggressive(false),
12469 },
12470 },
12471 abstract_ageable_baby: AbstractAgeableBaby(false),
12472 },
12473 abstract_villager_unhappy_counter: AbstractVillagerUnhappyCounter(0),
12474 }
12475 }
12476}
12477
12478pub fn apply_metadata(
12479 entity: &mut bevy_ecs::system::EntityCommands,
12480 entity_kind: azalea_registry::EntityKind,
12481 items: Vec<EntityDataItem>,
12482) -> Result<(), UpdateMetadataError> {
12483 match entity_kind {
12484 azalea_registry::EntityKind::AcaciaBoat => {
12485 for d in items {
12486 AcaciaBoat::apply_metadata(entity, d)?;
12487 }
12488 }
12489 azalea_registry::EntityKind::AcaciaChestBoat => {
12490 for d in items {
12491 AcaciaChestBoat::apply_metadata(entity, d)?;
12492 }
12493 }
12494 azalea_registry::EntityKind::Allay => {
12495 for d in items {
12496 Allay::apply_metadata(entity, d)?;
12497 }
12498 }
12499 azalea_registry::EntityKind::AreaEffectCloud => {
12500 for d in items {
12501 AreaEffectCloud::apply_metadata(entity, d)?;
12502 }
12503 }
12504 azalea_registry::EntityKind::Armadillo => {
12505 for d in items {
12506 Armadillo::apply_metadata(entity, d)?;
12507 }
12508 }
12509 azalea_registry::EntityKind::ArmorStand => {
12510 for d in items {
12511 ArmorStand::apply_metadata(entity, d)?;
12512 }
12513 }
12514 azalea_registry::EntityKind::Arrow => {
12515 for d in items {
12516 Arrow::apply_metadata(entity, d)?;
12517 }
12518 }
12519 azalea_registry::EntityKind::Axolotl => {
12520 for d in items {
12521 Axolotl::apply_metadata(entity, d)?;
12522 }
12523 }
12524 azalea_registry::EntityKind::BambooChestRaft => {
12525 for d in items {
12526 BambooChestRaft::apply_metadata(entity, d)?;
12527 }
12528 }
12529 azalea_registry::EntityKind::BambooRaft => {
12530 for d in items {
12531 BambooRaft::apply_metadata(entity, d)?;
12532 }
12533 }
12534 azalea_registry::EntityKind::Bat => {
12535 for d in items {
12536 Bat::apply_metadata(entity, d)?;
12537 }
12538 }
12539 azalea_registry::EntityKind::Bee => {
12540 for d in items {
12541 Bee::apply_metadata(entity, d)?;
12542 }
12543 }
12544 azalea_registry::EntityKind::BirchBoat => {
12545 for d in items {
12546 BirchBoat::apply_metadata(entity, d)?;
12547 }
12548 }
12549 azalea_registry::EntityKind::BirchChestBoat => {
12550 for d in items {
12551 BirchChestBoat::apply_metadata(entity, d)?;
12552 }
12553 }
12554 azalea_registry::EntityKind::Blaze => {
12555 for d in items {
12556 Blaze::apply_metadata(entity, d)?;
12557 }
12558 }
12559 azalea_registry::EntityKind::BlockDisplay => {
12560 for d in items {
12561 BlockDisplay::apply_metadata(entity, d)?;
12562 }
12563 }
12564 azalea_registry::EntityKind::Bogged => {
12565 for d in items {
12566 Bogged::apply_metadata(entity, d)?;
12567 }
12568 }
12569 azalea_registry::EntityKind::Breeze => {
12570 for d in items {
12571 Breeze::apply_metadata(entity, d)?;
12572 }
12573 }
12574 azalea_registry::EntityKind::BreezeWindCharge => {
12575 for d in items {
12576 BreezeWindCharge::apply_metadata(entity, d)?;
12577 }
12578 }
12579 azalea_registry::EntityKind::Camel => {
12580 for d in items {
12581 Camel::apply_metadata(entity, d)?;
12582 }
12583 }
12584 azalea_registry::EntityKind::Cat => {
12585 for d in items {
12586 Cat::apply_metadata(entity, d)?;
12587 }
12588 }
12589 azalea_registry::EntityKind::CaveSpider => {
12590 for d in items {
12591 CaveSpider::apply_metadata(entity, d)?;
12592 }
12593 }
12594 azalea_registry::EntityKind::CherryBoat => {
12595 for d in items {
12596 CherryBoat::apply_metadata(entity, d)?;
12597 }
12598 }
12599 azalea_registry::EntityKind::CherryChestBoat => {
12600 for d in items {
12601 CherryChestBoat::apply_metadata(entity, d)?;
12602 }
12603 }
12604 azalea_registry::EntityKind::ChestMinecart => {
12605 for d in items {
12606 ChestMinecart::apply_metadata(entity, d)?;
12607 }
12608 }
12609 azalea_registry::EntityKind::Chicken => {
12610 for d in items {
12611 Chicken::apply_metadata(entity, d)?;
12612 }
12613 }
12614 azalea_registry::EntityKind::Cod => {
12615 for d in items {
12616 Cod::apply_metadata(entity, d)?;
12617 }
12618 }
12619 azalea_registry::EntityKind::CommandBlockMinecart => {
12620 for d in items {
12621 CommandBlockMinecart::apply_metadata(entity, d)?;
12622 }
12623 }
12624 azalea_registry::EntityKind::Cow => {
12625 for d in items {
12626 Cow::apply_metadata(entity, d)?;
12627 }
12628 }
12629 azalea_registry::EntityKind::Creaking => {
12630 for d in items {
12631 Creaking::apply_metadata(entity, d)?;
12632 }
12633 }
12634 azalea_registry::EntityKind::Creeper => {
12635 for d in items {
12636 Creeper::apply_metadata(entity, d)?;
12637 }
12638 }
12639 azalea_registry::EntityKind::DarkOakBoat => {
12640 for d in items {
12641 DarkOakBoat::apply_metadata(entity, d)?;
12642 }
12643 }
12644 azalea_registry::EntityKind::DarkOakChestBoat => {
12645 for d in items {
12646 DarkOakChestBoat::apply_metadata(entity, d)?;
12647 }
12648 }
12649 azalea_registry::EntityKind::Dolphin => {
12650 for d in items {
12651 Dolphin::apply_metadata(entity, d)?;
12652 }
12653 }
12654 azalea_registry::EntityKind::Donkey => {
12655 for d in items {
12656 Donkey::apply_metadata(entity, d)?;
12657 }
12658 }
12659 azalea_registry::EntityKind::DragonFireball => {
12660 for d in items {
12661 DragonFireball::apply_metadata(entity, d)?;
12662 }
12663 }
12664 azalea_registry::EntityKind::Drowned => {
12665 for d in items {
12666 Drowned::apply_metadata(entity, d)?;
12667 }
12668 }
12669 azalea_registry::EntityKind::Egg => {
12670 for d in items {
12671 Egg::apply_metadata(entity, d)?;
12672 }
12673 }
12674 azalea_registry::EntityKind::ElderGuardian => {
12675 for d in items {
12676 ElderGuardian::apply_metadata(entity, d)?;
12677 }
12678 }
12679 azalea_registry::EntityKind::EndCrystal => {
12680 for d in items {
12681 EndCrystal::apply_metadata(entity, d)?;
12682 }
12683 }
12684 azalea_registry::EntityKind::EnderDragon => {
12685 for d in items {
12686 EnderDragon::apply_metadata(entity, d)?;
12687 }
12688 }
12689 azalea_registry::EntityKind::EnderPearl => {
12690 for d in items {
12691 EnderPearl::apply_metadata(entity, d)?;
12692 }
12693 }
12694 azalea_registry::EntityKind::Enderman => {
12695 for d in items {
12696 Enderman::apply_metadata(entity, d)?;
12697 }
12698 }
12699 azalea_registry::EntityKind::Endermite => {
12700 for d in items {
12701 Endermite::apply_metadata(entity, d)?;
12702 }
12703 }
12704 azalea_registry::EntityKind::Evoker => {
12705 for d in items {
12706 Evoker::apply_metadata(entity, d)?;
12707 }
12708 }
12709 azalea_registry::EntityKind::EvokerFangs => {
12710 for d in items {
12711 EvokerFangs::apply_metadata(entity, d)?;
12712 }
12713 }
12714 azalea_registry::EntityKind::ExperienceBottle => {
12715 for d in items {
12716 ExperienceBottle::apply_metadata(entity, d)?;
12717 }
12718 }
12719 azalea_registry::EntityKind::ExperienceOrb => {
12720 for d in items {
12721 ExperienceOrb::apply_metadata(entity, d)?;
12722 }
12723 }
12724 azalea_registry::EntityKind::EyeOfEnder => {
12725 for d in items {
12726 EyeOfEnder::apply_metadata(entity, d)?;
12727 }
12728 }
12729 azalea_registry::EntityKind::FallingBlock => {
12730 for d in items {
12731 FallingBlock::apply_metadata(entity, d)?;
12732 }
12733 }
12734 azalea_registry::EntityKind::Fireball => {
12735 for d in items {
12736 Fireball::apply_metadata(entity, d)?;
12737 }
12738 }
12739 azalea_registry::EntityKind::FireworkRocket => {
12740 for d in items {
12741 FireworkRocket::apply_metadata(entity, d)?;
12742 }
12743 }
12744 azalea_registry::EntityKind::FishingBobber => {
12745 for d in items {
12746 FishingBobber::apply_metadata(entity, d)?;
12747 }
12748 }
12749 azalea_registry::EntityKind::Fox => {
12750 for d in items {
12751 Fox::apply_metadata(entity, d)?;
12752 }
12753 }
12754 azalea_registry::EntityKind::Frog => {
12755 for d in items {
12756 Frog::apply_metadata(entity, d)?;
12757 }
12758 }
12759 azalea_registry::EntityKind::FurnaceMinecart => {
12760 for d in items {
12761 FurnaceMinecart::apply_metadata(entity, d)?;
12762 }
12763 }
12764 azalea_registry::EntityKind::Ghast => {
12765 for d in items {
12766 Ghast::apply_metadata(entity, d)?;
12767 }
12768 }
12769 azalea_registry::EntityKind::Giant => {
12770 for d in items {
12771 Giant::apply_metadata(entity, d)?;
12772 }
12773 }
12774 azalea_registry::EntityKind::GlowItemFrame => {
12775 for d in items {
12776 GlowItemFrame::apply_metadata(entity, d)?;
12777 }
12778 }
12779 azalea_registry::EntityKind::GlowSquid => {
12780 for d in items {
12781 GlowSquid::apply_metadata(entity, d)?;
12782 }
12783 }
12784 azalea_registry::EntityKind::Goat => {
12785 for d in items {
12786 Goat::apply_metadata(entity, d)?;
12787 }
12788 }
12789 azalea_registry::EntityKind::Guardian => {
12790 for d in items {
12791 Guardian::apply_metadata(entity, d)?;
12792 }
12793 }
12794 azalea_registry::EntityKind::HappyGhast => {
12795 for d in items {
12796 HappyGhast::apply_metadata(entity, d)?;
12797 }
12798 }
12799 azalea_registry::EntityKind::Hoglin => {
12800 for d in items {
12801 Hoglin::apply_metadata(entity, d)?;
12802 }
12803 }
12804 azalea_registry::EntityKind::HopperMinecart => {
12805 for d in items {
12806 HopperMinecart::apply_metadata(entity, d)?;
12807 }
12808 }
12809 azalea_registry::EntityKind::Horse => {
12810 for d in items {
12811 Horse::apply_metadata(entity, d)?;
12812 }
12813 }
12814 azalea_registry::EntityKind::Husk => {
12815 for d in items {
12816 Husk::apply_metadata(entity, d)?;
12817 }
12818 }
12819 azalea_registry::EntityKind::Illusioner => {
12820 for d in items {
12821 Illusioner::apply_metadata(entity, d)?;
12822 }
12823 }
12824 azalea_registry::EntityKind::Interaction => {
12825 for d in items {
12826 Interaction::apply_metadata(entity, d)?;
12827 }
12828 }
12829 azalea_registry::EntityKind::IronGolem => {
12830 for d in items {
12831 IronGolem::apply_metadata(entity, d)?;
12832 }
12833 }
12834 azalea_registry::EntityKind::Item => {
12835 for d in items {
12836 Item::apply_metadata(entity, d)?;
12837 }
12838 }
12839 azalea_registry::EntityKind::ItemDisplay => {
12840 for d in items {
12841 ItemDisplay::apply_metadata(entity, d)?;
12842 }
12843 }
12844 azalea_registry::EntityKind::ItemFrame => {
12845 for d in items {
12846 ItemFrame::apply_metadata(entity, d)?;
12847 }
12848 }
12849 azalea_registry::EntityKind::JungleBoat => {
12850 for d in items {
12851 JungleBoat::apply_metadata(entity, d)?;
12852 }
12853 }
12854 azalea_registry::EntityKind::JungleChestBoat => {
12855 for d in items {
12856 JungleChestBoat::apply_metadata(entity, d)?;
12857 }
12858 }
12859 azalea_registry::EntityKind::LeashKnot => {
12860 for d in items {
12861 LeashKnot::apply_metadata(entity, d)?;
12862 }
12863 }
12864 azalea_registry::EntityKind::LightningBolt => {
12865 for d in items {
12866 LightningBolt::apply_metadata(entity, d)?;
12867 }
12868 }
12869 azalea_registry::EntityKind::LingeringPotion => {
12870 for d in items {
12871 LingeringPotion::apply_metadata(entity, d)?;
12872 }
12873 }
12874 azalea_registry::EntityKind::Llama => {
12875 for d in items {
12876 Llama::apply_metadata(entity, d)?;
12877 }
12878 }
12879 azalea_registry::EntityKind::LlamaSpit => {
12880 for d in items {
12881 LlamaSpit::apply_metadata(entity, d)?;
12882 }
12883 }
12884 azalea_registry::EntityKind::MagmaCube => {
12885 for d in items {
12886 MagmaCube::apply_metadata(entity, d)?;
12887 }
12888 }
12889 azalea_registry::EntityKind::MangroveBoat => {
12890 for d in items {
12891 MangroveBoat::apply_metadata(entity, d)?;
12892 }
12893 }
12894 azalea_registry::EntityKind::MangroveChestBoat => {
12895 for d in items {
12896 MangroveChestBoat::apply_metadata(entity, d)?;
12897 }
12898 }
12899 azalea_registry::EntityKind::Marker => {
12900 for d in items {
12901 Marker::apply_metadata(entity, d)?;
12902 }
12903 }
12904 azalea_registry::EntityKind::Minecart => {
12905 for d in items {
12906 Minecart::apply_metadata(entity, d)?;
12907 }
12908 }
12909 azalea_registry::EntityKind::Mooshroom => {
12910 for d in items {
12911 Mooshroom::apply_metadata(entity, d)?;
12912 }
12913 }
12914 azalea_registry::EntityKind::Mule => {
12915 for d in items {
12916 Mule::apply_metadata(entity, d)?;
12917 }
12918 }
12919 azalea_registry::EntityKind::OakBoat => {
12920 for d in items {
12921 OakBoat::apply_metadata(entity, d)?;
12922 }
12923 }
12924 azalea_registry::EntityKind::OakChestBoat => {
12925 for d in items {
12926 OakChestBoat::apply_metadata(entity, d)?;
12927 }
12928 }
12929 azalea_registry::EntityKind::Ocelot => {
12930 for d in items {
12931 Ocelot::apply_metadata(entity, d)?;
12932 }
12933 }
12934 azalea_registry::EntityKind::OminousItemSpawner => {
12935 for d in items {
12936 OminousItemSpawner::apply_metadata(entity, d)?;
12937 }
12938 }
12939 azalea_registry::EntityKind::Painting => {
12940 for d in items {
12941 Painting::apply_metadata(entity, d)?;
12942 }
12943 }
12944 azalea_registry::EntityKind::PaleOakBoat => {
12945 for d in items {
12946 PaleOakBoat::apply_metadata(entity, d)?;
12947 }
12948 }
12949 azalea_registry::EntityKind::PaleOakChestBoat => {
12950 for d in items {
12951 PaleOakChestBoat::apply_metadata(entity, d)?;
12952 }
12953 }
12954 azalea_registry::EntityKind::Panda => {
12955 for d in items {
12956 Panda::apply_metadata(entity, d)?;
12957 }
12958 }
12959 azalea_registry::EntityKind::Parrot => {
12960 for d in items {
12961 Parrot::apply_metadata(entity, d)?;
12962 }
12963 }
12964 azalea_registry::EntityKind::Phantom => {
12965 for d in items {
12966 Phantom::apply_metadata(entity, d)?;
12967 }
12968 }
12969 azalea_registry::EntityKind::Pig => {
12970 for d in items {
12971 Pig::apply_metadata(entity, d)?;
12972 }
12973 }
12974 azalea_registry::EntityKind::Piglin => {
12975 for d in items {
12976 Piglin::apply_metadata(entity, d)?;
12977 }
12978 }
12979 azalea_registry::EntityKind::PiglinBrute => {
12980 for d in items {
12981 PiglinBrute::apply_metadata(entity, d)?;
12982 }
12983 }
12984 azalea_registry::EntityKind::Pillager => {
12985 for d in items {
12986 Pillager::apply_metadata(entity, d)?;
12987 }
12988 }
12989 azalea_registry::EntityKind::Player => {
12990 for d in items {
12991 Player::apply_metadata(entity, d)?;
12992 }
12993 }
12994 azalea_registry::EntityKind::PolarBear => {
12995 for d in items {
12996 PolarBear::apply_metadata(entity, d)?;
12997 }
12998 }
12999 azalea_registry::EntityKind::Pufferfish => {
13000 for d in items {
13001 Pufferfish::apply_metadata(entity, d)?;
13002 }
13003 }
13004 azalea_registry::EntityKind::Rabbit => {
13005 for d in items {
13006 Rabbit::apply_metadata(entity, d)?;
13007 }
13008 }
13009 azalea_registry::EntityKind::Ravager => {
13010 for d in items {
13011 Ravager::apply_metadata(entity, d)?;
13012 }
13013 }
13014 azalea_registry::EntityKind::Salmon => {
13015 for d in items {
13016 Salmon::apply_metadata(entity, d)?;
13017 }
13018 }
13019 azalea_registry::EntityKind::Sheep => {
13020 for d in items {
13021 Sheep::apply_metadata(entity, d)?;
13022 }
13023 }
13024 azalea_registry::EntityKind::Shulker => {
13025 for d in items {
13026 Shulker::apply_metadata(entity, d)?;
13027 }
13028 }
13029 azalea_registry::EntityKind::ShulkerBullet => {
13030 for d in items {
13031 ShulkerBullet::apply_metadata(entity, d)?;
13032 }
13033 }
13034 azalea_registry::EntityKind::Silverfish => {
13035 for d in items {
13036 Silverfish::apply_metadata(entity, d)?;
13037 }
13038 }
13039 azalea_registry::EntityKind::Skeleton => {
13040 for d in items {
13041 Skeleton::apply_metadata(entity, d)?;
13042 }
13043 }
13044 azalea_registry::EntityKind::SkeletonHorse => {
13045 for d in items {
13046 SkeletonHorse::apply_metadata(entity, d)?;
13047 }
13048 }
13049 azalea_registry::EntityKind::Slime => {
13050 for d in items {
13051 Slime::apply_metadata(entity, d)?;
13052 }
13053 }
13054 azalea_registry::EntityKind::SmallFireball => {
13055 for d in items {
13056 SmallFireball::apply_metadata(entity, d)?;
13057 }
13058 }
13059 azalea_registry::EntityKind::Sniffer => {
13060 for d in items {
13061 Sniffer::apply_metadata(entity, d)?;
13062 }
13063 }
13064 azalea_registry::EntityKind::SnowGolem => {
13065 for d in items {
13066 SnowGolem::apply_metadata(entity, d)?;
13067 }
13068 }
13069 azalea_registry::EntityKind::Snowball => {
13070 for d in items {
13071 Snowball::apply_metadata(entity, d)?;
13072 }
13073 }
13074 azalea_registry::EntityKind::SpawnerMinecart => {
13075 for d in items {
13076 SpawnerMinecart::apply_metadata(entity, d)?;
13077 }
13078 }
13079 azalea_registry::EntityKind::SpectralArrow => {
13080 for d in items {
13081 SpectralArrow::apply_metadata(entity, d)?;
13082 }
13083 }
13084 azalea_registry::EntityKind::Spider => {
13085 for d in items {
13086 Spider::apply_metadata(entity, d)?;
13087 }
13088 }
13089 azalea_registry::EntityKind::SplashPotion => {
13090 for d in items {
13091 SplashPotion::apply_metadata(entity, d)?;
13092 }
13093 }
13094 azalea_registry::EntityKind::SpruceBoat => {
13095 for d in items {
13096 SpruceBoat::apply_metadata(entity, d)?;
13097 }
13098 }
13099 azalea_registry::EntityKind::SpruceChestBoat => {
13100 for d in items {
13101 SpruceChestBoat::apply_metadata(entity, d)?;
13102 }
13103 }
13104 azalea_registry::EntityKind::Squid => {
13105 for d in items {
13106 Squid::apply_metadata(entity, d)?;
13107 }
13108 }
13109 azalea_registry::EntityKind::Stray => {
13110 for d in items {
13111 Stray::apply_metadata(entity, d)?;
13112 }
13113 }
13114 azalea_registry::EntityKind::Strider => {
13115 for d in items {
13116 Strider::apply_metadata(entity, d)?;
13117 }
13118 }
13119 azalea_registry::EntityKind::Tadpole => {
13120 for d in items {
13121 Tadpole::apply_metadata(entity, d)?;
13122 }
13123 }
13124 azalea_registry::EntityKind::TextDisplay => {
13125 for d in items {
13126 TextDisplay::apply_metadata(entity, d)?;
13127 }
13128 }
13129 azalea_registry::EntityKind::Tnt => {
13130 for d in items {
13131 Tnt::apply_metadata(entity, d)?;
13132 }
13133 }
13134 azalea_registry::EntityKind::TntMinecart => {
13135 for d in items {
13136 TntMinecart::apply_metadata(entity, d)?;
13137 }
13138 }
13139 azalea_registry::EntityKind::TraderLlama => {
13140 for d in items {
13141 TraderLlama::apply_metadata(entity, d)?;
13142 }
13143 }
13144 azalea_registry::EntityKind::Trident => {
13145 for d in items {
13146 Trident::apply_metadata(entity, d)?;
13147 }
13148 }
13149 azalea_registry::EntityKind::TropicalFish => {
13150 for d in items {
13151 TropicalFish::apply_metadata(entity, d)?;
13152 }
13153 }
13154 azalea_registry::EntityKind::Turtle => {
13155 for d in items {
13156 Turtle::apply_metadata(entity, d)?;
13157 }
13158 }
13159 azalea_registry::EntityKind::Vex => {
13160 for d in items {
13161 Vex::apply_metadata(entity, d)?;
13162 }
13163 }
13164 azalea_registry::EntityKind::Villager => {
13165 for d in items {
13166 Villager::apply_metadata(entity, d)?;
13167 }
13168 }
13169 azalea_registry::EntityKind::Vindicator => {
13170 for d in items {
13171 Vindicator::apply_metadata(entity, d)?;
13172 }
13173 }
13174 azalea_registry::EntityKind::WanderingTrader => {
13175 for d in items {
13176 WanderingTrader::apply_metadata(entity, d)?;
13177 }
13178 }
13179 azalea_registry::EntityKind::Warden => {
13180 for d in items {
13181 Warden::apply_metadata(entity, d)?;
13182 }
13183 }
13184 azalea_registry::EntityKind::WindCharge => {
13185 for d in items {
13186 WindCharge::apply_metadata(entity, d)?;
13187 }
13188 }
13189 azalea_registry::EntityKind::Witch => {
13190 for d in items {
13191 Witch::apply_metadata(entity, d)?;
13192 }
13193 }
13194 azalea_registry::EntityKind::Wither => {
13195 for d in items {
13196 Wither::apply_metadata(entity, d)?;
13197 }
13198 }
13199 azalea_registry::EntityKind::WitherSkeleton => {
13200 for d in items {
13201 WitherSkeleton::apply_metadata(entity, d)?;
13202 }
13203 }
13204 azalea_registry::EntityKind::WitherSkull => {
13205 for d in items {
13206 WitherSkull::apply_metadata(entity, d)?;
13207 }
13208 }
13209 azalea_registry::EntityKind::Wolf => {
13210 for d in items {
13211 Wolf::apply_metadata(entity, d)?;
13212 }
13213 }
13214 azalea_registry::EntityKind::Zoglin => {
13215 for d in items {
13216 Zoglin::apply_metadata(entity, d)?;
13217 }
13218 }
13219 azalea_registry::EntityKind::Zombie => {
13220 for d in items {
13221 Zombie::apply_metadata(entity, d)?;
13222 }
13223 }
13224 azalea_registry::EntityKind::ZombieHorse => {
13225 for d in items {
13226 ZombieHorse::apply_metadata(entity, d)?;
13227 }
13228 }
13229 azalea_registry::EntityKind::ZombieVillager => {
13230 for d in items {
13231 ZombieVillager::apply_metadata(entity, d)?;
13232 }
13233 }
13234 azalea_registry::EntityKind::ZombifiedPiglin => {
13235 for d in items {
13236 ZombifiedPiglin::apply_metadata(entity, d)?;
13237 }
13238 }
13239 }
13240 Ok(())
13241}
13242
13243pub fn apply_default_metadata(
13244 entity: &mut bevy_ecs::system::EntityCommands,
13245 kind: azalea_registry::EntityKind,
13246) {
13247 match kind {
13248 azalea_registry::EntityKind::AcaciaBoat => {
13249 entity.insert(AcaciaBoatMetadataBundle::default());
13250 }
13251 azalea_registry::EntityKind::AcaciaChestBoat => {
13252 entity.insert(AcaciaChestBoatMetadataBundle::default());
13253 }
13254 azalea_registry::EntityKind::Allay => {
13255 entity.insert(AllayMetadataBundle::default());
13256 }
13257 azalea_registry::EntityKind::AreaEffectCloud => {
13258 entity.insert(AreaEffectCloudMetadataBundle::default());
13259 }
13260 azalea_registry::EntityKind::Armadillo => {
13261 entity.insert(ArmadilloMetadataBundle::default());
13262 }
13263 azalea_registry::EntityKind::ArmorStand => {
13264 entity.insert(ArmorStandMetadataBundle::default());
13265 }
13266 azalea_registry::EntityKind::Arrow => {
13267 entity.insert(ArrowMetadataBundle::default());
13268 }
13269 azalea_registry::EntityKind::Axolotl => {
13270 entity.insert(AxolotlMetadataBundle::default());
13271 }
13272 azalea_registry::EntityKind::BambooChestRaft => {
13273 entity.insert(BambooChestRaftMetadataBundle::default());
13274 }
13275 azalea_registry::EntityKind::BambooRaft => {
13276 entity.insert(BambooRaftMetadataBundle::default());
13277 }
13278 azalea_registry::EntityKind::Bat => {
13279 entity.insert(BatMetadataBundle::default());
13280 }
13281 azalea_registry::EntityKind::Bee => {
13282 entity.insert(BeeMetadataBundle::default());
13283 }
13284 azalea_registry::EntityKind::BirchBoat => {
13285 entity.insert(BirchBoatMetadataBundle::default());
13286 }
13287 azalea_registry::EntityKind::BirchChestBoat => {
13288 entity.insert(BirchChestBoatMetadataBundle::default());
13289 }
13290 azalea_registry::EntityKind::Blaze => {
13291 entity.insert(BlazeMetadataBundle::default());
13292 }
13293 azalea_registry::EntityKind::BlockDisplay => {
13294 entity.insert(BlockDisplayMetadataBundle::default());
13295 }
13296 azalea_registry::EntityKind::Bogged => {
13297 entity.insert(BoggedMetadataBundle::default());
13298 }
13299 azalea_registry::EntityKind::Breeze => {
13300 entity.insert(BreezeMetadataBundle::default());
13301 }
13302 azalea_registry::EntityKind::BreezeWindCharge => {
13303 entity.insert(BreezeWindChargeMetadataBundle::default());
13304 }
13305 azalea_registry::EntityKind::Camel => {
13306 entity.insert(CamelMetadataBundle::default());
13307 }
13308 azalea_registry::EntityKind::Cat => {
13309 entity.insert(CatMetadataBundle::default());
13310 }
13311 azalea_registry::EntityKind::CaveSpider => {
13312 entity.insert(CaveSpiderMetadataBundle::default());
13313 }
13314 azalea_registry::EntityKind::CherryBoat => {
13315 entity.insert(CherryBoatMetadataBundle::default());
13316 }
13317 azalea_registry::EntityKind::CherryChestBoat => {
13318 entity.insert(CherryChestBoatMetadataBundle::default());
13319 }
13320 azalea_registry::EntityKind::ChestMinecart => {
13321 entity.insert(ChestMinecartMetadataBundle::default());
13322 }
13323 azalea_registry::EntityKind::Chicken => {
13324 entity.insert(ChickenMetadataBundle::default());
13325 }
13326 azalea_registry::EntityKind::Cod => {
13327 entity.insert(CodMetadataBundle::default());
13328 }
13329 azalea_registry::EntityKind::CommandBlockMinecart => {
13330 entity.insert(CommandBlockMinecartMetadataBundle::default());
13331 }
13332 azalea_registry::EntityKind::Cow => {
13333 entity.insert(CowMetadataBundle::default());
13334 }
13335 azalea_registry::EntityKind::Creaking => {
13336 entity.insert(CreakingMetadataBundle::default());
13337 }
13338 azalea_registry::EntityKind::Creeper => {
13339 entity.insert(CreeperMetadataBundle::default());
13340 }
13341 azalea_registry::EntityKind::DarkOakBoat => {
13342 entity.insert(DarkOakBoatMetadataBundle::default());
13343 }
13344 azalea_registry::EntityKind::DarkOakChestBoat => {
13345 entity.insert(DarkOakChestBoatMetadataBundle::default());
13346 }
13347 azalea_registry::EntityKind::Dolphin => {
13348 entity.insert(DolphinMetadataBundle::default());
13349 }
13350 azalea_registry::EntityKind::Donkey => {
13351 entity.insert(DonkeyMetadataBundle::default());
13352 }
13353 azalea_registry::EntityKind::DragonFireball => {
13354 entity.insert(DragonFireballMetadataBundle::default());
13355 }
13356 azalea_registry::EntityKind::Drowned => {
13357 entity.insert(DrownedMetadataBundle::default());
13358 }
13359 azalea_registry::EntityKind::Egg => {
13360 entity.insert(EggMetadataBundle::default());
13361 }
13362 azalea_registry::EntityKind::ElderGuardian => {
13363 entity.insert(ElderGuardianMetadataBundle::default());
13364 }
13365 azalea_registry::EntityKind::EndCrystal => {
13366 entity.insert(EndCrystalMetadataBundle::default());
13367 }
13368 azalea_registry::EntityKind::EnderDragon => {
13369 entity.insert(EnderDragonMetadataBundle::default());
13370 }
13371 azalea_registry::EntityKind::EnderPearl => {
13372 entity.insert(EnderPearlMetadataBundle::default());
13373 }
13374 azalea_registry::EntityKind::Enderman => {
13375 entity.insert(EndermanMetadataBundle::default());
13376 }
13377 azalea_registry::EntityKind::Endermite => {
13378 entity.insert(EndermiteMetadataBundle::default());
13379 }
13380 azalea_registry::EntityKind::Evoker => {
13381 entity.insert(EvokerMetadataBundle::default());
13382 }
13383 azalea_registry::EntityKind::EvokerFangs => {
13384 entity.insert(EvokerFangsMetadataBundle::default());
13385 }
13386 azalea_registry::EntityKind::ExperienceBottle => {
13387 entity.insert(ExperienceBottleMetadataBundle::default());
13388 }
13389 azalea_registry::EntityKind::ExperienceOrb => {
13390 entity.insert(ExperienceOrbMetadataBundle::default());
13391 }
13392 azalea_registry::EntityKind::EyeOfEnder => {
13393 entity.insert(EyeOfEnderMetadataBundle::default());
13394 }
13395 azalea_registry::EntityKind::FallingBlock => {
13396 entity.insert(FallingBlockMetadataBundle::default());
13397 }
13398 azalea_registry::EntityKind::Fireball => {
13399 entity.insert(FireballMetadataBundle::default());
13400 }
13401 azalea_registry::EntityKind::FireworkRocket => {
13402 entity.insert(FireworkRocketMetadataBundle::default());
13403 }
13404 azalea_registry::EntityKind::FishingBobber => {
13405 entity.insert(FishingBobberMetadataBundle::default());
13406 }
13407 azalea_registry::EntityKind::Fox => {
13408 entity.insert(FoxMetadataBundle::default());
13409 }
13410 azalea_registry::EntityKind::Frog => {
13411 entity.insert(FrogMetadataBundle::default());
13412 }
13413 azalea_registry::EntityKind::FurnaceMinecart => {
13414 entity.insert(FurnaceMinecartMetadataBundle::default());
13415 }
13416 azalea_registry::EntityKind::Ghast => {
13417 entity.insert(GhastMetadataBundle::default());
13418 }
13419 azalea_registry::EntityKind::Giant => {
13420 entity.insert(GiantMetadataBundle::default());
13421 }
13422 azalea_registry::EntityKind::GlowItemFrame => {
13423 entity.insert(GlowItemFrameMetadataBundle::default());
13424 }
13425 azalea_registry::EntityKind::GlowSquid => {
13426 entity.insert(GlowSquidMetadataBundle::default());
13427 }
13428 azalea_registry::EntityKind::Goat => {
13429 entity.insert(GoatMetadataBundle::default());
13430 }
13431 azalea_registry::EntityKind::Guardian => {
13432 entity.insert(GuardianMetadataBundle::default());
13433 }
13434 azalea_registry::EntityKind::HappyGhast => {
13435 entity.insert(HappyGhastMetadataBundle::default());
13436 }
13437 azalea_registry::EntityKind::Hoglin => {
13438 entity.insert(HoglinMetadataBundle::default());
13439 }
13440 azalea_registry::EntityKind::HopperMinecart => {
13441 entity.insert(HopperMinecartMetadataBundle::default());
13442 }
13443 azalea_registry::EntityKind::Horse => {
13444 entity.insert(HorseMetadataBundle::default());
13445 }
13446 azalea_registry::EntityKind::Husk => {
13447 entity.insert(HuskMetadataBundle::default());
13448 }
13449 azalea_registry::EntityKind::Illusioner => {
13450 entity.insert(IllusionerMetadataBundle::default());
13451 }
13452 azalea_registry::EntityKind::Interaction => {
13453 entity.insert(InteractionMetadataBundle::default());
13454 }
13455 azalea_registry::EntityKind::IronGolem => {
13456 entity.insert(IronGolemMetadataBundle::default());
13457 }
13458 azalea_registry::EntityKind::Item => {
13459 entity.insert(ItemMetadataBundle::default());
13460 }
13461 azalea_registry::EntityKind::ItemDisplay => {
13462 entity.insert(ItemDisplayMetadataBundle::default());
13463 }
13464 azalea_registry::EntityKind::ItemFrame => {
13465 entity.insert(ItemFrameMetadataBundle::default());
13466 }
13467 azalea_registry::EntityKind::JungleBoat => {
13468 entity.insert(JungleBoatMetadataBundle::default());
13469 }
13470 azalea_registry::EntityKind::JungleChestBoat => {
13471 entity.insert(JungleChestBoatMetadataBundle::default());
13472 }
13473 azalea_registry::EntityKind::LeashKnot => {
13474 entity.insert(LeashKnotMetadataBundle::default());
13475 }
13476 azalea_registry::EntityKind::LightningBolt => {
13477 entity.insert(LightningBoltMetadataBundle::default());
13478 }
13479 azalea_registry::EntityKind::LingeringPotion => {
13480 entity.insert(LingeringPotionMetadataBundle::default());
13481 }
13482 azalea_registry::EntityKind::Llama => {
13483 entity.insert(LlamaMetadataBundle::default());
13484 }
13485 azalea_registry::EntityKind::LlamaSpit => {
13486 entity.insert(LlamaSpitMetadataBundle::default());
13487 }
13488 azalea_registry::EntityKind::MagmaCube => {
13489 entity.insert(MagmaCubeMetadataBundle::default());
13490 }
13491 azalea_registry::EntityKind::MangroveBoat => {
13492 entity.insert(MangroveBoatMetadataBundle::default());
13493 }
13494 azalea_registry::EntityKind::MangroveChestBoat => {
13495 entity.insert(MangroveChestBoatMetadataBundle::default());
13496 }
13497 azalea_registry::EntityKind::Marker => {
13498 entity.insert(MarkerMetadataBundle::default());
13499 }
13500 azalea_registry::EntityKind::Minecart => {
13501 entity.insert(MinecartMetadataBundle::default());
13502 }
13503 azalea_registry::EntityKind::Mooshroom => {
13504 entity.insert(MooshroomMetadataBundle::default());
13505 }
13506 azalea_registry::EntityKind::Mule => {
13507 entity.insert(MuleMetadataBundle::default());
13508 }
13509 azalea_registry::EntityKind::OakBoat => {
13510 entity.insert(OakBoatMetadataBundle::default());
13511 }
13512 azalea_registry::EntityKind::OakChestBoat => {
13513 entity.insert(OakChestBoatMetadataBundle::default());
13514 }
13515 azalea_registry::EntityKind::Ocelot => {
13516 entity.insert(OcelotMetadataBundle::default());
13517 }
13518 azalea_registry::EntityKind::OminousItemSpawner => {
13519 entity.insert(OminousItemSpawnerMetadataBundle::default());
13520 }
13521 azalea_registry::EntityKind::Painting => {
13522 entity.insert(PaintingMetadataBundle::default());
13523 }
13524 azalea_registry::EntityKind::PaleOakBoat => {
13525 entity.insert(PaleOakBoatMetadataBundle::default());
13526 }
13527 azalea_registry::EntityKind::PaleOakChestBoat => {
13528 entity.insert(PaleOakChestBoatMetadataBundle::default());
13529 }
13530 azalea_registry::EntityKind::Panda => {
13531 entity.insert(PandaMetadataBundle::default());
13532 }
13533 azalea_registry::EntityKind::Parrot => {
13534 entity.insert(ParrotMetadataBundle::default());
13535 }
13536 azalea_registry::EntityKind::Phantom => {
13537 entity.insert(PhantomMetadataBundle::default());
13538 }
13539 azalea_registry::EntityKind::Pig => {
13540 entity.insert(PigMetadataBundle::default());
13541 }
13542 azalea_registry::EntityKind::Piglin => {
13543 entity.insert(PiglinMetadataBundle::default());
13544 }
13545 azalea_registry::EntityKind::PiglinBrute => {
13546 entity.insert(PiglinBruteMetadataBundle::default());
13547 }
13548 azalea_registry::EntityKind::Pillager => {
13549 entity.insert(PillagerMetadataBundle::default());
13550 }
13551 azalea_registry::EntityKind::Player => {
13552 entity.insert(PlayerMetadataBundle::default());
13553 }
13554 azalea_registry::EntityKind::PolarBear => {
13555 entity.insert(PolarBearMetadataBundle::default());
13556 }
13557 azalea_registry::EntityKind::Pufferfish => {
13558 entity.insert(PufferfishMetadataBundle::default());
13559 }
13560 azalea_registry::EntityKind::Rabbit => {
13561 entity.insert(RabbitMetadataBundle::default());
13562 }
13563 azalea_registry::EntityKind::Ravager => {
13564 entity.insert(RavagerMetadataBundle::default());
13565 }
13566 azalea_registry::EntityKind::Salmon => {
13567 entity.insert(SalmonMetadataBundle::default());
13568 }
13569 azalea_registry::EntityKind::Sheep => {
13570 entity.insert(SheepMetadataBundle::default());
13571 }
13572 azalea_registry::EntityKind::Shulker => {
13573 entity.insert(ShulkerMetadataBundle::default());
13574 }
13575 azalea_registry::EntityKind::ShulkerBullet => {
13576 entity.insert(ShulkerBulletMetadataBundle::default());
13577 }
13578 azalea_registry::EntityKind::Silverfish => {
13579 entity.insert(SilverfishMetadataBundle::default());
13580 }
13581 azalea_registry::EntityKind::Skeleton => {
13582 entity.insert(SkeletonMetadataBundle::default());
13583 }
13584 azalea_registry::EntityKind::SkeletonHorse => {
13585 entity.insert(SkeletonHorseMetadataBundle::default());
13586 }
13587 azalea_registry::EntityKind::Slime => {
13588 entity.insert(SlimeMetadataBundle::default());
13589 }
13590 azalea_registry::EntityKind::SmallFireball => {
13591 entity.insert(SmallFireballMetadataBundle::default());
13592 }
13593 azalea_registry::EntityKind::Sniffer => {
13594 entity.insert(SnifferMetadataBundle::default());
13595 }
13596 azalea_registry::EntityKind::SnowGolem => {
13597 entity.insert(SnowGolemMetadataBundle::default());
13598 }
13599 azalea_registry::EntityKind::Snowball => {
13600 entity.insert(SnowballMetadataBundle::default());
13601 }
13602 azalea_registry::EntityKind::SpawnerMinecart => {
13603 entity.insert(SpawnerMinecartMetadataBundle::default());
13604 }
13605 azalea_registry::EntityKind::SpectralArrow => {
13606 entity.insert(SpectralArrowMetadataBundle::default());
13607 }
13608 azalea_registry::EntityKind::Spider => {
13609 entity.insert(SpiderMetadataBundle::default());
13610 }
13611 azalea_registry::EntityKind::SplashPotion => {
13612 entity.insert(SplashPotionMetadataBundle::default());
13613 }
13614 azalea_registry::EntityKind::SpruceBoat => {
13615 entity.insert(SpruceBoatMetadataBundle::default());
13616 }
13617 azalea_registry::EntityKind::SpruceChestBoat => {
13618 entity.insert(SpruceChestBoatMetadataBundle::default());
13619 }
13620 azalea_registry::EntityKind::Squid => {
13621 entity.insert(SquidMetadataBundle::default());
13622 }
13623 azalea_registry::EntityKind::Stray => {
13624 entity.insert(StrayMetadataBundle::default());
13625 }
13626 azalea_registry::EntityKind::Strider => {
13627 entity.insert(StriderMetadataBundle::default());
13628 }
13629 azalea_registry::EntityKind::Tadpole => {
13630 entity.insert(TadpoleMetadataBundle::default());
13631 }
13632 azalea_registry::EntityKind::TextDisplay => {
13633 entity.insert(TextDisplayMetadataBundle::default());
13634 }
13635 azalea_registry::EntityKind::Tnt => {
13636 entity.insert(TntMetadataBundle::default());
13637 }
13638 azalea_registry::EntityKind::TntMinecart => {
13639 entity.insert(TntMinecartMetadataBundle::default());
13640 }
13641 azalea_registry::EntityKind::TraderLlama => {
13642 entity.insert(TraderLlamaMetadataBundle::default());
13643 }
13644 azalea_registry::EntityKind::Trident => {
13645 entity.insert(TridentMetadataBundle::default());
13646 }
13647 azalea_registry::EntityKind::TropicalFish => {
13648 entity.insert(TropicalFishMetadataBundle::default());
13649 }
13650 azalea_registry::EntityKind::Turtle => {
13651 entity.insert(TurtleMetadataBundle::default());
13652 }
13653 azalea_registry::EntityKind::Vex => {
13654 entity.insert(VexMetadataBundle::default());
13655 }
13656 azalea_registry::EntityKind::Villager => {
13657 entity.insert(VillagerMetadataBundle::default());
13658 }
13659 azalea_registry::EntityKind::Vindicator => {
13660 entity.insert(VindicatorMetadataBundle::default());
13661 }
13662 azalea_registry::EntityKind::WanderingTrader => {
13663 entity.insert(WanderingTraderMetadataBundle::default());
13664 }
13665 azalea_registry::EntityKind::Warden => {
13666 entity.insert(WardenMetadataBundle::default());
13667 }
13668 azalea_registry::EntityKind::WindCharge => {
13669 entity.insert(WindChargeMetadataBundle::default());
13670 }
13671 azalea_registry::EntityKind::Witch => {
13672 entity.insert(WitchMetadataBundle::default());
13673 }
13674 azalea_registry::EntityKind::Wither => {
13675 entity.insert(WitherMetadataBundle::default());
13676 }
13677 azalea_registry::EntityKind::WitherSkeleton => {
13678 entity.insert(WitherSkeletonMetadataBundle::default());
13679 }
13680 azalea_registry::EntityKind::WitherSkull => {
13681 entity.insert(WitherSkullMetadataBundle::default());
13682 }
13683 azalea_registry::EntityKind::Wolf => {
13684 entity.insert(WolfMetadataBundle::default());
13685 }
13686 azalea_registry::EntityKind::Zoglin => {
13687 entity.insert(ZoglinMetadataBundle::default());
13688 }
13689 azalea_registry::EntityKind::Zombie => {
13690 entity.insert(ZombieMetadataBundle::default());
13691 }
13692 azalea_registry::EntityKind::ZombieHorse => {
13693 entity.insert(ZombieHorseMetadataBundle::default());
13694 }
13695 azalea_registry::EntityKind::ZombieVillager => {
13696 entity.insert(ZombieVillagerMetadataBundle::default());
13697 }
13698 azalea_registry::EntityKind::ZombifiedPiglin => {
13699 entity.insert(ZombifiedPiglinMetadataBundle::default());
13700 }
13701 }
13702}