azalea_entity/
metadata.rs

1#![allow(clippy::single_match)]
2
3// This file is @generated from codegen/lib/code/entity.py.
4// Don't change it manually!
5
6use 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}