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,
pub player_names: 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
}
#[must_use]
pub const fn with_player_names(mut self, on: bool) -> Self {
self.player_names = on;
self
}
#[must_use]
pub const fn reads_tab_list(&self) -> bool {
self.player_list || self.player_names
}
}
impl Default for Config {
fn default() -> Self {
Config {
metadata: true,
equipment: true,
effects: true,
player_list: true,
events: false,
skins: false,
player_names: 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>>,
pub display_name_nbt: Option<bytes::Bytes>,
pub listed: bool,
pub list_order: i32,
pub(crate) generation: u32,
}
#[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_u64(&mut self, v: u64) {
self.0 = v;
}
#[inline]
fn write_u128(&mut self, v: u128) {
self.0 = (v as u64) ^ ((v >> 64) as u64);
}
}
pub(crate) type Fast<K, V> = HashMap<K, V, BuildHasherDefault<IdHasher>>;
#[inline]
pub(crate) fn shrink_map<K: Eq + std::hash::Hash, V>(m: &mut Fast<K, V>) {
let cap = m.capacity();
if cap > 64 && m.len() * 4 < cap {
m.shrink_to(m.len() * 2);
}
}
#[inline]
pub(crate) fn after_insert<K: Eq + std::hash::Hash, V>(m: &mut Fast<K, V>, old_cap: usize) {
let cap = m.capacity();
if cap >= 2 * old_cap.max(1) && m.len() * 2 <= cap {
compact(m);
}
}
#[cold]
#[inline(never)]
fn compact<K: Eq + std::hash::Hash, V>(m: &mut Fast<K, V>) {
m.shrink_to(m.len());
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct TabLite {
name: [u8; TabLite::INLINE],
len: u8,
pub(crate) game_mode: i32,
pub(crate) generation: u32,
}
impl TabLite {
const INLINE: usize = 23;
const LONG: u8 = u8::MAX;
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct TabRef<'a> {
pub(crate) name: &'a str,
pub(crate) game_mode: i32,
pub(crate) generation: u32,
}
#[derive(Clone, Copy)]
pub(crate) struct Tabs<'a> {
pub(crate) players: &'a Fast<Uuid, PlayerInfo>,
pub(crate) lite: &'a Fast<Uuid, TabLite>,
pub(crate) long_names: &'a Fast<Uuid, Box<str>>,
}
impl<'a> Tabs<'a> {
#[inline]
pub(crate) fn get(self, uuid: &Uuid) -> Option<TabRef<'a>> {
if let Some(p) = self.players.get(uuid) {
return Some(TabRef {
name: &p.name,
game_mode: p.game_mode,
generation: p.generation,
});
}
if self.lite.is_empty() {
return None;
}
let t = self.lite.get(uuid)?;
let name = if t.len == TabLite::LONG {
self.long_names.get(uuid).map_or("", |n| &**n)
} else {
std::str::from_utf8(&t.name[..usize::from(t.len)]).unwrap_or("")
};
Some(TabRef {
name,
game_mode: t.game_mode,
generation: t.generation,
})
}
}
#[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) lite: Fast<Uuid, TabLite>,
pub(crate) long_names: Fast<Uuid, Box<str>>,
pub(crate) scratch: Vec<(u8, MetaValue)>,
pub(crate) any_leash: bool,
pub(crate) era: crate::entity::Era,
pub(crate) generations: u32,
}
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.tab(&e.uuid).map(|t| t.name))
.flatten()
}
#[must_use]
pub fn tab_name(&self, uuid: &Uuid) -> Option<&str> {
self.tab(uuid).map(|t| t.name)
}
#[must_use]
pub fn tab_game_mode(&self, uuid: &Uuid) -> Option<i32> {
self.tab(uuid).map(|t| t.game_mode)
}
#[must_use]
pub fn tab_len(&self) -> usize {
self.players.len() + self.lite.len()
}
#[inline]
pub(crate) fn lite_mode(&self) -> bool {
!self.config.player_list && self.config.player_names
}
#[inline]
pub(crate) fn tab(&self, uuid: &Uuid) -> Option<TabRef<'_>> {
self.tabs().get(uuid)
}
#[inline]
pub(crate) fn tabs(&self) -> Tabs<'_> {
Tabs {
players: &self.players,
lite: &self.lite,
long_names: &self.long_names,
}
}
#[inline]
pub(crate) fn tab_has(&self, uuid: &Uuid) -> bool {
self.players.contains_key(uuid) || self.lite.contains_key(uuid)
}
pub(crate) fn lite_add(
&mut self,
uuid: Uuid,
name: &str,
game_mode: i32,
generation: u32,
replace: bool,
) -> bool {
if !replace && self.lite.contains_key(&uuid) {
return false;
}
let mut t = TabLite {
name: [0; TabLite::INLINE],
len: TabLite::LONG,
game_mode,
generation,
};
if name.len() <= TabLite::INLINE {
t.name[..name.len()].copy_from_slice(name.as_bytes());
t.len = name.len() as u8;
if self.long_names.remove(&uuid).is_some() {
shrink_map(&mut self.long_names);
}
} else {
self.long_names.insert(uuid, Box::from(name));
}
let cap = self.lite.capacity();
self.lite.insert(uuid, t);
after_insert(&mut self.lite, cap);
true
}
pub(crate) fn tab_remove(&mut self, uuid: &Uuid) -> Option<(i32, u32)> {
if let Some(p) = self.players.remove(uuid) {
shrink_map(&mut self.players);
return Some((p.game_mode, p.generation));
}
let t = self.lite.remove(uuid)?;
if t.len == TabLite::LONG && self.long_names.remove(uuid).is_some() {
shrink_map(&mut self.long_names);
}
shrink_map(&mut self.lite);
Some((t.game_mode, t.generation))
}
#[inline]
pub(crate) fn lite_game_mode(&mut self, uuid: &Uuid, game_mode: i32) {
if let Some(t) = self.lite.get_mut(uuid) {
t.game_mode = game_mode;
}
}
#[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();
shrink_map(&mut self.map);
if let Some(mut me) = me {
me.set_vehicle(None);
if let Some(l) = &mut me.links {
l.passengers.clear();
l.leash_holder = None;
}
me.tidy_links();
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 {
#[cfg(feature = "v1_8")]
Era::V1_8 => crate::v1_8::vanilla_size(e),
#[cfg(feature = "v1_12")]
Era::V1_12 => crate::v1_12::vanilla_size(e),
#[cfg(feature = "v1_16_5")]
Era::V1_16 => crate::v1_16_5::vanilla_size(e),
#[cfg(feature = "v26_1")]
Era::V26 => crate::v26_1::vanilla_size(e),
#[cfg(feature = "v26_2")]
Era::V26_2 => crate::v26_2::vanilla_size(e),
#[allow(unreachable_patterns)]
_ => None,
};
}
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);
}
let cap = self.map.capacity();
self.map.insert(id, e);
after_insert(&mut self.map, cap);
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 });
}
shrink_map(&mut self.map);
true
}
fn unlink(&mut self, id: i32) {
let Some(e) = self.map.get_mut(&id) else {
return;
};
if e.links.is_none() && !e.rides && !self.any_leash {
return;
}
let vehicle = e.take_vehicle();
let passengers = e.take_passengers();
if let Some(v) = vehicle
&& let Some(v) = self.map.get_mut(&v)
{
v.remove_passenger(id);
}
for p in passengers {
if let Some(p) = self.map.get_mut(&p)
&& p.vehicle() == Some(id)
{
p.set_vehicle(None);
}
}
if self.any_leash {
for other in self.map.values_mut() {
if other.leash_holder() == Some(id) {
other.set_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(Entity::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(Entity::take_vehicle);
if let Some(o) = old
&& let Some(o) = self.map.get_mut(&o)
{
o.remove_passenger(rider);
}
if let Some(v) = vehicle {
let prev: Vec<i32> = if single {
self.map
.get_mut(&v)
.map(Entity::take_passengers)
.unwrap_or_default()
} else {
Vec::new()
};
for p in prev {
if let Some(p) = self.map.get_mut(&p) {
p.set_vehicle(None);
}
}
if let Some(ve) = self.map.get_mut(&v) {
ve.push_passenger(rider);
}
if let Some(r) = self.map.get_mut(&rider) {
r.set_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 = v.take_passengers();
for p in &old {
if let Some(p) = self.map.get_mut(p)
&& p.vehicle() == Some(vehicle)
{
p.set_vehicle(None);
}
}
let mut old = old;
old.clear();
if let Some(v) = self.map.get_mut(&vehicle) {
v.set_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.set_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 entity_size() {
let n = std::mem::size_of::<Entity>();
eprintln!("size_of::<Entity>() = {n}");
let modern = cfg!(any(feature = "v26_1", feature = "v26_2"));
assert!(n <= if modern { 168 } else { 160 }, "{n}");
#[cfg(any(feature = "v26_1", feature = "v26_2"))]
{
let b = std::mem::size_of::<crate::modern_state::State>();
eprintln!("size_of::<modern_state::State>() = {b} (heap, 26.x entities only)");
assert!(b <= 120, "{b}");
}
}
#[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);
}
}