1#![allow(clippy::single_match)]
2
3use 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}