use std::collections::HashMap;
use std::hash::{BuildHasherDefault, Hasher};
use uuid::Uuid;
use crate::entity::{Entity, EntityType, MetaValue};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct Config {
pub metadata: bool,
pub equipment: bool,
pub effects: bool,
pub player_list: bool,
pub events: bool,
pub skins: bool,
}
impl Config {
#[must_use]
pub const fn with_metadata(mut self, on: bool) -> Self {
self.metadata = on;
self
}
#[must_use]
pub const fn with_equipment(mut self, on: bool) -> Self {
self.equipment = on;
self
}
#[must_use]
pub const fn with_effects(mut self, on: bool) -> Self {
self.effects = on;
self
}
#[must_use]
pub const fn with_player_list(mut self, on: bool) -> Self {
self.player_list = on;
self
}
#[must_use]
pub const fn with_events(mut self, on: bool) -> Self {
self.events = on;
self
}
#[must_use]
pub const fn with_skins(mut self, on: bool) -> Self {
self.skins = on;
self
}
}
impl Default for Config {
fn default() -> Self {
Config {
metadata: true,
equipment: true,
effects: true,
player_list: true,
events: false,
skins: false,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum Event {
Spawned(i32),
Removed {
id: i32,
ty: EntityType,
},
Moved(i32),
Velocity(i32),
Status {
id: i32,
status: i8,
},
Metadata(i32),
Equipment(i32),
Effects(i32),
Mounted {
id: i32,
vehicle: Option<i32>,
},
Collected {
collected: i32,
collector: i32,
},
PlayerList,
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct PlayerInfo {
pub name: Box<str>,
pub game_mode: i32,
pub ping: i32,
pub display_name: Option<Box<str>>,
pub textures: Option<Box<str>>,
}
#[derive(Default, Clone, Copy)]
pub(crate) struct IdHasher(u64);
impl Hasher for IdHasher {
#[inline]
fn finish(&self) -> u64 {
let h = self.0.wrapping_mul(0x9E37_79B9_7F4A_7C15);
h ^ (h >> 29)
}
#[inline]
fn write(&mut self, bytes: &[u8]) {
for &b in bytes {
self.0 = (self.0 << 8) | u64::from(b);
}
}
#[inline]
fn write_i32(&mut self, v: i32) {
self.0 = u64::from(v as u32);
}
#[inline]
fn write_u128(&mut self, v: u128) {
self.0 = (v as u64) ^ ((v >> 64) as u64);
}
}
type Fast<K, V> = HashMap<K, V, BuildHasherDefault<IdHasher>>;
#[derive(Clone, Debug, Default)]
pub struct Entities {
pub(crate) map: Fast<i32, Entity>,
pub(crate) self_id: Option<i32>,
pub(crate) config: Config,
pub(crate) events: Vec<Event>,
pub(crate) players: Fast<Uuid, PlayerInfo>,
pub(crate) scratch: Vec<(u8, MetaValue)>,
pub(crate) any_leash: bool,
pub(crate) era: crate::entity::Era,
}
impl Entities {
pub(crate) fn new(config: Config) -> Self {
Entities {
config,
..Default::default()
}
}
#[inline]
#[must_use]
pub fn get(&self, id: i32) -> Option<&Entity> {
self.map.get(&id)
}
#[must_use]
pub fn len(&self) -> usize {
self.map.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.map.is_empty()
}
pub fn iter(&self) -> impl Iterator<Item = &Entity> {
let me = self.self_id;
self.map.values().filter(move |e| Some(e.id) != me)
}
#[must_use]
pub fn self_id(&self) -> Option<i32> {
self.self_id
}
#[must_use]
pub fn me(&self) -> Option<&Entity> {
self.map.get(&self.self_id?)
}
pub fn within(&self, p: [f64; 3], radius: f64) -> impl Iterator<Item = &Entity> {
let r2 = radius * radius;
self.iter().filter(move |e| {
let d = [e.pos[0] - p[0], e.pos[1] - p[1], e.pos[2] - p[2]];
d[0] * d[0] + d[1] * d[1] + d[2] * d[2] <= r2
})
}
pub fn near(&self, p: [f64; 3], radius: f64) -> impl Iterator<Item = &Entity> {
self.within(p, radius)
}
#[must_use]
pub fn player_info(&self, uuid: &Uuid) -> Option<&PlayerInfo> {
self.players.get(uuid)
}
pub fn players(&self) -> impl Iterator<Item = (&Uuid, &PlayerInfo)> {
self.players.iter()
}
#[must_use]
pub fn player_name(&self, id: i32) -> Option<&str> {
let e = self.map.get(&id)?;
e.is_player()
.then(|| self.players.get(&e.uuid).map(|p| &*p.name))
.flatten()
}
#[must_use]
pub fn config(&self) -> Config {
self.config
}
pub fn drain_events(&mut self) -> std::vec::Drain<'_, Event> {
self.events.drain(..)
}
pub fn clear(&mut self) {
if self.config.events {
let me = self.self_id;
self.events.extend(
self.map
.values()
.filter(|e| Some(e.id) != me)
.map(|e| Event::Removed { id: e.id, ty: e.ty }),
);
}
let me = self.self_id.and_then(|id| self.map.remove(&id));
self.map.clear();
if let Some(mut me) = me {
me.vehicle = None;
me.passengers.clear();
me.leash_holder = None;
self.map.insert(me.id, me);
}
}
#[inline]
pub(crate) fn event(&mut self, e: Event) {
if self.config.events {
self.events.push(e);
}
}
pub(crate) fn set_self(&mut self, id: i32) {
if let Some(old) = self.self_id {
self.map.remove(&old);
}
self.self_id = Some(id);
let mut me = Entity::new(id, EntityType::Player);
self.resolve(&mut me);
self.map.insert(id, me);
}
fn resolve(&self, e: &mut Entity) {
use crate::entity::Era;
e.era = self.era;
e.sizer = match self.era {
Era::V1_8 => crate::v1_8::vanilla_size(e),
Era::V1_12 => crate::v1_12::vanilla_size(e),
Era::V1_16 => crate::v1_16_5::vanilla_size(e),
};
}
pub(crate) fn spawn(&mut self, mut e: Entity) {
let id = e.id;
self.resolve(&mut e);
if Some(id) == self.self_id {
return;
}
if self.map.contains_key(&id) {
self.unlink(id);
}
self.map.insert(id, e);
self.event(Event::Spawned(id));
}
pub(crate) fn remove(&mut self, id: i32) -> bool {
if Some(id) == self.self_id || !self.map.contains_key(&id) {
return false;
}
self.unlink(id);
if let Some(e) = self.map.remove(&id) {
self.event(Event::Removed { id, ty: e.ty });
}
true
}
fn unlink(&mut self, id: i32) {
let Some(e) = self.map.get_mut(&id) else {
return;
};
let vehicle = e.vehicle.take();
let passengers = std::mem::take(&mut e.passengers);
if let Some(v) = vehicle
&& let Some(v) = self.map.get_mut(&v)
{
v.passengers.retain(|&p| p != id);
}
for p in passengers {
if let Some(p) = self.map.get_mut(&p)
&& p.vehicle == Some(id)
{
p.vehicle = None;
}
}
if self.any_leash {
for other in self.map.values_mut() {
if other.leash_holder == Some(id) {
other.leash_holder = None;
}
}
}
}
fn rides(&self, vehicle: i32, rider: i32) -> bool {
let mut cur = Some(vehicle);
let mut guard = 0;
while let Some(c) = cur {
if c == rider {
return true;
}
guard += 1;
if guard > 64 {
return true;
}
cur = self.map.get(&c).and_then(|e| e.vehicle);
}
false
}
pub(crate) fn mount(&mut self, rider: i32, vehicle: Option<i32>, single: bool) -> bool {
if !self.map.contains_key(&rider) {
return false;
}
if let Some(v) = vehicle
&& (!self.map.contains_key(&v) || self.rides(v, rider))
{
return false;
}
let old = self.map.get_mut(&rider).and_then(|e| e.vehicle.take());
if let Some(o) = old
&& let Some(o) = self.map.get_mut(&o)
{
o.passengers.retain(|&p| p != rider);
}
if let Some(v) = vehicle {
let prev: Vec<i32> = if single {
self.map
.get_mut(&v)
.map(|e| std::mem::take(&mut e.passengers))
.unwrap_or_default()
} else {
Vec::new()
};
for p in prev {
if let Some(p) = self.map.get_mut(&p) {
p.vehicle = None;
}
}
if let Some(ve) = self.map.get_mut(&v) {
ve.passengers.push(rider);
}
if let Some(r) = self.map.get_mut(&rider) {
r.vehicle = Some(v);
}
}
self.event(Event::Mounted { id: rider, vehicle });
true
}
pub(crate) fn set_passengers(&mut self, vehicle: i32, ids: impl Iterator<Item = i32>) -> bool {
let Some(v) = self.map.get_mut(&vehicle) else {
return false;
};
let old = std::mem::take(&mut v.passengers);
for p in &old {
if let Some(p) = self.map.get_mut(p)
&& p.vehicle == Some(vehicle)
{
p.vehicle = None;
}
}
let mut old = old;
old.clear();
if let Some(v) = self.map.get_mut(&vehicle) {
v.passengers = old;
}
for id in ids {
self.mount(id, Some(vehicle), false);
}
true
}
pub(crate) fn leash(&mut self, id: i32, holder: Option<i32>) -> bool {
match self.map.get_mut(&id) {
Some(e) => {
e.leash_holder = holder;
self.any_leash |= holder.is_some();
true
}
None => false,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn store() -> Entities {
let mut s = Entities::new(Config {
events: true,
..Config::default()
});
for id in 1..=4 {
s.spawn(Entity::new(id, EntityType::Registry(6)));
}
s
}
#[test]
fn mount_single_and_multi() {
let mut s = store();
assert!(s.mount(1, Some(2), true));
assert!(s.mount(3, Some(2), true)); assert_eq!(s.get(2).unwrap().passengers(), &[3]);
assert_eq!(s.get(1).unwrap().vehicle(), None);
assert!(!s.mount(2, Some(3), true), "cycle");
assert!(s.set_passengers(4, [1, 3].into_iter()));
assert_eq!(s.get(4).unwrap().passengers(), &[1, 3]);
assert_eq!(s.get(2).unwrap().passengers(), &[] as &[i32]);
assert_eq!(s.get(3).unwrap().vehicle(), Some(4));
s.remove(4);
assert_eq!(s.get(1).unwrap().vehicle(), None);
assert_eq!(s.get(3).unwrap().vehicle(), None);
}
#[test]
fn self_entry_survives_clear() {
let mut s = store();
s.set_self(9);
s.spawn(Entity::new(9, EntityType::Registry(1))); assert_eq!(s.get(9).unwrap().entity_type(), EntityType::Player);
assert!(!s.remove(9));
s.drain_events().for_each(drop);
s.clear();
assert_eq!(s.len(), 1);
assert!(s.me().is_some());
assert_eq!(s.drain_events().count(), 4);
assert_eq!(s.iter().count(), 0);
}
}