1use bytes::Bytes;
4use uuid::Uuid;
5
6#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
8#[non_exhaustive]
9pub enum EntityType {
10 Player,
12 LegacyMob(u8),
15 LegacyObject(u8),
18 ExperienceOrb,
20 Painting,
22 Registry(u16),
25}
26
27#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
29#[non_exhaustive]
30pub enum EntityClass {
31 Player,
33 Item,
35 ExperienceOrb,
37 Mob,
39 Object,
41 Painting,
43}
44
45#[derive(Clone, Debug, PartialEq, Eq)]
50pub struct Item {
51 pub id: i32,
53 pub count: i8,
55 pub damage: i16,
57 pub nbt: Option<Bytes>,
59}
60
61#[derive(Clone, Copy, Debug, PartialEq, Eq)]
63pub struct Effect {
64 pub id: u8,
66 pub amplifier: i8,
68 pub duration: i32,
70 pub flags: u8,
73}
74
75#[derive(Clone, Debug, PartialEq)]
78#[non_exhaustive]
79pub enum MetaValue {
80 Byte(i8),
82 Short(i16),
84 Int(i32),
86 VarInt(i32),
88 Float(f32),
90 String(Box<str>),
92 Chat(Box<str>),
94 OptChat(Option<Box<str>>),
96 Item(Option<Item>),
98 Bool(bool),
100 Rotation([f32; 3]),
102 BlockPos([i32; 3]),
104 OptBlockPos(Option<[i32; 3]>),
106 Direction(i32),
108 OptUuid(Option<Uuid>),
110 BlockState(i32),
112 Nbt(Bytes),
114 Particle(i32),
116 VillagerData([i32; 3]),
118 OptVarInt(i32),
120 Pose(i32),
122 Long(i64),
124 Component(Bytes),
126 OptComponent(Option<Bytes>),
128 #[cfg(any(feature = "v26_1", feature = "v26_2"))]
130 Stack(Option<ghast_protocol::types::slot::v775::ItemStack>),
131 Enum(u8, i32),
135 Vector3([f32; 3]),
137 Quaternion([f32; 4]),
139 Raw(u8, Bytes),
143}
144
145#[derive(Clone, Debug, Default, PartialEq)]
150pub struct Metadata {
151 entries: Box<[(u8, MetaValue)]>,
152}
153
154impl Metadata {
155 #[must_use]
157 pub fn get(&self, index: u8) -> Option<&MetaValue> {
158 self.entries
159 .iter()
160 .find(|(i, _)| *i == index)
161 .map(|(_, v)| v)
162 }
163
164 pub fn set(&mut self, index: u8, value: MetaValue) {
166 match self.entries.iter_mut().find(|(i, _)| *i == index) {
167 Some(slot) => slot.1 = value,
168 None => self.push_new(index, value),
169 }
170 }
171
172 #[cold]
174 #[inline(never)]
175 fn push_new(&mut self, index: u8, value: MetaValue) {
176 let mut v = Vec::with_capacity(self.entries.len() + 1);
177 v.extend(std::mem::take(&mut self.entries));
178 v.push((index, value));
179 self.entries = v.into_boxed_slice();
180 }
181
182 #[inline]
185 pub(crate) fn set_from(&mut self, src: &mut Vec<(u8, MetaValue)>, keep: impl Fn(u8) -> bool) {
186 let mut it = src.drain(..);
187 while let Some((i, v)) = it.next() {
189 if !keep(i) {
190 continue;
191 }
192 match self.entries.iter_mut().find(|(k, _)| *k == i) {
193 Some(slot) => slot.1 = v,
194 None => return self.grow_from((i, v), it, keep),
195 }
196 }
197 }
198
199 #[cold]
201 #[inline(never)]
202 fn grow_from(
203 &mut self,
204 first: (u8, MetaValue),
205 rest: std::vec::Drain<'_, (u8, MetaValue)>,
206 keep: impl Fn(u8) -> bool,
207 ) {
208 let tail = rest.as_slice();
209 let mut new = 1;
210 for (j, (i, _)) in tail.iter().enumerate() {
211 if keep(*i)
212 && *i != first.0
213 && !self.entries.iter().any(|(k, _)| k == i)
214 && !tail[..j].iter().any(|(k, _)| k == i)
215 {
216 new += 1;
217 }
218 }
219 let mut out = Vec::with_capacity(self.entries.len() + new);
220 out.extend(std::mem::take(&mut self.entries));
221 out.push(first);
222 for (i, v) in rest {
223 if !keep(i) {
224 continue;
225 }
226 match out.iter_mut().find(|(k, _)| *k == i) {
227 Some(slot) => slot.1 = v,
228 None => out.push((i, v)),
229 }
230 }
231 debug_assert_eq!(out.len(), out.capacity());
232 self.entries = out.into_boxed_slice();
233 }
234
235 pub fn iter(&self) -> impl Iterator<Item = (u8, &MetaValue)> {
237 self.entries.iter().map(|(i, v)| (*i, v))
238 }
239
240 #[must_use]
242 pub fn len(&self) -> usize {
243 self.entries.len()
244 }
245
246 #[must_use]
248 pub fn is_empty(&self) -> bool {
249 self.entries.is_empty()
250 }
251
252 #[must_use]
254 pub fn byte(&self, index: u8) -> Option<i8> {
255 match self.get(index)? {
256 MetaValue::Byte(b) => Some(*b),
257 _ => None,
258 }
259 }
260
261 #[must_use]
263 pub fn float(&self, index: u8) -> Option<f32> {
264 match self.get(index)? {
265 MetaValue::Float(f) => Some(*f),
266 _ => None,
267 }
268 }
269
270 #[must_use]
272 pub fn item(&self, index: u8) -> Option<Option<&Item>> {
273 match self.get(index)? {
274 MetaValue::Item(i) => Some(i.as_ref()),
275 _ => None,
276 }
277 }
278
279 pub(crate) fn clear(&mut self) {
280 self.entries = Box::default();
281 }
282
283 pub(crate) fn entries_mut(&mut self) -> impl Iterator<Item = &mut (u8, MetaValue)> {
284 self.entries.iter_mut()
285 }
286
287 #[cfg(test)]
289 pub(crate) fn heap_bytes(&self) -> usize {
290 std::mem::size_of_val::<[(u8, MetaValue)]>(&self.entries)
291 }
292}
293
294#[derive(Clone, Debug, Default, PartialEq)]
297pub(crate) struct Links {
298 pub(crate) profile_name: Option<Box<str>>,
301 pub(crate) leash_holder: Option<i32>,
302 pub(crate) passengers: Vec<i32>,
303 pub(crate) effects: Vec<Effect>,
304}
305
306#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
308pub(crate) enum Era {
309 #[default]
311 V1_8,
312 V1_12,
314 V1_16,
316 V26,
318 V26_2,
320}
321
322const ITEM_1_16: u16 = 37;
324const XP_ORB_1_16: u16 = 24;
325const PAINTING_1_16: u16 = 55;
326
327pub const EQUIPMENT_SLOTS: usize = 6;
330
331#[derive(Clone, Debug)]
333pub struct Entity {
334 pub(crate) id: i32,
335 pub(crate) uuid: Uuid,
336 pub(crate) ty: EntityType,
337 pub(crate) living: bool,
338 pub(crate) era: Era,
340 pub(crate) sizer: Option<&'static ghast_data::VanillaEntitySize>,
342 pub(crate) pos: [f64; 3],
343 pub(crate) traced: [i64; 3],
347 pub(crate) yaw: f32,
348 pub(crate) pitch: f32,
349 pub(crate) head_yaw: f32,
350 pub(crate) velocity: [f64; 3],
351 pub(crate) on_ground: bool,
352 pub(crate) data: i32,
353 pub(crate) meta: Metadata,
354 pub(crate) equipment: Option<Box<[Option<Item>; EQUIPMENT_SLOTS]>>,
355 pub(crate) vehicle_id: i32,
357 pub(crate) rides: bool,
358 pub(crate) links: Option<Box<Links>>,
360 #[cfg(any(feature = "v26_1", feature = "v26_2"))]
363 pub(crate) m: crate::modern_state::Ext,
364}
365
366impl Entity {
367 pub(crate) fn new(id: i32, ty: EntityType) -> Self {
368 Entity {
369 id,
370 uuid: Uuid::nil(),
371 ty,
372 living: matches!(ty, EntityType::Player | EntityType::LegacyMob(_)),
373 era: Era::V1_8,
374 sizer: None,
375 pos: [0.0; 3],
376 traced: [0; 3],
377 yaw: 0.0,
378 pitch: 0.0,
379 head_yaw: 0.0,
380 velocity: [0.0; 3],
381 on_ground: false,
382 data: 0,
383 meta: Metadata::default(),
384 equipment: None,
385 links: None,
386 vehicle_id: 0,
387 rides: false,
388 #[cfg(any(feature = "v26_1", feature = "v26_2"))]
389 m: crate::modern_state::Ext::default(),
390 }
391 }
392
393 #[inline]
395 pub(crate) fn links_mut(&mut self) -> &mut Links {
396 self.links.get_or_insert_with(Box::default)
397 }
398
399 #[inline]
401 pub(crate) fn set_vehicle(&mut self, v: Option<i32>) {
402 self.rides = v.is_some();
403 self.vehicle_id = v.unwrap_or(0);
404 }
405
406 #[inline]
408 pub(crate) fn take_vehicle(&mut self) -> Option<i32> {
409 let v = self.vehicle();
410 self.set_vehicle(None);
411 v
412 }
413
414 #[inline]
416 pub(crate) fn set_leash_holder(&mut self, h: Option<i32>) {
417 match (&mut self.links, h) {
418 (Some(l), h) => l.leash_holder = h,
419 (None, None) => {}
420 (None, Some(_)) => self.links_mut().leash_holder = h,
421 }
422 self.tidy_links();
423 }
424
425 #[inline]
427 pub(crate) fn take_passengers(&mut self) -> Vec<i32> {
428 let p = self
429 .links
430 .as_mut()
431 .map(|l| std::mem::take(&mut l.passengers))
432 .unwrap_or_default();
433 self.tidy_links();
434 p
435 }
436
437 #[inline]
439 pub(crate) fn remove_passenger(&mut self, id: i32) {
440 if let Some(l) = &mut self.links {
441 l.passengers.retain(|&p| p != id);
442 }
443 self.tidy_links();
444 }
445
446 #[inline]
448 pub(crate) fn set_passengers(&mut self, p: Vec<i32>) {
449 if !p.is_empty() || self.links.is_some() {
450 self.links_mut().passengers = p;
451 }
452 self.tidy_links();
453 }
454
455 #[inline]
457 pub(crate) fn push_passenger(&mut self, id: i32) {
458 self.links_mut().passengers.push(id);
459 }
460
461 #[inline]
463 pub(crate) fn clear_effects(&mut self) {
464 if let Some(l) = &mut self.links {
465 l.effects = Vec::new();
466 }
467 self.tidy_links();
468 }
469
470 #[inline]
472 pub(crate) fn tidy_links(&mut self) {
473 if self.links.as_ref().is_some_and(|l| {
474 l.leash_holder.is_none()
475 && l.profile_name.is_none()
476 && l.passengers.is_empty()
477 && l.effects.is_empty()
478 }) {
479 self.links = None;
480 }
481 }
482
483 #[cfg(test)]
486 pub(crate) fn heap_bytes(&self) -> usize {
487 let mut n = self.meta.heap_bytes();
488 if self.equipment.is_some() {
489 n += std::mem::size_of::<[Option<Item>; EQUIPMENT_SLOTS]>();
490 }
491 if let Some(l) = &self.links {
492 n += std::mem::size_of::<Links>()
493 + l.passengers.capacity() * 4
494 + l.effects.capacity() * std::mem::size_of::<Effect>();
495 }
496 #[cfg(any(feature = "v26_1", feature = "v26_2"))]
497 if self.m.0.is_some() {
498 n += std::mem::size_of::<crate::modern_state::State>();
499 }
500 n
501 }
502
503 #[must_use]
505 pub fn id(&self) -> i32 {
506 self.id
507 }
508
509 #[must_use]
511 pub fn uuid(&self) -> Uuid {
512 self.uuid
513 }
514
515 #[must_use]
517 pub fn entity_type(&self) -> EntityType {
518 self.ty
519 }
520
521 #[must_use]
523 pub fn class(&self) -> EntityClass {
524 #[cfg(feature = "v26_1")]
525 if self.era == Era::V26 {
526 return crate::v26_1::class(self);
527 }
528 #[cfg(feature = "v26_2")]
529 if self.era == Era::V26_2 {
530 return crate::v26_2::class(self);
531 }
532 match self.ty {
533 EntityType::Player => EntityClass::Player,
534 EntityType::LegacyObject(2) | EntityType::Registry(ITEM_1_16) => EntityClass::Item,
535 EntityType::ExperienceOrb | EntityType::Registry(XP_ORB_1_16) => {
536 EntityClass::ExperienceOrb
537 }
538 EntityType::Painting | EntityType::Registry(PAINTING_1_16) => EntityClass::Painting,
539 _ if self.living => EntityClass::Mob,
540 _ => EntityClass::Object,
541 }
542 }
543
544 #[must_use]
548 pub fn item(&self) -> Option<&Item> {
549 if matches!(self.era, Era::V26 | Era::V26_2) {
550 return None;
551 }
552 let index = match self.ty {
553 EntityType::LegacyObject(2) if self.era == Era::V1_12 => 6,
554 EntityType::LegacyObject(2) => 10,
555 EntityType::Registry(ITEM_1_16) => 7,
556 _ => return None,
557 };
558 self.meta.item(index).flatten()
559 }
560
561 #[must_use]
569 pub fn dimensions(&self) -> Option<ghast_data::EntityDimensions> {
570 let vs = self.sizer?;
571 match self.era {
572 #[cfg(feature = "v1_8")]
573 Era::V1_8 => crate::v1_8::dimensions(self, vs),
574 #[cfg(feature = "v1_12")]
575 Era::V1_12 => crate::v1_12::dimensions(self, vs),
576 #[cfg(feature = "v1_16_5")]
577 Era::V1_16 => crate::v1_16_5::dimensions(self, vs),
578 #[cfg(feature = "v26_1")]
579 Era::V26 => {
580 let _ = vs;
581 crate::v26_1::dimensions(self)
582 }
583 #[cfg(feature = "v26_2")]
584 Era::V26_2 => {
585 let _ = vs;
586 crate::v26_2::dimensions(self)
587 }
588 #[allow(unreachable_patterns)]
590 _ => None,
591 }
592 }
593
594 #[must_use]
598 pub fn targeting_margin(&self) -> f32 {
599 self.sizer.map_or(0.0, |s| s.targeting_margin)
600 }
601
602 #[must_use]
604 pub fn size(&self) -> Option<(f32, f32)> {
605 self.dimensions().map(|d| (d.width, d.height))
606 }
607
608 #[must_use]
611 pub fn bounding_box(&self) -> Option<[f64; 6]> {
612 let [x, y, z] = self.pos;
613 let b = self.dimensions()?.bounding_box(x, y, z);
614 Some([b.min_x, b.min_y, b.min_z, b.max_x, b.max_y, b.max_z])
615 }
616
617 #[must_use]
619 pub fn is_player(&self) -> bool {
620 self.ty == EntityType::Player
621 }
622
623 #[must_use]
635 pub fn position(&self) -> [f64; 3] {
636 self.pos
637 }
638
639 #[must_use]
641 pub fn fixed_position(&self) -> [i32; 3] {
642 if self.era == Era::V1_8 {
643 self.traced.map(|t| t as i32)
644 } else {
645 [0; 3]
646 }
647 }
648
649 #[must_use]
651 pub fn yaw(&self) -> f32 {
652 self.yaw
653 }
654
655 #[must_use]
657 pub fn pitch(&self) -> f32 {
658 self.pitch
659 }
660
661 #[must_use]
663 pub fn head_yaw(&self) -> f32 {
664 self.head_yaw
665 }
666
667 #[must_use]
670 pub fn velocity(&self) -> [f64; 3] {
671 self.velocity
672 }
673
674 #[must_use]
676 pub fn on_ground(&self) -> bool {
677 self.on_ground
678 }
679
680 #[must_use]
683 pub fn data(&self) -> i32 {
684 self.data
685 }
686
687 #[must_use]
689 pub fn vehicle(&self) -> Option<i32> {
690 self.rides.then_some(self.vehicle_id)
691 }
692
693 #[must_use]
695 pub fn passengers(&self) -> &[i32] {
696 self.links.as_ref().map_or(&[], |l| &l.passengers)
697 }
698
699 #[must_use]
701 pub fn leash_holder(&self) -> Option<i32> {
702 self.links.as_ref().and_then(|l| l.leash_holder)
703 }
704
705 #[must_use]
707 pub fn metadata(&self) -> &Metadata {
708 &self.meta
709 }
710
711 #[must_use]
713 pub fn equipment(&self, slot: usize) -> Option<&Item> {
714 self.equipment.as_ref()?.get(slot)?.as_ref()
715 }
716
717 #[must_use]
719 pub fn effects(&self) -> &[Effect] {
720 self.links.as_ref().map_or(&[], |l| &l.effects)
721 }
722
723 #[must_use]
725 pub fn effect(&self, id: u8) -> Option<&Effect> {
726 self.effects().iter().find(|e| e.id == id)
727 }
728}
729
730#[cfg(test)]
731mod tests {
732 use super::*;
733
734 #[test]
737 fn metadata_set_from_matches_set() {
738 let batches: [&[(u8, i8)]; 4] = [
739 &[(0, 1), (9, 2), (0, 3)],
740 &[(9, 4)],
741 &[(5, 5), (2, 6), (5, 7), (9, 8)],
742 &[(7, 9), (3, 10)],
743 ];
744 let keep = |i: u8| i != 3;
745 let (mut a, mut b) = (Metadata::default(), Metadata::default());
746 for batch in batches {
747 let mut src: Vec<(u8, MetaValue)> = batch
748 .iter()
749 .map(|&(i, v)| (i, MetaValue::Byte(v)))
750 .collect();
751 for (i, v) in src.clone() {
752 if keep(i) {
753 a.set(i, v);
754 }
755 }
756 b.set_from(&mut src, keep);
757 assert!(src.is_empty());
758 assert_eq!(a, b);
759 }
760 let got: Vec<(u8, i8)> = b
761 .iter()
762 .map(|(i, v)| match v {
763 MetaValue::Byte(x) => (i, *x),
764 _ => unreachable!(),
765 })
766 .collect();
767 assert_eq!(got, [(0, 3), (9, 8), (5, 7), (2, 6), (7, 9)]);
768 assert_eq!(b.heap_bytes(), 5 * std::mem::size_of::<(u8, MetaValue)>());
769 b.clear();
770 assert!(b.is_empty() && b.heap_bytes() == 0);
771 }
772
773 #[test]
774 fn links_are_freed_when_empty() {
775 let mut e = Entity::new(1, EntityType::Player);
776 e.set_vehicle(None);
777 e.set_leash_holder(None);
778 e.clear_effects();
779 assert!(e.links.is_none());
780 e.set_vehicle(Some(2));
781 e.push_passenger(3);
782 assert_eq!((e.vehicle(), e.passengers()), (Some(2), &[3][..]));
783 e.set_vehicle(None);
784 e.remove_passenger(3);
785 assert!(e.links.is_none());
786 assert_eq!(e.take_passengers(), Vec::<i32>::new());
787 }
788}