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}
37
38impl Config {
39 #[must_use]
41 pub const fn with_metadata(mut self, on: bool) -> Self {
42 self.metadata = on;
43 self
44 }
45
46 #[must_use]
48 pub const fn with_equipment(mut self, on: bool) -> Self {
49 self.equipment = on;
50 self
51 }
52
53 #[must_use]
55 pub const fn with_effects(mut self, on: bool) -> Self {
56 self.effects = on;
57 self
58 }
59
60 #[must_use]
62 pub const fn with_player_list(mut self, on: bool) -> Self {
63 self.player_list = on;
64 self
65 }
66
67 #[must_use]
69 pub const fn with_events(mut self, on: bool) -> Self {
70 self.events = on;
71 self
72 }
73
74 #[must_use]
76 pub const fn with_skins(mut self, on: bool) -> Self {
77 self.skins = on;
78 self
79 }
80}
81
82impl Default for Config {
83 fn default() -> Self {
84 Config {
85 metadata: true,
86 equipment: true,
87 effects: true,
88 player_list: true,
89 events: false,
90 skins: false,
91 }
92 }
93}
94
95#[derive(Clone, Copy, Debug, PartialEq, Eq)]
97#[non_exhaustive]
98pub enum Event {
99 Spawned(i32),
101 Removed {
103 id: i32,
105 ty: EntityType,
107 },
108 Moved(i32),
110 Velocity(i32),
112 Status {
114 id: i32,
116 status: i8,
118 },
119 Metadata(i32),
121 Equipment(i32),
123 Effects(i32),
125 Mounted {
127 id: i32,
129 vehicle: Option<i32>,
131 },
132 Collected {
134 collected: i32,
136 collector: i32,
138 },
139 PlayerList,
141}
142
143#[derive(Clone, Debug, PartialEq, Eq)]
145#[non_exhaustive]
146pub struct PlayerInfo {
147 pub name: Box<str>,
149 pub game_mode: i32,
151 pub ping: i32,
153 pub display_name: Option<Box<str>>,
155 pub textures: Option<Box<str>>,
158}
159
160#[derive(Default, Clone, Copy)]
161pub(crate) struct IdHasher(u64);
162
163impl Hasher for IdHasher {
164 #[inline]
165 fn finish(&self) -> u64 {
166 let h = self.0.wrapping_mul(0x9E37_79B9_7F4A_7C15);
167 h ^ (h >> 29)
168 }
169
170 #[inline]
171 fn write(&mut self, bytes: &[u8]) {
172 for &b in bytes {
173 self.0 = (self.0 << 8) | u64::from(b);
174 }
175 }
176
177 #[inline]
178 fn write_i32(&mut self, v: i32) {
179 self.0 = u64::from(v as u32);
180 }
181
182 #[inline]
183 fn write_u128(&mut self, v: u128) {
184 self.0 = (v as u64) ^ ((v >> 64) as u64);
185 }
186}
187
188type Fast<K, V> = HashMap<K, V, BuildHasherDefault<IdHasher>>;
189
190#[derive(Clone, Debug, Default)]
192pub struct Entities {
193 pub(crate) map: Fast<i32, Entity>,
194 pub(crate) self_id: Option<i32>,
195 pub(crate) config: Config,
196 pub(crate) events: Vec<Event>,
197 pub(crate) players: Fast<Uuid, PlayerInfo>,
198 pub(crate) scratch: Vec<(u8, MetaValue)>,
199 pub(crate) any_leash: bool,
201 pub(crate) era: crate::entity::Era,
203}
204
205impl Entities {
206 pub(crate) fn new(config: Config) -> Self {
207 Entities {
208 config,
209 ..Default::default()
210 }
211 }
212
213 #[inline]
215 #[must_use]
216 pub fn get(&self, id: i32) -> Option<&Entity> {
217 self.map.get(&id)
218 }
219
220 #[must_use]
222 pub fn len(&self) -> usize {
223 self.map.len()
224 }
225
226 #[must_use]
228 pub fn is_empty(&self) -> bool {
229 self.map.is_empty()
230 }
231
232 pub fn iter(&self) -> impl Iterator<Item = &Entity> {
234 let me = self.self_id;
235 self.map.values().filter(move |e| Some(e.id) != me)
236 }
237
238 #[must_use]
241 pub fn self_id(&self) -> Option<i32> {
242 self.self_id
243 }
244
245 #[must_use]
247 pub fn me(&self) -> Option<&Entity> {
248 self.map.get(&self.self_id?)
249 }
250
251 pub fn within(&self, p: [f64; 3], radius: f64) -> impl Iterator<Item = &Entity> {
253 let r2 = radius * radius;
254 self.iter().filter(move |e| {
255 let d = [e.pos[0] - p[0], e.pos[1] - p[1], e.pos[2] - p[2]];
256 d[0] * d[0] + d[1] * d[1] + d[2] * d[2] <= r2
257 })
258 }
259
260 pub fn near(&self, p: [f64; 3], radius: f64) -> impl Iterator<Item = &Entity> {
262 self.within(p, radius)
263 }
264
265 #[must_use]
267 pub fn player_info(&self, uuid: &Uuid) -> Option<&PlayerInfo> {
268 self.players.get(uuid)
269 }
270
271 pub fn players(&self) -> impl Iterator<Item = (&Uuid, &PlayerInfo)> {
273 self.players.iter()
274 }
275
276 #[must_use]
278 pub fn player_name(&self, id: i32) -> Option<&str> {
279 let e = self.map.get(&id)?;
280 e.is_player()
281 .then(|| self.players.get(&e.uuid).map(|p| &*p.name))
282 .flatten()
283 }
284
285 #[must_use]
287 pub fn config(&self) -> Config {
288 self.config
289 }
290
291 pub fn drain_events(&mut self) -> std::vec::Drain<'_, Event> {
293 self.events.drain(..)
294 }
295
296 pub fn clear(&mut self) {
298 if self.config.events {
299 let me = self.self_id;
300 self.events.extend(
301 self.map
302 .values()
303 .filter(|e| Some(e.id) != me)
304 .map(|e| Event::Removed { id: e.id, ty: e.ty }),
305 );
306 }
307 let me = self.self_id.and_then(|id| self.map.remove(&id));
308 self.map.clear();
309 if let Some(mut me) = me {
310 me.vehicle = None;
311 me.passengers.clear();
312 me.leash_holder = None;
313 self.map.insert(me.id, me);
314 }
315 }
316
317 #[inline]
318 pub(crate) fn event(&mut self, e: Event) {
319 if self.config.events {
320 self.events.push(e);
321 }
322 }
323
324 pub(crate) fn set_self(&mut self, id: i32) {
325 if let Some(old) = self.self_id {
326 self.map.remove(&old);
327 }
328 self.self_id = Some(id);
329 let mut me = Entity::new(id, EntityType::Player);
330 self.resolve(&mut me);
331 self.map.insert(id, me);
332 }
333
334 fn resolve(&self, e: &mut Entity) {
336 use crate::entity::Era;
337 e.era = self.era;
338 e.sizer = match self.era {
339 Era::V1_8 => crate::v1_8::vanilla_size(e),
340 Era::V1_12 => crate::v1_12::vanilla_size(e),
341 Era::V1_16 => crate::v1_16_5::vanilla_size(e),
342 };
343 }
344
345 pub(crate) fn spawn(&mut self, mut e: Entity) {
347 let id = e.id;
348 self.resolve(&mut e);
349 if Some(id) == self.self_id {
350 return;
351 }
352 if self.map.contains_key(&id) {
353 self.unlink(id);
354 }
355 self.map.insert(id, e);
356 self.event(Event::Spawned(id));
357 }
358
359 pub(crate) fn remove(&mut self, id: i32) -> bool {
360 if Some(id) == self.self_id || !self.map.contains_key(&id) {
361 return false;
362 }
363 self.unlink(id);
364 if let Some(e) = self.map.remove(&id) {
365 self.event(Event::Removed { id, ty: e.ty });
366 }
367 true
368 }
369
370 fn unlink(&mut self, id: i32) {
372 let Some(e) = self.map.get_mut(&id) else {
373 return;
374 };
375 let vehicle = e.vehicle.take();
376 let passengers = std::mem::take(&mut e.passengers);
377 if let Some(v) = vehicle
378 && let Some(v) = self.map.get_mut(&v)
379 {
380 v.passengers.retain(|&p| p != id);
381 }
382 for p in passengers {
383 if let Some(p) = self.map.get_mut(&p)
384 && p.vehicle == Some(id)
385 {
386 p.vehicle = None;
387 }
388 }
389 if self.any_leash {
390 for other in self.map.values_mut() {
391 if other.leash_holder == Some(id) {
392 other.leash_holder = None;
393 }
394 }
395 }
396 }
397
398 fn rides(&self, vehicle: i32, rider: i32) -> bool {
400 let mut cur = Some(vehicle);
401 let mut guard = 0;
402 while let Some(c) = cur {
403 if c == rider {
404 return true;
405 }
406 guard += 1;
407 if guard > 64 {
408 return true;
409 }
410 cur = self.map.get(&c).and_then(|e| e.vehicle);
411 }
412 false
413 }
414
415 pub(crate) fn mount(&mut self, rider: i32, vehicle: Option<i32>, single: bool) -> bool {
418 if !self.map.contains_key(&rider) {
419 return false;
420 }
421 if let Some(v) = vehicle
422 && (!self.map.contains_key(&v) || self.rides(v, rider))
423 {
424 return false;
425 }
426 let old = self.map.get_mut(&rider).and_then(|e| e.vehicle.take());
428 if let Some(o) = old
429 && let Some(o) = self.map.get_mut(&o)
430 {
431 o.passengers.retain(|&p| p != rider);
432 }
433 if let Some(v) = vehicle {
434 let prev: Vec<i32> = if single {
435 self.map
436 .get_mut(&v)
437 .map(|e| std::mem::take(&mut e.passengers))
438 .unwrap_or_default()
439 } else {
440 Vec::new()
441 };
442 for p in prev {
443 if let Some(p) = self.map.get_mut(&p) {
444 p.vehicle = None;
445 }
446 }
447 if let Some(ve) = self.map.get_mut(&v) {
448 ve.passengers.push(rider);
449 }
450 if let Some(r) = self.map.get_mut(&rider) {
451 r.vehicle = Some(v);
452 }
453 }
454 self.event(Event::Mounted { id: rider, vehicle });
455 true
456 }
457
458 pub(crate) fn set_passengers(&mut self, vehicle: i32, ids: impl Iterator<Item = i32>) -> bool {
460 let Some(v) = self.map.get_mut(&vehicle) else {
461 return false;
462 };
463 let old = std::mem::take(&mut v.passengers);
464 for p in &old {
465 if let Some(p) = self.map.get_mut(p)
466 && p.vehicle == Some(vehicle)
467 {
468 p.vehicle = None;
469 }
470 }
471 let mut old = old;
473 old.clear();
474 if let Some(v) = self.map.get_mut(&vehicle) {
475 v.passengers = old;
476 }
477 for id in ids {
478 self.mount(id, Some(vehicle), false);
479 }
480 true
481 }
482
483 pub(crate) fn leash(&mut self, id: i32, holder: Option<i32>) -> bool {
484 match self.map.get_mut(&id) {
485 Some(e) => {
486 e.leash_holder = holder;
487 self.any_leash |= holder.is_some();
488 true
489 }
490 None => false,
491 }
492 }
493}
494
495#[cfg(test)]
496mod tests {
497 use super::*;
498
499 fn store() -> Entities {
500 let mut s = Entities::new(Config {
501 events: true,
502 ..Config::default()
503 });
504 for id in 1..=4 {
505 s.spawn(Entity::new(id, EntityType::Registry(6)));
506 }
507 s
508 }
509
510 #[test]
511 fn mount_single_and_multi() {
512 let mut s = store();
513 assert!(s.mount(1, Some(2), true));
514 assert!(s.mount(3, Some(2), true)); assert_eq!(s.get(2).unwrap().passengers(), &[3]);
516 assert_eq!(s.get(1).unwrap().vehicle(), None);
517 assert!(!s.mount(2, Some(3), true), "cycle");
518 assert!(s.set_passengers(4, [1, 3].into_iter()));
519 assert_eq!(s.get(4).unwrap().passengers(), &[1, 3]);
520 assert_eq!(s.get(2).unwrap().passengers(), &[] as &[i32]);
521 assert_eq!(s.get(3).unwrap().vehicle(), Some(4));
522 s.remove(4);
523 assert_eq!(s.get(1).unwrap().vehicle(), None);
524 assert_eq!(s.get(3).unwrap().vehicle(), None);
525 }
526
527 #[test]
528 fn self_entry_survives_clear() {
529 let mut s = store();
530 s.set_self(9);
531 s.spawn(Entity::new(9, EntityType::Registry(1))); assert_eq!(s.get(9).unwrap().entity_type(), EntityType::Player);
533 assert!(!s.remove(9));
534 s.drain_events().for_each(drop);
535 s.clear();
536 assert_eq!(s.len(), 1);
537 assert!(s.me().is_some());
538 assert_eq!(s.drain_events().count(), 4);
539 assert_eq!(s.iter().count(), 0);
540 }
541}