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)]
14pub struct Config {
15 pub metadata: bool,
17 pub equipment: bool,
19 pub effects: bool,
21 pub player_list: bool,
23 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#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41pub enum Event {
42 Spawned(i32),
44 Removed {
46 id: i32,
48 ty: EntityType,
50 },
51 Moved(i32),
53 Velocity(i32),
55 Status {
57 id: i32,
59 status: i8,
61 },
62 Metadata(i32),
64 Equipment(i32),
66 Effects(i32),
68 Mounted {
70 id: i32,
72 vehicle: Option<i32>,
74 },
75 Collected {
77 collected: i32,
79 collector: i32,
81 },
82 PlayerList,
84}
85
86#[derive(Clone, Debug, PartialEq, Eq)]
88pub struct PlayerInfo {
89 pub name: Box<str>,
91 pub game_mode: i32,
93 pub ping: i32,
95 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#[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 pub(crate) any_leash: bool,
140 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 #[inline]
154 #[must_use]
155 pub fn get(&self, id: i32) -> Option<&Entity> {
156 self.map.get(&id)
157 }
158
159 #[must_use]
161 pub fn len(&self) -> usize {
162 self.map.len()
163 }
164
165 #[must_use]
167 pub fn is_empty(&self) -> bool {
168 self.map.is_empty()
169 }
170
171 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 #[must_use]
180 pub fn self_id(&self) -> Option<i32> {
181 self.self_id
182 }
183
184 #[must_use]
186 pub fn me(&self) -> Option<&Entity> {
187 self.map.get(&self.self_id?)
188 }
189
190 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 pub fn near(&self, p: [f64; 3], radius: f64) -> impl Iterator<Item = &Entity> {
201 self.within(p, radius)
202 }
203
204 #[must_use]
206 pub fn player_info(&self, uuid: &Uuid) -> Option<&PlayerInfo> {
207 self.players.get(uuid)
208 }
209
210 pub fn players(&self) -> impl Iterator<Item = (&Uuid, &PlayerInfo)> {
212 self.players.iter()
213 }
214
215 #[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 #[must_use]
226 pub fn config(&self) -> Config {
227 self.config
228 }
229
230 pub fn drain_events(&mut self) -> std::vec::Drain<'_, Event> {
232 self.events.drain(..)
233 }
234
235 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 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 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 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 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 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 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 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)); 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))); 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}