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