Skip to main content

ghast_entity/
store.rs

1//! Version-independent entity store shared by the per-version trackers.
2
3use std::collections::HashMap;
4use std::hash::{BuildHasherDefault, Hasher};
5
6use uuid::Uuid;
7
8use crate::entity::{Entity, EntityType, MetaValue};
9
10/// What the tracker keeps. Everything off costs nothing beyond position tracking; packets for a
11/// disabled part are not parsed (and the client should not even decode them, see the version
12/// modules' packet id lists).
13#[derive(Clone, Copy, Debug, PartialEq, Eq)]
14pub struct Config {
15    /// Entity metadata (flags, health, item of item entities, names, ...). Default `true`.
16    pub metadata: bool,
17    /// Equipment. Default `true`.
18    pub equipment: bool,
19    /// Status effects. Default `true`.
20    pub effects: bool,
21    /// Tab list (`player_info`). Default `true`.
22    pub player_list: bool,
23    /// Queue [`Event`]s for [`Entities::drain_events`]. Default `false`.
24    pub events: bool,
25}
26
27impl Default for Config {
28    fn default() -> Self {
29        Config {
30            metadata: true,
31            equipment: true,
32            effects: true,
33            player_list: true,
34            events: false,
35        }
36    }
37}
38
39/// A change notification (only queued with [`Config::events`]).
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41pub enum Event {
42    /// A new entity (or a replacement for an existing id).
43    Spawned(i32),
44    /// An entity was removed (destroy, pickup, world change).
45    Removed {
46        /// Id.
47        id: i32,
48        /// Its type.
49        ty: EntityType,
50    },
51    /// Server position or rotation changed (movement, teleport).
52    Moved(i32),
53    /// Velocity changed.
54    Velocity(i32),
55    /// `entity_status` (e.g. 2 hurt, 3 death).
56    Status {
57        /// Id.
58        id: i32,
59        /// Status byte.
60        status: i8,
61    },
62    /// Metadata changed.
63    Metadata(i32),
64    /// Equipment changed.
65    Equipment(i32),
66    /// Effects changed.
67    Effects(i32),
68    /// Riding changed: `id` now rides `vehicle`.
69    Mounted {
70        /// Rider.
71        id: i32,
72        /// Vehicle (`None` = dismounted).
73        vehicle: Option<i32>,
74    },
75    /// An item / orb / arrow was picked up (`collector` may be the bot).
76    Collected {
77        /// Picked-up entity.
78        collected: i32,
79        /// Collector.
80        collector: i32,
81    },
82    /// The tab list changed.
83    PlayerList,
84}
85
86/// A tab-list entry.
87#[derive(Clone, Debug, PartialEq, Eq)]
88pub struct PlayerInfo {
89    /// Profile name.
90    pub name: Box<str>,
91    /// Game mode.
92    pub game_mode: i32,
93    /// Latency in ms.
94    pub ping: i32,
95    /// Display name (raw chat JSON), if set.
96    pub display_name: Option<Box<str>>,
97}
98
99#[derive(Default, Clone, Copy)]
100pub(crate) struct IdHasher(u64);
101
102impl Hasher for IdHasher {
103    #[inline]
104    fn finish(&self) -> u64 {
105        let h = self.0.wrapping_mul(0x9E37_79B9_7F4A_7C15);
106        h ^ (h >> 29)
107    }
108
109    #[inline]
110    fn write(&mut self, bytes: &[u8]) {
111        for &b in bytes {
112            self.0 = (self.0 << 8) | u64::from(b);
113        }
114    }
115
116    #[inline]
117    fn write_i32(&mut self, v: i32) {
118        self.0 = u64::from(v as u32);
119    }
120
121    #[inline]
122    fn write_u128(&mut self, v: u128) {
123        self.0 = (v as u64) ^ ((v >> 64) as u64);
124    }
125}
126
127type Fast<K, V> = HashMap<K, V, BuildHasherDefault<IdHasher>>;
128
129/// The tracked entities and tab list (queries are the same for every version).
130#[derive(Clone, Debug, Default)]
131pub struct Entities {
132    pub(crate) map: Fast<i32, Entity>,
133    pub(crate) self_id: Option<i32>,
134    pub(crate) config: Config,
135    pub(crate) events: Vec<Event>,
136    pub(crate) players: Fast<Uuid, PlayerInfo>,
137    pub(crate) scratch: Vec<(u8, MetaValue)>,
138    /// Set once any leash link exists (skips the leash scan on removal otherwise).
139    pub(crate) any_leash: bool,
140    /// 1.16 tracker (selects the vanilla size table).
141    pub(crate) modern: bool,
142}
143
144impl Entities {
145    pub(crate) fn new(config: Config) -> Self {
146        Entities {
147            config,
148            ..Default::default()
149        }
150    }
151
152    /// The entity with this id (including the bot's own entry, see [`Entities::self_id`]).
153    #[inline]
154    #[must_use]
155    pub fn get(&self, id: i32) -> Option<&Entity> {
156        self.map.get(&id)
157    }
158
159    /// Number of tracked entities (including the bot's own entry).
160    #[must_use]
161    pub fn len(&self) -> usize {
162        self.map.len()
163    }
164
165    /// `true` when nothing is tracked.
166    #[must_use]
167    pub fn is_empty(&self) -> bool {
168        self.map.is_empty()
169    }
170
171    /// Other entities (the bot's own entry is skipped), arbitrary order.
172    pub fn iter(&self) -> impl Iterator<Item = &Entity> {
173        let me = self.self_id;
174        self.map.values().filter(move |e| Some(e.id) != me)
175    }
176
177    /// The bot's own entity id (from `login`). Its entry carries metadata, effects, equipment
178    /// and riding state, but **no position**: the client owns its own position.
179    #[must_use]
180    pub fn self_id(&self) -> Option<i32> {
181        self.self_id
182    }
183
184    /// The bot's own entry.
185    #[must_use]
186    pub fn me(&self) -> Option<&Entity> {
187        self.map.get(&self.self_id?)
188    }
189
190    /// Entities whose server position is within `radius` of `p` (linear scan).
191    pub fn within(&self, p: [f64; 3], radius: f64) -> impl Iterator<Item = &Entity> {
192        let r2 = radius * radius;
193        self.iter().filter(move |e| {
194            let d = [e.pos[0] - p[0], e.pos[1] - p[1], e.pos[2] - p[2]];
195            d[0] * d[0] + d[1] * d[1] + d[2] * d[2] <= r2
196        })
197    }
198
199    /// Alias of [`Entities::within`].
200    pub fn near(&self, p: [f64; 3], radius: f64) -> impl Iterator<Item = &Entity> {
201        self.within(p, radius)
202    }
203
204    /// The tab list.
205    #[must_use]
206    pub fn player_info(&self, uuid: &Uuid) -> Option<&PlayerInfo> {
207        self.players.get(uuid)
208    }
209
210    /// All tab-list entries.
211    pub fn players(&self) -> impl Iterator<Item = (&Uuid, &PlayerInfo)> {
212        self.players.iter()
213    }
214
215    /// Name of a player entity (from the tab list).
216    #[must_use]
217    pub fn player_name(&self, id: i32) -> Option<&str> {
218        let e = self.map.get(&id)?;
219        e.is_player()
220            .then(|| self.players.get(&e.uuid).map(|p| &*p.name))
221            .flatten()
222    }
223
224    /// The configuration.
225    #[must_use]
226    pub fn config(&self) -> Config {
227        self.config
228    }
229
230    /// Takes the queued events (keeps the buffer's capacity).
231    pub fn drain_events(&mut self) -> std::vec::Drain<'_, Event> {
232        self.events.drain(..)
233    }
234
235    /// Removes every entity (keeps the tab list and the bot's id).
236    pub fn clear(&mut self) {
237        if self.config.events {
238            let me = self.self_id;
239            self.events.extend(
240                self.map
241                    .values()
242                    .filter(|e| Some(e.id) != me)
243                    .map(|e| Event::Removed { id: e.id, ty: e.ty }),
244            );
245        }
246        let me = self.self_id.and_then(|id| self.map.remove(&id));
247        self.map.clear();
248        if let Some(mut me) = me {
249            me.vehicle = None;
250            me.passengers.clear();
251            me.leash_holder = None;
252            self.map.insert(me.id, me);
253        }
254    }
255
256    #[inline]
257    pub(crate) fn event(&mut self, e: Event) {
258        if self.config.events {
259            self.events.push(e);
260        }
261    }
262
263    pub(crate) fn set_self(&mut self, id: i32) {
264        if let Some(old) = self.self_id {
265            self.map.remove(&old);
266        }
267        self.self_id = Some(id);
268        let mut me = Entity::new(id, EntityType::Player);
269        me.sizer = if self.modern {
270            crate::v1_16_5::vanilla_size(&me).map(|v| (v, true))
271        } else {
272            crate::v1_8::vanilla_size(&me).map(|v| (v, false))
273        };
274        self.map.insert(id, me);
275    }
276
277    /// Adds an entity, replacing (and unlinking) any entity with the same id, as vanilla does.
278    pub(crate) fn spawn(&mut self, mut e: Entity) {
279        let id = e.id;
280        e.sizer = if self.modern {
281            crate::v1_16_5::vanilla_size(&e).map(|v| (v, true))
282        } else {
283            crate::v1_8::vanilla_size(&e).map(|v| (v, false))
284        };
285        if Some(id) == self.self_id {
286            return;
287        }
288        if self.map.contains_key(&id) {
289            self.unlink(id);
290        }
291        self.map.insert(id, e);
292        self.event(Event::Spawned(id));
293    }
294
295    pub(crate) fn remove(&mut self, id: i32) -> bool {
296        if Some(id) == self.self_id || !self.map.contains_key(&id) {
297            return false;
298        }
299        self.unlink(id);
300        if let Some(e) = self.map.remove(&id) {
301            self.event(Event::Removed { id, ty: e.ty });
302        }
303        true
304    }
305
306    /// Detaches `id` from its vehicle, passengers and leash links.
307    fn unlink(&mut self, id: i32) {
308        let Some(e) = self.map.get_mut(&id) else {
309            return;
310        };
311        let vehicle = e.vehicle.take();
312        let passengers = std::mem::take(&mut e.passengers);
313        if let Some(v) = vehicle
314            && let Some(v) = self.map.get_mut(&v)
315        {
316            v.passengers.retain(|&p| p != id);
317        }
318        for p in passengers {
319            if let Some(p) = self.map.get_mut(&p)
320                && p.vehicle == Some(id)
321            {
322                p.vehicle = None;
323            }
324        }
325        if self.any_leash {
326            for other in self.map.values_mut() {
327                if other.leash_holder == Some(id) {
328                    other.leash_holder = None;
329                }
330            }
331        }
332    }
333
334    /// `true` when `vehicle` is `rider` or (indirectly) rides `rider`.
335    fn rides(&self, vehicle: i32, rider: i32) -> bool {
336        let mut cur = Some(vehicle);
337        let mut guard = 0;
338        while let Some(c) = cur {
339            if c == rider {
340                return true;
341            }
342            guard += 1;
343            if guard > 64 {
344                return true;
345            }
346            cur = self.map.get(&c).and_then(|e| e.vehicle);
347        }
348        false
349    }
350
351    /// Makes `rider` ride `vehicle` (or dismount with `None`). `single` = 1.8 semantics (one
352    /// rider per vehicle: a previous rider is dismounted). Returns `false` when ignored.
353    pub(crate) fn mount(&mut self, rider: i32, vehicle: Option<i32>, single: bool) -> bool {
354        if !self.map.contains_key(&rider) {
355            return false;
356        }
357        if let Some(v) = vehicle
358            && (!self.map.contains_key(&v) || self.rides(v, rider))
359        {
360            return false;
361        }
362        // Leave the old vehicle.
363        let old = self.map.get_mut(&rider).and_then(|e| e.vehicle.take());
364        if let Some(o) = old
365            && let Some(o) = self.map.get_mut(&o)
366        {
367            o.passengers.retain(|&p| p != rider);
368        }
369        if let Some(v) = vehicle {
370            let prev: Vec<i32> = if single {
371                self.map
372                    .get_mut(&v)
373                    .map(|e| std::mem::take(&mut e.passengers))
374                    .unwrap_or_default()
375            } else {
376                Vec::new()
377            };
378            for p in prev {
379                if let Some(p) = self.map.get_mut(&p) {
380                    p.vehicle = None;
381                }
382            }
383            if let Some(ve) = self.map.get_mut(&v) {
384                ve.passengers.push(rider);
385            }
386            if let Some(r) = self.map.get_mut(&rider) {
387                r.vehicle = Some(v);
388            }
389        }
390        self.event(Event::Mounted { id: rider, vehicle });
391        true
392    }
393
394    /// 1.16 `set_passengers`: ejects every current passenger of `vehicle`, then mounts `ids`.
395    pub(crate) fn set_passengers(&mut self, vehicle: i32, ids: impl Iterator<Item = i32>) -> bool {
396        let Some(v) = self.map.get_mut(&vehicle) else {
397            return false;
398        };
399        let old = std::mem::take(&mut v.passengers);
400        for p in &old {
401            if let Some(p) = self.map.get_mut(p)
402                && p.vehicle == Some(vehicle)
403            {
404                p.vehicle = None;
405            }
406        }
407        // Reuse the old buffer for the new list (no allocation in steady state).
408        let mut old = old;
409        old.clear();
410        if let Some(v) = self.map.get_mut(&vehicle) {
411            v.passengers = old;
412        }
413        for id in ids {
414            self.mount(id, Some(vehicle), false);
415        }
416        true
417    }
418
419    pub(crate) fn leash(&mut self, id: i32, holder: Option<i32>) -> bool {
420        match self.map.get_mut(&id) {
421            Some(e) => {
422                e.leash_holder = holder;
423                self.any_leash |= holder.is_some();
424                true
425            }
426            None => false,
427        }
428    }
429}
430
431#[cfg(test)]
432mod tests {
433    use super::*;
434
435    fn store() -> Entities {
436        let mut s = Entities::new(Config {
437            events: true,
438            ..Config::default()
439        });
440        for id in 1..=4 {
441            s.spawn(Entity::new(id, EntityType::Registry(6)));
442        }
443        s
444    }
445
446    #[test]
447    fn mount_single_and_multi() {
448        let mut s = store();
449        assert!(s.mount(1, Some(2), true));
450        assert!(s.mount(3, Some(2), true)); // 1.8: replaces rider 1
451        assert_eq!(s.get(2).unwrap().passengers(), &[3]);
452        assert_eq!(s.get(1).unwrap().vehicle(), None);
453        assert!(!s.mount(2, Some(3), true), "cycle");
454        assert!(s.set_passengers(4, [1, 3].into_iter()));
455        assert_eq!(s.get(4).unwrap().passengers(), &[1, 3]);
456        assert_eq!(s.get(2).unwrap().passengers(), &[] as &[i32]);
457        assert_eq!(s.get(3).unwrap().vehicle(), Some(4));
458        s.remove(4);
459        assert_eq!(s.get(1).unwrap().vehicle(), None);
460        assert_eq!(s.get(3).unwrap().vehicle(), None);
461    }
462
463    #[test]
464    fn self_entry_survives_clear() {
465        let mut s = store();
466        s.set_self(9);
467        s.spawn(Entity::new(9, EntityType::Registry(1))); // ignored: own id
468        assert_eq!(s.get(9).unwrap().entity_type(), EntityType::Player);
469        assert!(!s.remove(9));
470        s.drain_events().for_each(drop);
471        s.clear();
472        assert_eq!(s.len(), 1);
473        assert!(s.me().is_some());
474        assert_eq!(s.drain_events().count(), 4);
475        assert_eq!(s.iter().count(), 0);
476    }
477}