1use std::collections::HashMap;
4use std::hash::{BuildHasherDefault, Hasher};
5
6use uuid::Uuid;
7
8use crate::entity::{Entity, EntityType, MetaValue};
9
10#[derive(Clone, Copy, Debug, PartialEq, Eq)]
21#[non_exhaustive]
22pub struct Config {
23 pub metadata: bool,
25 pub equipment: bool,
27 pub effects: bool,
29 pub player_list: bool,
31 pub events: bool,
33 pub skins: bool,
36 pub player_names: bool,
43}
44
45impl Config {
46 #[must_use]
48 pub const fn with_metadata(mut self, on: bool) -> Self {
49 self.metadata = on;
50 self
51 }
52
53 #[must_use]
55 pub const fn with_equipment(mut self, on: bool) -> Self {
56 self.equipment = on;
57 self
58 }
59
60 #[must_use]
62 pub const fn with_effects(mut self, on: bool) -> Self {
63 self.effects = on;
64 self
65 }
66
67 #[must_use]
69 pub const fn with_player_list(mut self, on: bool) -> Self {
70 self.player_list = on;
71 self
72 }
73
74 #[must_use]
76 pub const fn with_events(mut self, on: bool) -> Self {
77 self.events = on;
78 self
79 }
80
81 #[must_use]
83 pub const fn with_skins(mut self, on: bool) -> Self {
84 self.skins = on;
85 self
86 }
87
88 #[must_use]
90 pub const fn with_player_names(mut self, on: bool) -> Self {
91 self.player_names = on;
92 self
93 }
94
95 #[must_use]
98 pub const fn reads_tab_list(&self) -> bool {
99 self.player_list || self.player_names
100 }
101}
102
103impl Default for Config {
104 fn default() -> Self {
105 Config {
106 metadata: true,
107 equipment: true,
108 effects: true,
109 player_list: true,
110 events: false,
111 skins: false,
112 player_names: false,
113 }
114 }
115}
116
117#[derive(Clone, Copy, Debug, PartialEq, Eq)]
119#[non_exhaustive]
120pub enum Event {
121 Spawned(i32),
123 Removed {
125 id: i32,
127 ty: EntityType,
129 },
130 Moved(i32),
132 Velocity(i32),
134 Status {
136 id: i32,
138 status: i8,
140 },
141 Metadata(i32),
143 Equipment(i32),
145 Effects(i32),
147 Mounted {
149 id: i32,
151 vehicle: Option<i32>,
153 },
154 Collected {
156 collected: i32,
158 collector: i32,
160 },
161 PlayerList,
163}
164
165#[derive(Clone, Debug, PartialEq, Eq)]
167#[non_exhaustive]
168pub struct PlayerInfo {
169 pub name: Box<str>,
171 pub game_mode: i32,
173 pub ping: i32,
175 pub display_name: Option<Box<str>>,
178 pub textures: Option<Box<str>>,
181 pub display_name_nbt: Option<bytes::Bytes>,
183 pub listed: bool,
185 pub list_order: i32,
187 pub(crate) generation: u32,
189}
190
191#[derive(Default, Clone, Copy)]
192pub(crate) struct IdHasher(u64);
193
194impl Hasher for IdHasher {
195 #[inline]
196 fn finish(&self) -> u64 {
197 let h = self.0.wrapping_mul(0x9E37_79B9_7F4A_7C15);
198 h ^ (h >> 29)
199 }
200
201 #[inline]
202 fn write(&mut self, bytes: &[u8]) {
203 for &b in bytes {
204 self.0 = (self.0 << 8) | u64::from(b);
205 }
206 }
207
208 #[inline]
209 fn write_i32(&mut self, v: i32) {
210 self.0 = u64::from(v as u32);
211 }
212
213 #[inline]
214 fn write_u64(&mut self, v: u64) {
215 self.0 = v;
216 }
217
218 #[inline]
219 fn write_u128(&mut self, v: u128) {
220 self.0 = (v as u64) ^ ((v >> 64) as u64);
221 }
222}
223
224pub(crate) type Fast<K, V> = HashMap<K, V, BuildHasherDefault<IdHasher>>;
225
226#[inline]
230pub(crate) fn shrink_map<K: Eq + std::hash::Hash, V>(m: &mut Fast<K, V>) {
231 let cap = m.capacity();
232 if cap > 64 && m.len() * 4 < cap {
233 m.shrink_to(m.len() * 2);
234 }
235}
236
237#[inline]
244pub(crate) fn after_insert<K: Eq + std::hash::Hash, V>(m: &mut Fast<K, V>, old_cap: usize) {
245 let cap = m.capacity();
246 if cap >= 2 * old_cap.max(1) && m.len() * 2 <= cap {
247 compact(m);
248 }
249}
250
251#[cold]
252#[inline(never)]
253fn compact<K: Eq + std::hash::Hash, V>(m: &mut Fast<K, V>) {
254 m.shrink_to(m.len());
255}
256
257#[derive(Clone, Copy, Debug)]
261pub(crate) struct TabLite {
262 name: [u8; TabLite::INLINE],
263 len: u8,
265 pub(crate) game_mode: i32,
266 pub(crate) generation: u32,
267}
268
269impl TabLite {
270 const INLINE: usize = 23;
272 const LONG: u8 = u8::MAX;
273}
274
275#[derive(Clone, Copy, Debug)]
277pub(crate) struct TabRef<'a> {
278 pub(crate) name: &'a str,
279 pub(crate) game_mode: i32,
280 pub(crate) generation: u32,
281}
282
283#[derive(Clone, Copy)]
286pub(crate) struct Tabs<'a> {
287 pub(crate) players: &'a Fast<Uuid, PlayerInfo>,
288 pub(crate) lite: &'a Fast<Uuid, TabLite>,
289 pub(crate) long_names: &'a Fast<Uuid, Box<str>>,
290}
291
292impl<'a> Tabs<'a> {
293 #[inline]
295 pub(crate) fn get(self, uuid: &Uuid) -> Option<TabRef<'a>> {
296 if let Some(p) = self.players.get(uuid) {
297 return Some(TabRef {
298 name: &p.name,
299 game_mode: p.game_mode,
300 generation: p.generation,
301 });
302 }
303 if self.lite.is_empty() {
304 return None;
305 }
306 let t = self.lite.get(uuid)?;
307 let name = if t.len == TabLite::LONG {
308 self.long_names.get(uuid).map_or("", |n| &**n)
309 } else {
310 std::str::from_utf8(&t.name[..usize::from(t.len)]).unwrap_or("")
311 };
312 Some(TabRef {
313 name,
314 game_mode: t.game_mode,
315 generation: t.generation,
316 })
317 }
318}
319
320#[derive(Clone, Debug, Default)]
322pub struct Entities {
323 pub(crate) map: Fast<i32, Entity>,
324 pub(crate) self_id: Option<i32>,
325 pub(crate) config: Config,
326 pub(crate) events: Vec<Event>,
327 pub(crate) players: Fast<Uuid, PlayerInfo>,
328 pub(crate) lite: Fast<Uuid, TabLite>,
330 pub(crate) long_names: Fast<Uuid, Box<str>>,
332 pub(crate) scratch: Vec<(u8, MetaValue)>,
333 pub(crate) any_leash: bool,
335 pub(crate) era: crate::entity::Era,
337 pub(crate) generations: u32,
339}
340
341impl Entities {
342 pub(crate) fn new(config: Config) -> Self {
343 Entities {
344 config,
345 ..Default::default()
346 }
347 }
348
349 #[inline]
351 #[must_use]
352 pub fn get(&self, id: i32) -> Option<&Entity> {
353 self.map.get(&id)
354 }
355
356 #[must_use]
358 pub fn len(&self) -> usize {
359 self.map.len()
360 }
361
362 #[must_use]
364 pub fn is_empty(&self) -> bool {
365 self.map.is_empty()
366 }
367
368 pub fn iter(&self) -> impl Iterator<Item = &Entity> {
370 let me = self.self_id;
371 self.map.values().filter(move |e| Some(e.id) != me)
372 }
373
374 #[must_use]
377 pub fn self_id(&self) -> Option<i32> {
378 self.self_id
379 }
380
381 #[must_use]
383 pub fn me(&self) -> Option<&Entity> {
384 self.map.get(&self.self_id?)
385 }
386
387 pub fn within(&self, p: [f64; 3], radius: f64) -> impl Iterator<Item = &Entity> {
389 let r2 = radius * radius;
390 self.iter().filter(move |e| {
391 let d = [e.pos[0] - p[0], e.pos[1] - p[1], e.pos[2] - p[2]];
392 d[0] * d[0] + d[1] * d[1] + d[2] * d[2] <= r2
393 })
394 }
395
396 pub fn near(&self, p: [f64; 3], radius: f64) -> impl Iterator<Item = &Entity> {
398 self.within(p, radius)
399 }
400
401 #[must_use]
403 pub fn player_info(&self, uuid: &Uuid) -> Option<&PlayerInfo> {
404 self.players.get(uuid)
405 }
406
407 pub fn players(&self) -> impl Iterator<Item = (&Uuid, &PlayerInfo)> {
409 self.players.iter()
410 }
411
412 #[must_use]
415 pub fn player_name(&self, id: i32) -> Option<&str> {
416 let e = self.map.get(&id)?;
417 e.is_player()
418 .then(|| self.tab(&e.uuid).map(|t| t.name))
419 .flatten()
420 }
421
422 #[must_use]
424 pub fn tab_name(&self, uuid: &Uuid) -> Option<&str> {
425 self.tab(uuid).map(|t| t.name)
426 }
427
428 #[must_use]
430 pub fn tab_game_mode(&self, uuid: &Uuid) -> Option<i32> {
431 self.tab(uuid).map(|t| t.game_mode)
432 }
433
434 #[must_use]
436 pub fn tab_len(&self) -> usize {
437 self.players.len() + self.lite.len()
438 }
439
440 #[inline]
442 pub(crate) fn lite_mode(&self) -> bool {
443 !self.config.player_list && self.config.player_names
444 }
445
446 #[inline]
448 pub(crate) fn tab(&self, uuid: &Uuid) -> Option<TabRef<'_>> {
449 self.tabs().get(uuid)
450 }
451
452 #[inline]
454 pub(crate) fn tabs(&self) -> Tabs<'_> {
455 Tabs {
456 players: &self.players,
457 lite: &self.lite,
458 long_names: &self.long_names,
459 }
460 }
461
462 #[inline]
464 pub(crate) fn tab_has(&self, uuid: &Uuid) -> bool {
465 self.players.contains_key(uuid) || self.lite.contains_key(uuid)
466 }
467
468 pub(crate) fn lite_add(
471 &mut self,
472 uuid: Uuid,
473 name: &str,
474 game_mode: i32,
475 generation: u32,
476 replace: bool,
477 ) -> bool {
478 if !replace && self.lite.contains_key(&uuid) {
479 return false;
480 }
481 let mut t = TabLite {
482 name: [0; TabLite::INLINE],
483 len: TabLite::LONG,
484 game_mode,
485 generation,
486 };
487 if name.len() <= TabLite::INLINE {
488 t.name[..name.len()].copy_from_slice(name.as_bytes());
489 t.len = name.len() as u8;
490 if self.long_names.remove(&uuid).is_some() {
491 shrink_map(&mut self.long_names);
492 }
493 } else {
494 self.long_names.insert(uuid, Box::from(name));
495 }
496 let cap = self.lite.capacity();
497 self.lite.insert(uuid, t);
498 after_insert(&mut self.lite, cap);
499 true
500 }
501
502 pub(crate) fn tab_remove(&mut self, uuid: &Uuid) -> Option<(i32, u32)> {
504 if let Some(p) = self.players.remove(uuid) {
505 shrink_map(&mut self.players);
506 return Some((p.game_mode, p.generation));
507 }
508 let t = self.lite.remove(uuid)?;
509 if t.len == TabLite::LONG && self.long_names.remove(uuid).is_some() {
510 shrink_map(&mut self.long_names);
511 }
512 shrink_map(&mut self.lite);
513 Some((t.game_mode, t.generation))
514 }
515
516 #[inline]
518 pub(crate) fn lite_game_mode(&mut self, uuid: &Uuid, game_mode: i32) {
519 if let Some(t) = self.lite.get_mut(uuid) {
520 t.game_mode = game_mode;
521 }
522 }
523
524 #[must_use]
526 pub fn config(&self) -> Config {
527 self.config
528 }
529
530 pub fn drain_events(&mut self) -> std::vec::Drain<'_, Event> {
532 self.events.drain(..)
533 }
534
535 pub fn clear(&mut self) {
537 if self.config.events {
538 let me = self.self_id;
539 self.events.extend(
540 self.map
541 .values()
542 .filter(|e| Some(e.id) != me)
543 .map(|e| Event::Removed { id: e.id, ty: e.ty }),
544 );
545 }
546 let me = self.self_id.and_then(|id| self.map.remove(&id));
547 self.map.clear();
548 shrink_map(&mut self.map);
549 if let Some(mut me) = me {
550 me.set_vehicle(None);
551 if let Some(l) = &mut me.links {
552 l.passengers.clear();
553 l.leash_holder = None;
554 }
555 me.tidy_links();
556 self.map.insert(me.id, me);
557 }
558 }
559
560 #[inline]
561 pub(crate) fn event(&mut self, e: Event) {
562 if self.config.events {
563 self.events.push(e);
564 }
565 }
566
567 pub(crate) fn set_self(&mut self, id: i32) {
568 if let Some(old) = self.self_id {
569 self.map.remove(&old);
570 }
571 self.self_id = Some(id);
572 let mut me = Entity::new(id, EntityType::Player);
573 self.resolve(&mut me);
574 self.map.insert(id, me);
575 }
576
577 fn resolve(&self, e: &mut Entity) {
579 use crate::entity::Era;
580 e.era = self.era;
581 e.sizer = match self.era {
582 #[cfg(feature = "v1_8")]
583 Era::V1_8 => crate::v1_8::vanilla_size(e),
584 #[cfg(feature = "v1_12")]
585 Era::V1_12 => crate::v1_12::vanilla_size(e),
586 #[cfg(feature = "v1_16_5")]
587 Era::V1_16 => crate::v1_16_5::vanilla_size(e),
588 #[cfg(feature = "v26_1")]
589 Era::V26 => crate::v26_1::vanilla_size(e),
590 #[cfg(feature = "v26_2")]
591 Era::V26_2 => crate::v26_2::vanilla_size(e),
592 #[allow(unreachable_patterns)]
593 _ => None,
594 };
595 }
596
597 pub(crate) fn spawn(&mut self, mut e: Entity) {
599 let id = e.id;
600 self.resolve(&mut e);
601 if Some(id) == self.self_id {
602 return;
603 }
604 if self.map.contains_key(&id) {
605 self.unlink(id);
606 }
607 let cap = self.map.capacity();
608 self.map.insert(id, e);
609 after_insert(&mut self.map, cap);
610 self.event(Event::Spawned(id));
611 }
612
613 pub(crate) fn remove(&mut self, id: i32) -> bool {
614 if Some(id) == self.self_id || !self.map.contains_key(&id) {
615 return false;
616 }
617 self.unlink(id);
618 if let Some(e) = self.map.remove(&id) {
619 self.event(Event::Removed { id, ty: e.ty });
620 }
621 shrink_map(&mut self.map);
622 true
623 }
624
625 fn unlink(&mut self, id: i32) {
627 let Some(e) = self.map.get_mut(&id) else {
628 return;
629 };
630 if e.links.is_none() && !e.rides && !self.any_leash {
631 return;
632 }
633 let vehicle = e.take_vehicle();
634 let passengers = e.take_passengers();
635 if let Some(v) = vehicle
636 && let Some(v) = self.map.get_mut(&v)
637 {
638 v.remove_passenger(id);
639 }
640 for p in passengers {
641 if let Some(p) = self.map.get_mut(&p)
642 && p.vehicle() == Some(id)
643 {
644 p.set_vehicle(None);
645 }
646 }
647 if self.any_leash {
648 for other in self.map.values_mut() {
649 if other.leash_holder() == Some(id) {
650 other.set_leash_holder(None);
651 }
652 }
653 }
654 }
655
656 fn rides(&self, vehicle: i32, rider: i32) -> bool {
658 let mut cur = Some(vehicle);
659 let mut guard = 0;
660 while let Some(c) = cur {
661 if c == rider {
662 return true;
663 }
664 guard += 1;
665 if guard > 64 {
666 return true;
667 }
668 cur = self.map.get(&c).and_then(Entity::vehicle);
669 }
670 false
671 }
672
673 pub(crate) fn mount(&mut self, rider: i32, vehicle: Option<i32>, single: bool) -> bool {
676 if !self.map.contains_key(&rider) {
677 return false;
678 }
679 if let Some(v) = vehicle
680 && (!self.map.contains_key(&v) || self.rides(v, rider))
681 {
682 return false;
683 }
684 let old = self.map.get_mut(&rider).and_then(Entity::take_vehicle);
686 if let Some(o) = old
687 && let Some(o) = self.map.get_mut(&o)
688 {
689 o.remove_passenger(rider);
690 }
691 if let Some(v) = vehicle {
692 let prev: Vec<i32> = if single {
693 self.map
694 .get_mut(&v)
695 .map(Entity::take_passengers)
696 .unwrap_or_default()
697 } else {
698 Vec::new()
699 };
700 for p in prev {
701 if let Some(p) = self.map.get_mut(&p) {
702 p.set_vehicle(None);
703 }
704 }
705 if let Some(ve) = self.map.get_mut(&v) {
706 ve.push_passenger(rider);
707 }
708 if let Some(r) = self.map.get_mut(&rider) {
709 r.set_vehicle(Some(v));
710 }
711 }
712 self.event(Event::Mounted { id: rider, vehicle });
713 true
714 }
715
716 pub(crate) fn set_passengers(&mut self, vehicle: i32, ids: impl Iterator<Item = i32>) -> bool {
718 let Some(v) = self.map.get_mut(&vehicle) else {
719 return false;
720 };
721 let old = v.take_passengers();
722 for p in &old {
723 if let Some(p) = self.map.get_mut(p)
724 && p.vehicle() == Some(vehicle)
725 {
726 p.set_vehicle(None);
727 }
728 }
729 let mut old = old;
731 old.clear();
732 if let Some(v) = self.map.get_mut(&vehicle) {
733 v.set_passengers(old);
734 }
735 for id in ids {
736 self.mount(id, Some(vehicle), false);
737 }
738 true
739 }
740
741 pub(crate) fn leash(&mut self, id: i32, holder: Option<i32>) -> bool {
742 match self.map.get_mut(&id) {
743 Some(e) => {
744 e.set_leash_holder(holder);
745 self.any_leash |= holder.is_some();
746 true
747 }
748 None => false,
749 }
750 }
751}
752
753#[cfg(test)]
754mod tests {
755 use super::*;
756
757 fn store() -> Entities {
758 let mut s = Entities::new(Config {
759 events: true,
760 ..Config::default()
761 });
762 for id in 1..=4 {
763 s.spawn(Entity::new(id, EntityType::Registry(6)));
764 }
765 s
766 }
767
768 #[test]
770 fn entity_size() {
771 let n = std::mem::size_of::<Entity>();
772 eprintln!("size_of::<Entity>() = {n}");
773 let modern = cfg!(any(feature = "v26_1", feature = "v26_2"));
776 assert!(n <= if modern { 168 } else { 160 }, "{n}");
777 #[cfg(any(feature = "v26_1", feature = "v26_2"))]
778 {
779 let b = std::mem::size_of::<crate::modern_state::State>();
780 eprintln!("size_of::<modern_state::State>() = {b} (heap, 26.x entities only)");
781 assert!(b <= 120, "{b}");
782 }
783 }
784
785 #[test]
786 fn mount_single_and_multi() {
787 let mut s = store();
788 assert!(s.mount(1, Some(2), true));
789 assert!(s.mount(3, Some(2), true)); assert_eq!(s.get(2).unwrap().passengers(), &[3]);
791 assert_eq!(s.get(1).unwrap().vehicle(), None);
792 assert!(!s.mount(2, Some(3), true), "cycle");
793 assert!(s.set_passengers(4, [1, 3].into_iter()));
794 assert_eq!(s.get(4).unwrap().passengers(), &[1, 3]);
795 assert_eq!(s.get(2).unwrap().passengers(), &[] as &[i32]);
796 assert_eq!(s.get(3).unwrap().vehicle(), Some(4));
797 s.remove(4);
798 assert_eq!(s.get(1).unwrap().vehicle(), None);
799 assert_eq!(s.get(3).unwrap().vehicle(), None);
800 }
801
802 #[test]
803 fn self_entry_survives_clear() {
804 let mut s = store();
805 s.set_self(9);
806 s.spawn(Entity::new(9, EntityType::Registry(1))); assert_eq!(s.get(9).unwrap().entity_type(), EntityType::Player);
808 assert!(!s.remove(9));
809 s.drain_events().for_each(drop);
810 s.clear();
811 assert_eq!(s.len(), 1);
812 assert!(s.me().is_some());
813 assert_eq!(s.drain_events().count(), 4);
814 assert_eq!(s.iter().count(), 0);
815 }
816}