use std::collections::HashSet;
use std::sync::Arc;
use rustc_hash::FxHashMap;
use crate::error::{Error, Result};
use crate::io::BitReader;
use crate::limits::DecodeLimits;
use super::class_info::ClassInfo;
use super::field_decoder::FieldDecodeContext;
use super::field_path::{self, FieldPath};
use super::field_value::FieldValue;
use super::properties::{ClassProperties, PropertyFilter};
use super::serializer_bindings::SerializerBindings;
use super::serializers::{Serializer, SerializerContainer, SerializerField};
use super::string_tables::StringTableContainer;
const MAX_EDICT_BITS: u32 = 14;
const NUM_ENT_ENTRY_BITS: u32 = MAX_EDICT_BITS + 1;
const NUM_SERIAL_NUM_BITS: u32 = 32 - NUM_ENT_ENTRY_BITS;
const MAX_ENTITY_INDEX: i64 = (1_i64 << MAX_EDICT_BITS) - 1;
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub struct PacketEntities<'a> {
pub updated_entries: i32,
pub entity_data: &'a [u8],
pub has_pvs_vis_bits: u32,
}
impl<'a> PacketEntities<'a> {
pub const fn new(updated_entries: i32, entity_data: &'a [u8], has_pvs_vis_bits: u32) -> Self {
Self {
updated_entries,
entity_data,
has_pvs_vis_bits,
}
}
}
pub const ENTITY_HANDLE_INDEX_MASK: u32 = 0x3FFF;
pub const INVALID_ENTITY_HANDLE: u32 = 0x00FF_FFFF;
pub fn protobuf_handle_index(handle: Option<u32>) -> Option<i32> {
handle
.filter(|&h| h != INVALID_ENTITY_HANDLE)
.map(|h| (h & ENTITY_HANDLE_INDEX_MASK) as i32)
}
pub(super) fn resolve_field_path<'a>(
serializer: &'a Serializer,
fp: &FieldPath,
) -> Result<&'a SerializerField> {
let oob = || Error::Parse {
context: format!(
"field path out of range for serializer '{}' ({} fields)",
serializer.name,
serializer.fields.len()
),
};
let mut field = serializer.fields.get(fp.get(0)).ok_or_else(oob)?;
for i in 1..=fp.last {
let idx = fp.get(i);
if field.is_dynamic_array() {
match field.field_serializer.as_ref() {
Some(fs) => field = fs.fields.first().ok_or_else(oob)?,
None => break,
}
} else if let Some(fs) = field.field_serializer.as_ref() {
field = fs.fields.get(idx).ok_or_else(oob)?;
} else {
break;
}
}
Ok(field)
}
const CMD_LEAVE: u8 = 0x01;
const CMD_CREATE_DELETE: u8 = 0x02;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[non_exhaustive]
pub struct EntityId {
pub index: i32,
pub serial: u32,
}
impl EntityId {
pub const fn new(index: i32, serial: u32) -> Self {
Self { index, serial }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[non_exhaustive]
pub enum EntityChangeKind {
Created,
Updated,
Reactivated,
LeftPvs,
Deleted,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
#[non_exhaustive]
pub struct EntityChange {
pub kind: EntityChangeKind,
pub index: i32,
pub serial: u32,
pub class_id: i32,
pub class_name: Arc<str>,
}
impl EntityChange {
fn from_entity(kind: EntityChangeKind, entity: &Entity) -> Self {
Self {
kind,
index: entity.index,
serial: entity.serial,
class_id: entity.class_id,
class_name: Arc::clone(&entity.class_name),
}
}
pub const fn id(&self) -> EntityId {
EntityId::new(self.index, self.serial)
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct Entity {
pub index: i32,
pub serial: u32,
pub class_id: i32,
pub class_name: Arc<str>,
pub active: bool,
pub fields: FxHashMap<u64, FieldValue>,
}
impl Entity {
pub const fn id(&self) -> EntityId {
EntityId::new(self.index, self.serial)
}
pub fn from_fields(
index: i32,
serial: u32,
class_id: i32,
class_name: impl Into<Arc<str>>,
active: bool,
fields: FxHashMap<u64, FieldValue>,
) -> Result<Self> {
if !(0..=MAX_ENTITY_INDEX as i32).contains(&index) {
return Err(Error::Parse {
context: format!("entity index {index} out of range"),
});
}
Ok(Self {
index,
serial,
class_id,
class_name: class_name.into(),
active,
fields,
})
}
fn new(index: i32, class_id: i32, class_name: Arc<str>) -> Self {
Self {
index,
serial: 0,
class_id,
class_name,
active: true,
fields: FxHashMap::default(),
}
}
#[allow(clippy::needless_range_loop)]
fn apply_update<const PROJECTED: bool>(
&mut self,
br: &mut BitReader,
serializer: &Serializer,
ctx: &mut FieldDecodeContext,
fp_buf: &mut Vec<FieldPath>,
properties: Option<&ClassProperties>,
) -> Result<()> {
if PROJECTED && properties.is_none() {
return self.apply_update::<false>(br, serializer, ctx, fp_buf, None);
}
let limits = ctx.limits();
field_path::read_field_paths_with_limits(br, fp_buf, &limits)?;
for fp_idx in 0..fp_buf.len() {
let field = resolve_field_path(serializer, &fp_buf[fp_idx])?;
let key = fp_buf[fp_idx].pack_decoded();
if PROJECTED && properties.is_some_and(|selected| !selected.retains(key, field)) {
field.metadata.decoder.skip(ctx, br).map_err(|error| Error::Parse {
context: format!("skipped field #{fp_idx} key={key:#x} (type: {}, decoder: {:?}, pos: {}, remaining: {}): {error}", field.var_type, field.metadata.decoder, br.position(), br.bits_remaining()),
})?;
continue;
}
let value = field
.metadata
.decoder
.decode(ctx, br)
.map_err(|e| Error::Parse {
context: format!(
"field #{} key={:#x} (type: {}, decoder: {:?}, pos: {}, remaining: {}): {}",
fp_idx,
key,
field.var_type,
field.metadata.decoder,
br.position(),
br.bits_remaining(),
e
),
})?;
let cutoff = if field.metadata.is_pointer() && matches!(value, FieldValue::Bool(false))
{
Some(0)
} else if field.is_dynamic_array() {
let count = u64::try_from(&value).map_err(|_| Error::Parse {
context: format!("invalid vector length at field {key:#x}"),
})?;
if self
.fields
.get(&key)
.and_then(|old| u64::try_from(old).ok())
.is_some_and(|old| old <= count)
{
None
} else {
Some(count)
}
} else {
None
};
if let Some(cutoff) = cutoff {
self.remove_descendants(key, cutoff);
}
if PROJECTED {
self.fields.entry(key).insert_entry(value);
} else {
self.fields.insert(key, value);
}
}
Ok(())
}
#[inline(never)]
fn remove_descendants(&mut self, key: u64, cutoff: u64) {
let retain = FieldPath::retain_after_shrink(key, cutoff);
self.fields.retain(|child_key, _| retain(*child_key));
}
#[allow(clippy::needless_range_loop)]
fn skip_update(
br: &mut BitReader,
serializer: &Serializer,
ctx: &mut FieldDecodeContext,
fp_buf: &mut Vec<FieldPath>,
) -> Result<()> {
let limits = ctx.limits();
field_path::read_field_paths_with_limits(br, fp_buf, &limits)?;
for fp_idx in 0..fp_buf.len() {
let field = resolve_field_path(serializer, &fp_buf[fp_idx])?;
field.metadata.decoder.skip(ctx, br)?;
}
Ok(())
}
pub fn field_value(&self, key: Option<u64>) -> Option<&FieldValue> {
key.and_then(|key| self.fields.get(&key))
}
pub fn try_get<T>(
&self,
key: Option<u64>,
) -> std::result::Result<Option<T>, crate::error::FieldValueConversionError>
where
for<'value> T: TryFrom<&'value FieldValue, Error = crate::error::FieldValueConversionError>,
{
self.field_value(key).map(T::try_from).transpose()
}
pub fn get_by_name(&self, path: &str, serializer: &Serializer) -> Option<&FieldValue> {
let key = serializer.resolve_field_key(path)?;
self.fields.get(&key)
}
pub fn get_i64(&self, key: Option<u64>) -> i64 {
key.and_then(|k| self.fields.get(&k))
.and_then(|v| match v {
FieldValue::U32(n) => Some(*n as i64),
FieldValue::U64(n) => Some(*n as i64),
FieldValue::I32(n) => Some(*n as i64),
FieldValue::I64(n) => Some(*n),
_ => None,
})
.unwrap_or(0)
}
pub fn get_u32(&self, key: Option<u64>) -> u32 {
key.and_then(|k| self.fields.get(&k))
.and_then(|v| match v {
FieldValue::U32(n) => Some(*n),
FieldValue::U64(n) => Some(*n as u32),
FieldValue::I32(n) => Some(*n as u32),
FieldValue::I64(n) => Some(*n as u32),
_ => None,
})
.unwrap_or(0)
}
pub fn get_f32(&self, key: Option<u64>) -> f32 {
key.and_then(|k| self.fields.get(&k))
.and_then(|v| match v {
FieldValue::F32(f) => Some(*f),
_ => None,
})
.unwrap_or(0.0)
}
pub fn get_bool(&self, key: Option<u64>) -> bool {
key.and_then(|k| self.fields.get(&k))
.and_then(|v| match v {
FieldValue::Bool(b) => Some(*b),
_ => None,
})
.unwrap_or(false)
}
pub fn get_qangle(&self, key: Option<u64>) -> [f32; 3] {
key.and_then(|k| self.fields.get(&k))
.and_then(|v| match v {
FieldValue::QAngle(a) => Some(*a),
_ => None,
})
.unwrap_or([0.0; 3])
}
pub fn get_vector3(&self, key: Option<u64>) -> [f32; 3] {
key.and_then(|k| self.fields.get(&k))
.and_then(|v| match v {
FieldValue::Vector3(v) => Some(*v),
FieldValue::FloatVector(v) if v.len() >= 3 => Some([v[0], v[1], v[2]]),
_ => None,
})
.unwrap_or([0.0; 3])
}
pub fn world_position(
&self,
cell_keys: [Option<u64>; 3],
offset_keys: [Option<u64>; 3],
) -> [f32; 3] {
let cell = [
self.get_i64(cell_keys[0]) as i32,
self.get_i64(cell_keys[1]) as i32,
self.get_i64(cell_keys[2]) as i32,
];
let offset = [
self.get_f32(offset_keys[0]),
self.get_f32(offset_keys[1]),
self.get_f32(offset_keys[2]),
];
[
crate::position::cell_to_world(cell[0], offset[0]),
crate::position::cell_to_world(cell[1], offset[1]),
crate::position::cell_to_world(cell[2], offset[2]),
]
}
pub fn get_handle(&self, key: Option<u64>) -> Option<u32> {
key.and_then(|k| self.fields.get(&k)).and_then(|v| match v {
FieldValue::U32(n) => Some(*n),
FieldValue::U64(n) => Some(*n as u32),
FieldValue::I32(n) => Some(*n as u32),
FieldValue::I64(n) => Some(*n as u32),
_ => None,
})
}
pub fn get_u64(&self, key: Option<u64>) -> Option<u64> {
key.and_then(|k| self.fields.get(&k)).and_then(|v| match v {
FieldValue::U64(n) => Some(*n),
FieldValue::U32(n) => Some(*n as u64),
FieldValue::I64(n) => Some(*n as u64),
FieldValue::I32(n) => Some(*n as u64),
_ => None,
})
}
pub fn get_bytes(&self, key: Option<u64>) -> Option<&[u8]> {
self.field_value(key).and_then(|value| match value {
FieldValue::String(bytes) => Some(bytes.as_slice()),
_ => None,
})
}
pub fn get_str(
&self,
key: Option<u64>,
) -> std::result::Result<Option<&str>, std::str::Utf8Error> {
self.get_bytes(key).map(std::str::from_utf8).transpose()
}
pub fn get_string(&self, key: Option<u64>) -> Option<String> {
self.get_bytes(key)
.map(|bytes| String::from_utf8_lossy(bytes).into_owned())
}
}
#[derive(Default)]
struct BaselineCache {
entries: FxHashMap<i32, CachedBaseline>,
}
impl Clone for BaselineCache {
fn clone(&self) -> Self {
Self::default()
}
}
struct CachedBaseline {
schema: Arc<()>,
revision: Arc<()>,
class_name: Arc<str>,
tick_interval: u32,
limits: DecodeLimits,
fields: FxHashMap<u64, FieldValue>,
}
impl BaselineCache {
#[allow(clippy::too_many_arguments)]
fn apply<const PROJECTED: bool>(
&mut self,
entity: &mut Entity,
serializer: &Serializer,
serializers: &SerializerContainer,
tables: &StringTableContainer,
ctx: &mut FieldDecodeContext,
paths: &mut Vec<FieldPath>,
properties: Option<&ClassProperties>,
) -> Result<()> {
let Some(bytes) = tables.instance_baseline(entity.class_id) else {
return Ok(());
};
let cached = self.entries.entry(entity.class_id);
let cached = match cached {
std::collections::hash_map::Entry::Occupied(entry)
if Arc::ptr_eq(&entry.get().schema, serializers.schema_id())
&& Arc::ptr_eq(&entry.get().revision, tables.baseline_revision())
&& entry.get().class_name == entity.class_name
&& entry.get().tick_interval == ctx.tick_interval.to_bits()
&& entry.get().limits == ctx.limits() =>
{
entry.into_mut()
}
entry => {
let mut baseline = Entity::new(0, entity.class_id, Arc::clone(&entity.class_name));
baseline.fields.reserve(serializer.fields.len());
baseline.apply_update::<PROJECTED>(
&mut BitReader::new(bytes),
serializer,
ctx,
paths,
properties,
)?;
let baseline = CachedBaseline {
schema: Arc::clone(serializers.schema_id()),
revision: Arc::clone(tables.baseline_revision()),
class_name: Arc::clone(&entity.class_name),
tick_interval: ctx.tick_interval.to_bits(),
limits: ctx.limits(),
fields: baseline.fields,
};
match entry {
std::collections::hash_map::Entry::Occupied(mut entry) => {
entry.insert(baseline);
entry.into_mut()
}
std::collections::hash_map::Entry::Vacant(entry) => entry.insert(baseline),
}
}
};
entity.fields.clone_from(&cached.fields);
Ok(())
}
}
#[derive(Clone, Default)]
pub struct EntityContainer {
serializer_bindings: SerializerBindings,
baseline_cache: BaselineCache,
properties: Option<PropertyFilter>,
entities: Vec<Option<Entity>>,
occupied_count: usize,
skipped_entity_classes: Vec<i32>,
updated: Vec<i32>,
changes: Vec<EntityChange>,
}
impl EntityContainer {
pub fn new() -> Self {
Self::default()
}
pub fn with_properties(properties: PropertyFilter) -> Self {
Self {
properties: Some(properties),
..Self::default()
}
}
pub(crate) fn project_properties(
&mut self,
properties: PropertyFilter,
serializers: &SerializerContainer,
) -> Result<()> {
properties.validate(serializers)?;
if self.properties.is_some() {
return Err(Error::Parse {
context: "cannot change a property filter on existing entity state".into(),
});
}
for entity in self.entities.iter_mut().flatten() {
properties.retain_entity(entity);
}
self.baseline_cache = BaselineCache::default();
self.properties = Some(properties);
Ok(())
}
pub(crate) fn validate_properties(&self, serializers: &SerializerContainer) -> Result<()> {
if let Some(properties) = &self.properties {
properties.validate(serializers)?;
}
Ok(())
}
pub fn reserve_slots(&mut self, slot_count: usize) -> Result<()> {
let max_slots = MAX_ENTITY_INDEX as usize + 1;
if slot_count > max_slots {
return Err(Error::LimitExceeded {
resource: "entity slots",
limit: max_slots,
actual: slot_count,
});
}
if slot_count < self.entities.len() {
self.occupied_count -= self.entities[slot_count..]
.iter()
.filter(|slot| slot.is_some())
.count();
}
self.entities.resize_with(slot_count, || None);
Ok(())
}
pub fn insert(&mut self, entity: Entity) -> Result<Option<Entity>> {
if !(0..=MAX_ENTITY_INDEX as i32).contains(&entity.index) {
return Err(Error::Parse {
context: format!("entity index {} out of range", entity.index),
});
}
let index = entity.index as usize;
if index >= self.entities.len() {
self.entities.resize_with(index + 1, || None);
}
let created = EntityChange::from_entity(EntityChangeKind::Created, &entity);
let previous = self.entities[index].replace(entity);
self.occupied_count += usize::from(previous.is_none());
if let Some(previous) = previous.as_ref() {
self.changes.push(EntityChange::from_entity(
EntityChangeKind::Deleted,
previous,
));
}
self.changes.push(created);
self.updated.push(index as i32);
Ok(previous)
}
pub fn slots(&self) -> &[Option<Entity>] {
&self.entities
}
pub fn slot_count(&self) -> usize {
self.entities.len()
}
#[inline]
fn entity_mut(&mut self, index: i32) -> Option<&mut Entity> {
usize::try_from(index)
.ok()
.and_then(|i| self.entities.get_mut(i))
.and_then(Option::as_mut)
}
#[inline]
fn put_entity(&mut self, index: i32, entity: Entity) {
let Ok(i) = usize::try_from(index) else {
return;
};
if i >= self.entities.len() {
self.entities.resize_with(i + 1, || None);
}
let created = EntityChange::from_entity(EntityChangeKind::Created, &entity);
let previous = self.entities[i].replace(entity);
self.occupied_count += usize::from(previous.is_none());
if let Some(previous) = previous.as_ref() {
self.changes.push(EntityChange::from_entity(
EntityChangeKind::Deleted,
previous,
));
}
self.changes.push(created);
self.updated.push(index);
}
#[inline]
fn take_entity(&mut self, index: i32) -> Option<Entity> {
let entity = self
.entities
.get_mut(usize::try_from(index).ok()?)?
.take()?;
self.occupied_count -= 1;
Some(entity)
}
#[inline]
fn delete_entity(&mut self, index: i32) {
if let Some(entity) = self.take_entity(index) {
self.changes.push(EntityChange::from_entity(
EntityChangeKind::Deleted,
&entity,
));
}
}
#[inline]
fn skipped_class(&self, index: i32) -> Option<i32> {
usize::try_from(index)
.ok()
.and_then(|i| self.skipped_entity_classes.get(i))
.copied()
.filter(|&c| c >= 0)
}
#[inline]
fn set_skipped(&mut self, index: i32, class_id: Option<i32>) {
let Ok(i) = usize::try_from(index) else {
return;
};
let value = class_id.unwrap_or(-1);
if i >= self.skipped_entity_classes.len() {
if value < 0 {
return; }
self.skipped_entity_classes.resize(i + 1, -1);
}
self.skipped_entity_classes[i] = value;
}
pub fn handle_packet_entities(
&mut self,
msg: PacketEntities<'_>,
class_info: &ClassInfo,
serializers: &SerializerContainer,
string_tables: &StringTableContainer,
field_decode_ctx: &mut FieldDecodeContext,
fp_buf: &mut Vec<FieldPath>,
) -> Result<()> {
if self.properties.is_some() {
self.validate_properties(serializers)?;
self.handle_packet_entities_impl::<false, true>(
msg,
class_info,
serializers,
string_tables,
field_decode_ctx,
None,
fp_buf,
)
} else {
self.handle_packet_entities_impl::<false, false>(
msg,
class_info,
serializers,
string_tables,
field_decode_ctx,
None,
fp_buf,
)
}
}
#[allow(clippy::too_many_arguments)]
fn handle_packet_entities_impl<const FILTERED: bool, const PROJECTED: bool>(
&mut self,
msg: PacketEntities<'_>,
class_info: &ClassInfo,
serializers: &SerializerContainer,
string_tables: &StringTableContainer,
field_decode_ctx: &mut FieldDecodeContext,
class_filter: Option<&HashSet<&str>>,
fp_buf: &mut Vec<FieldPath>,
) -> Result<()> {
let update_count = usize::try_from(msg.updated_entries).map_err(|_| Error::Parse {
context: format!(
"negative packet-entity update count {}",
msg.updated_entries
),
})?;
let limits = field_decode_ctx.limits();
limits.ensure(
"packet entity updates",
update_count,
limits.max_packet_entity_updates(),
)?;
let has_pvs_vis_bits = msg.has_pvs_vis_bits;
self.serializer_bindings.refresh(class_info, serializers);
let entity_data = msg.entity_data;
let mut br = BitReader::new(entity_data);
let mut entity_index: i32 = -1;
for _ in 0..update_count {
let next = i64::from(entity_index) + i64::from(br.read_ubitvar()?) + 1;
if !(0..=MAX_ENTITY_INDEX).contains(&next) {
return Err(Error::Parse {
context: format!("entity index {next} out of range"),
});
}
entity_index = next as i32;
let cmd = br.read_bits(2)? as u8;
if cmd & CMD_LEAVE == 0 {
if cmd & CMD_CREATE_DELETE != 0 {
self.handle_create::<PROJECTED>(
entity_index,
&mut br,
class_info,
serializers,
string_tables,
field_decode_ctx,
class_filter,
fp_buf,
)
.map_err(|e| Error::Parse {
context: format!("entity create #{entity_index}: {e}"),
})?;
} else {
if has_pvs_vis_bits > 0 && (br.read_bits(2)? & 0x01) != 0 {
continue;
}
if FILTERED {
self.handle_update_filtered::<PROJECTED>(
entity_index,
&mut br,
class_info,
serializers,
field_decode_ctx,
fp_buf,
)?;
} else {
self.handle_update::<PROJECTED>(
entity_index,
&mut br,
serializers,
field_decode_ctx,
fp_buf,
)
.map_err(|e| Error::Parse {
context: format!(
"entity update #{} (class: {:?}): {}",
entity_index,
self.get(entity_index).map(|e| &e.class_name),
e
),
})?;
}
}
} else {
self.handle_leave_filtered(entity_index, cmd & CMD_CREATE_DELETE != 0);
}
}
Ok(())
}
fn handle_leave(&mut self, index: i32, delete: bool) {
if delete {
self.delete_entity(index);
return;
}
let change = self.entity_mut(index).and_then(|e| {
if !e.active {
return None;
}
e.active = false;
Some(EntityChange::from_entity(EntityChangeKind::LeftPvs, e))
});
if let Some(change) = change {
self.changes.push(change);
}
}
#[allow(clippy::too_many_arguments)]
pub fn handle_packet_entities_filtered(
&mut self,
msg: PacketEntities<'_>,
class_info: &ClassInfo,
serializers: &SerializerContainer,
string_tables: &StringTableContainer,
field_decode_ctx: &mut FieldDecodeContext,
class_filter: &HashSet<&str>,
fp_buf: &mut Vec<FieldPath>,
) -> Result<()> {
if self.properties.is_some() {
self.validate_properties(serializers)?;
self.handle_packet_entities_impl::<true, true>(
msg,
class_info,
serializers,
string_tables,
field_decode_ctx,
Some(class_filter),
fp_buf,
)
} else {
self.handle_packet_entities_impl::<true, false>(
msg,
class_info,
serializers,
string_tables,
field_decode_ctx,
Some(class_filter),
fp_buf,
)
}
}
fn handle_leave_filtered(&mut self, index: i32, delete: bool) {
if self.get(index).is_some() {
self.handle_leave(index, delete);
} else if delete {
self.set_skipped(index, None);
}
}
#[allow(clippy::too_many_arguments)]
fn handle_create<const PROJECTED: bool>(
&mut self,
index: i32,
br: &mut BitReader,
class_info: &ClassInfo,
serializers: &SerializerContainer,
string_tables: &StringTableContainer,
field_decode_ctx: &mut FieldDecodeContext,
class_filter: Option<&HashSet<&str>>,
fp_buf: &mut Vec<FieldPath>,
) -> Result<()> {
let class_id = br.read_bits(class_info.bits())? as i32;
let serial = br.read_bits(NUM_SERIAL_NUM_BITS as usize)? as u32;
let _unknown = br.read_uvarint32()?;
let class_entry = class_info.by_id(class_id).ok_or_else(|| Error::Parse {
context: format!("unknown class_id {class_id}"),
})?;
let serializer = self
.serializer_bindings
.get(class_id, &class_entry.network_name, serializers)
.ok_or_else(|| Error::Parse {
context: format!("no serializer for {}", class_entry.network_name),
})?;
if class_filter.is_some_and(|filter| !filter.contains(class_entry.network_name.as_ref())) {
Entity::skip_update(br, serializer, field_decode_ctx, fp_buf)?;
self.delete_entity(index);
self.set_skipped(index, Some(class_id));
return Ok(());
}
let properties = if PROJECTED {
self.properties
.as_ref()
.and_then(|filter| filter.get(&class_entry.network_name))
} else {
None
};
let mut entity = Entity::new(index, class_id, Arc::clone(&class_entry.network_name));
entity.serial = serial;
entity.fields.reserve(serializer.fields.len());
self.baseline_cache
.apply::<PROJECTED>(
&mut entity,
serializer,
serializers,
string_tables,
field_decode_ctx,
fp_buf,
properties,
)
.map_err(|err| Error::Parse {
context: format!(
"baseline for {} (class_id {}): {err}",
class_entry.network_name, class_id
),
})?;
entity
.apply_update::<PROJECTED>(br, serializer, field_decode_ctx, fp_buf, properties)
.map_err(|err| Error::Parse {
context: format!(
"create delta for {} (class_id {}): {}",
class_entry.network_name, class_id, err
),
})?;
self.set_skipped(index, None);
self.put_entity(index, entity);
Ok(())
}
fn handle_update<const PROJECTED: bool>(
&mut self,
index: i32,
br: &mut BitReader,
serializers: &SerializerContainer,
field_decode_ctx: &mut FieldDecodeContext,
fp_buf: &mut Vec<FieldPath>,
) -> Result<()> {
let change = {
let entity = usize::try_from(index)
.ok()
.and_then(|i| self.entities.get_mut(i))
.and_then(Option::as_mut)
.ok_or_else(|| Error::Parse {
context: format!("tried to update non-existent entity #{index}"),
})?;
let kind = if entity.active {
EntityChangeKind::Updated
} else {
EntityChangeKind::Reactivated
};
entity.active = true;
let serializer = self
.serializer_bindings
.get(entity.class_id, &entity.class_name, serializers)
.ok_or_else(|| Error::Parse {
context: format!("no serializer for {}", entity.class_name),
})?;
let properties = if PROJECTED {
self.properties
.as_ref()
.and_then(|filter| filter.get(&entity.class_name))
} else {
None
};
entity.apply_update::<PROJECTED>(
br,
serializer,
field_decode_ctx,
fp_buf,
properties,
)?;
EntityChange::from_entity(kind, entity)
};
self.updated.push(index);
self.changes.push(change);
Ok(())
}
fn handle_update_filtered<const PROJECTED: bool>(
&mut self,
index: i32,
br: &mut BitReader,
class_info: &ClassInfo,
serializers: &SerializerContainer,
field_decode_ctx: &mut FieldDecodeContext,
fp_buf: &mut Vec<FieldPath>,
) -> Result<bool> {
if self.get(index).is_some() {
self.handle_update::<PROJECTED>(index, br, serializers, field_decode_ctx, fp_buf)?;
return Ok(true);
}
if let Some(class_id) = self.skipped_class(index) {
let class_entry = class_info.by_id(class_id).ok_or_else(|| Error::Parse {
context: format!("unknown class_id {class_id}"),
})?;
let serializer = self
.serializer_bindings
.get(class_id, &class_entry.network_name, serializers)
.ok_or_else(|| Error::Parse {
context: format!("no serializer for {}", class_entry.network_name),
})?;
Entity::skip_update(br, serializer, field_decode_ctx, fp_buf)?;
return Ok(false);
}
Ok(false)
}
pub fn get(&self, index: i32) -> Option<&Entity> {
usize::try_from(index)
.ok()
.and_then(|i| self.entities.get(i))
.and_then(Option::as_ref)
}
pub fn get_by_handle(&self, handle: u32) -> Option<&Entity> {
if handle == INVALID_ENTITY_HANDLE || handle == u32::MAX {
return None;
}
self.get((handle & ENTITY_HANDLE_INDEX_MASK) as i32)
.filter(|entity| entity.serial == handle >> MAX_EDICT_BITS)
}
pub fn iter(&self) -> impl Iterator<Item = (i32, &Entity)> {
self.entities
.iter()
.enumerate()
.filter_map(|(i, slot)| slot.as_ref().map(|e| (i as i32, e)))
}
pub fn updated_indices(&self) -> &[i32] {
&self.updated
}
pub fn entity_changes(&self) -> &[EntityChange] {
&self.changes
}
pub fn clear_updated(&mut self) {
self.updated.clear();
}
pub fn clear_entity_changes(&mut self) {
self.changes.clear();
}
pub fn clear_tick_changes(&mut self) {
self.updated.clear();
self.changes.clear();
}
pub fn len(&self) -> usize {
self.occupied_count
}
pub fn is_empty(&self) -> bool {
self.occupied_count == 0
}
}
#[cfg(test)]
mod coverage_tests;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn container_new_is_empty() {
let c = EntityContainer::new();
assert!(c.is_empty());
assert_eq!(c.len(), 0);
assert!(c.get(0).is_none());
}
#[test]
fn container_iter_yields_entries() {
let mut c = EntityContainer::new();
c.put_entity(1, Entity::new(1, 1, "A".into()));
c.put_entity(2, Entity::new(2, 2, "B".into()));
let keys: Vec<i32> = c.iter().map(|(k, _)| k).collect();
assert_eq!(keys, [1, 2]);
}
#[test]
fn entity_basic_fields() {
let e = Entity::new(7, 42, "NPC".into());
assert_eq!(e.index, 7);
assert_eq!(e.class_id, 42);
assert_eq!(&*e.class_name, "NPC");
assert_eq!(e.serial, 0);
assert!(e.fields.is_empty());
}
}