use crate::error::{Error, Result};
use crate::io::BitReader;
use crate::limits::DecodeLimits;
use super::field_value::FieldValue;
use super::quantized_float::QuantizedFloat;
pub struct FieldDecodeContext {
pub tick_interval: f32,
pub string_buf: Vec<u8>,
limits: DecodeLimits,
}
impl FieldDecodeContext {
pub fn new(tick_interval: f32) -> Self {
Self::with_limits(tick_interval, DecodeLimits::default())
}
pub fn with_limits(tick_interval: f32, limits: DecodeLimits) -> Self {
Self {
tick_interval,
string_buf: Vec::with_capacity(512),
limits,
}
}
pub const fn limits(&self) -> DecodeLimits {
self.limits
}
pub fn set_tick_interval(&mut self, tick_interval: f32) {
self.tick_interval = tick_interval;
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum BareCharEncoding {
NullTerminatedString,
UnsignedVarint,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum PreciseQAngleMode {
Centered,
Raw,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DecodeProfile {
bare_char: BareCharEncoding,
ammo_field: Option<&'static str>,
pitch_yaw_qangles: bool,
precise_qangle: PreciseQAngleMode,
symbolic_array_lengths: &'static [(&'static str, usize)],
pointer_types: &'static [&'static str],
dynamic_serializer_types: &'static [&'static str],
}
impl DecodeProfile {
pub const fn new(bare_char: BareCharEncoding, precise_qangle: PreciseQAngleMode) -> Self {
Self {
bare_char,
ammo_field: None,
pitch_yaw_qangles: false,
precise_qangle,
symbolic_array_lengths: &[],
pointer_types: &[],
dynamic_serializer_types: &[],
}
}
#[must_use]
pub const fn with_ammo_field(mut self, field_name: &'static str) -> Self {
self.ammo_field = Some(field_name);
self
}
#[must_use]
pub const fn with_pitch_yaw_qangles(mut self) -> Self {
self.pitch_yaw_qangles = true;
self
}
#[must_use]
pub const fn with_symbolic_array_lengths(
mut self,
lengths: &'static [(&'static str, usize)],
) -> Self {
self.symbolic_array_lengths = lengths;
self
}
#[must_use]
pub const fn with_pointer_types(mut self, types: &'static [&'static str]) -> Self {
self.pointer_types = types;
self
}
#[must_use]
pub const fn with_dynamic_serializer_types(mut self, types: &'static [&'static str]) -> Self {
self.dynamic_serializer_types = types;
self
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum Decoder {
Bool,
I64,
U64,
I64Fixed8,
U64Fixed8,
U64Fixed64,
F32NoScale,
F32SimulationTime,
F32Coord,
F32Normal,
F32Quantized(QuantizedFloat),
Ammo,
String,
Vector2(Box<Decoder>),
Vector3(Box<Decoder>),
Vector3Normal,
Vector4(Box<Decoder>),
FloatVecN {
count: usize,
inner: Box<Decoder>,
},
BinaryBlock,
Poly,
QAnglePrecise,
QAnglePreciseRaw,
QAnglePitchYaw {
bit_count: usize,
},
QAngleBitCount {
bit_count: usize,
},
QAngleCoord,
Default,
}
impl Decoder {
pub fn decode(&self, ctx: &mut FieldDecodeContext, br: &mut BitReader) -> Result<FieldValue> {
match self {
Decoder::Bool => Ok(FieldValue::Bool(br.read_bool()?)),
Decoder::I64 => Ok(FieldValue::I64(br.read_varint64()?)),
Decoder::U64 => Ok(FieldValue::U64(br.read_uvarint64()?)),
Decoder::I64Fixed8 => {
let byte = br.read_bits(8)? as u8;
Ok(FieldValue::I64(i64::from(i8::from_le_bytes([byte]))))
}
Decoder::U64Fixed8 => Ok(FieldValue::U64(br.read_bits(8)?)),
Decoder::U64Fixed64 => {
let mut buf = [0u8; 8];
br.read_bytes(&mut buf)?;
Ok(FieldValue::U64(u64::from_le_bytes(buf)))
}
Decoder::F32NoScale => Ok(FieldValue::F32(br.read_f32()?)),
Decoder::F32SimulationTime => {
let ticks = br.read_uvarint32()?;
Ok(FieldValue::F32(ticks as f32 * ctx.tick_interval))
}
Decoder::F32Coord => Ok(FieldValue::F32(br.read_bitcoord()?)),
Decoder::F32Normal => Ok(FieldValue::F32(br.read_bitnormal()?)),
Decoder::F32Quantized(qf) => Ok(FieldValue::F32(qf.decode(br)?)),
Decoder::Ammo => {
let raw = br.read_uvarint32()?;
Ok(FieldValue::I32(if raw > 0 { (raw - 1) as i32 } else { 0 }))
}
Decoder::String => {
ctx.string_buf.clear();
br.read_string_raw_limited(
&mut ctx.string_buf,
ctx.limits.max_field_string_bytes(),
)?;
Ok(FieldValue::String(ctx.string_buf.clone()))
}
Decoder::Vector2(inner) => {
let x = inner.decode_f32(ctx, br)?;
let y = inner.decode_f32(ctx, br)?;
Ok(FieldValue::Vector2([x, y]))
}
Decoder::Vector3(inner) => {
let x = inner.decode_f32(ctx, br)?;
let y = inner.decode_f32(ctx, br)?;
let z = inner.decode_f32(ctx, br)?;
Ok(FieldValue::Vector3([x, y, z]))
}
Decoder::Vector3Normal => Ok(FieldValue::Vector3(br.read_bitvec3normal()?)),
Decoder::FloatVecN { count, inner } => {
let mut v = Vec::with_capacity(*count);
for _ in 0..*count {
v.push(inner.decode_f32(ctx, br)?);
}
Ok(FieldValue::FloatVector(v))
}
Decoder::BinaryBlock => {
let n = br.read_uvarint32()? as usize;
ctx.limits.ensure(
"decoded field binary block",
n,
ctx.limits.max_field_string_bytes(),
)?;
ctx.string_buf.clear();
ctx.string_buf.resize(n, 0);
br.read_bytes(&mut ctx.string_buf)?;
Ok(FieldValue::String(ctx.string_buf.clone()))
}
Decoder::Poly => {
let present = br.read_bool()?;
let _poly_type_index = br.read_ubitvar()?;
Ok(FieldValue::Bool(present))
}
Decoder::Vector4(inner) => {
let x = inner.decode_f32(ctx, br)?;
let y = inner.decode_f32(ctx, br)?;
let z = inner.decode_f32(ctx, br)?;
let w = inner.decode_f32(ctx, br)?;
Ok(FieldValue::Vector4([x, y, z, w]))
}
Decoder::QAnglePrecise => {
let mut v = [0.0f32; 3];
let rx = br.read_bool()?;
let ry = br.read_bool()?;
let rz = br.read_bool()?;
if rx {
v[0] = br.read_bitangle(20)? - 180.0;
}
if ry {
v[1] = br.read_bitangle(20)? - 180.0;
}
if rz {
v[2] = br.read_bitangle(20)? - 180.0;
}
Ok(FieldValue::QAngle(v))
}
Decoder::QAnglePreciseRaw => {
let mut value = [0.0; 3];
let present = [br.read_bool()?, br.read_bool()?, br.read_bool()?];
for (component, is_present) in value.iter_mut().zip(present) {
if is_present {
*component = br.read_bitangle(20)?;
}
}
Ok(FieldValue::QAngle(value))
}
Decoder::QAnglePitchYaw { bit_count } => Ok(FieldValue::QAngle([
br.read_bitangle(*bit_count)?,
br.read_bitangle(*bit_count)?,
0.0,
])),
Decoder::QAngleBitCount { bit_count } => {
let x = br.read_bitangle(*bit_count)?;
let y = br.read_bitangle(*bit_count)?;
let z = br.read_bitangle(*bit_count)?;
Ok(FieldValue::QAngle([x, y, z]))
}
Decoder::QAngleCoord => Ok(FieldValue::QAngle(br.read_bitvec3coord()?)),
Decoder::Default => Ok(FieldValue::U64(br.read_uvarint64()?)),
}
}
fn decode_f32(&self, ctx: &mut FieldDecodeContext, br: &mut BitReader) -> Result<f32> {
match self.decode(ctx, br)? {
FieldValue::F32(v) => Ok(v),
_ => Ok(0.0),
}
}
#[allow(clippy::only_used_in_recursion)]
pub fn skip(&self, ctx: &mut FieldDecodeContext, br: &mut BitReader) -> Result<()> {
match self {
Decoder::Bool => {
br.skip_bits(1)?;
}
Decoder::I64 => {
br.skip_varint()?;
}
Decoder::U64 => {
br.skip_varint()?;
}
Decoder::I64Fixed8 | Decoder::U64Fixed8 => {
br.skip_bits(8)?;
}
Decoder::U64Fixed64 => {
br.skip_bits(64)?;
}
Decoder::F32NoScale => {
br.skip_bits(32)?;
}
Decoder::F32SimulationTime => {
br.read_uvarint32()?;
}
Decoder::F32Coord => {
br.skip_bitcoord()?;
}
Decoder::F32Normal => {
br.skip_bitnormal()?;
}
Decoder::F32Quantized(qf) => {
qf.skip(br)?;
}
Decoder::Ammo => {
br.read_uvarint32()?;
}
Decoder::String => {
return br.skip_string_limited(ctx.limits.max_field_string_bytes());
}
Decoder::Vector2(inner) => {
inner.skip(ctx, br)?;
inner.skip(ctx, br)?;
}
Decoder::Vector3(inner) => {
return if matches!(inner.as_ref(), Decoder::F32NoScale) && br.bits_remaining() >= 96
{
br.skip_bits(96)
} else {
inner.skip_vector3_components(ctx, br)
};
}
Decoder::Vector3Normal => {
br.skip_bitvec3normal()?;
}
Decoder::FloatVecN { count, inner } => {
for _ in 0..*count {
inner.skip(ctx, br)?;
}
}
Decoder::BinaryBlock => {
return skip_binary_block(br, ctx.limits.max_field_string_bytes());
}
Decoder::Poly => {
br.skip_bits(1)?;
br.read_ubitvar()?;
}
Decoder::Vector4(inner) => {
inner.skip(ctx, br)?;
inner.skip(ctx, br)?;
inner.skip(ctx, br)?;
inner.skip(ctx, br)?;
}
Decoder::QAnglePrecise | Decoder::QAnglePreciseRaw => {
let rx = br.read_bool()?;
let ry = br.read_bool()?;
let rz = br.read_bool()?;
if rx {
br.skip_bits(20)?;
}
if ry {
br.skip_bits(20)?;
}
if rz {
br.skip_bits(20)?;
}
}
Decoder::QAnglePitchYaw { bit_count } => {
br.skip_bits(*bit_count * 2)?;
}
Decoder::QAngleBitCount { bit_count } => {
br.skip_bits(*bit_count * 3)?;
}
Decoder::QAngleCoord => {
br.skip_bitvec3coord()?;
}
Decoder::Default => {
br.skip_varint()?;
}
}
Ok(())
}
#[inline(never)]
fn skip_vector3_components(
&self,
ctx: &mut FieldDecodeContext,
br: &mut BitReader,
) -> Result<()> {
match self {
Decoder::F32Coord => {
br.skip_bitcoord()?;
br.skip_bitcoord()?;
br.skip_bitcoord()?;
}
Decoder::F32Normal => {
br.skip_bitnormal()?;
br.skip_bitnormal()?;
br.skip_bitnormal()?;
}
Decoder::F32Quantized(qf) => {
qf.skip(br)?;
qf.skip(br)?;
qf.skip(br)?;
}
_ => {
self.skip(ctx, br)?;
self.skip(ctx, br)?;
self.skip(ctx, br)?;
}
}
Ok(())
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum FieldSpecialDescriptor {
FixedArray {
length: usize,
},
DynamicArray {
inner_decoder: Decoder,
},
DynamicSerializerArray,
Pointer,
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct FieldMetadata {
pub decoder: Decoder,
pub special: Option<FieldSpecialDescriptor>,
}
impl Default for FieldMetadata {
fn default() -> Self {
Self {
decoder: Decoder::Default,
special: None,
}
}
}
impl FieldMetadata {
pub fn is_dynamic_array(&self) -> bool {
matches!(
self.special,
Some(FieldSpecialDescriptor::DynamicArray { .. })
| Some(FieldSpecialDescriptor::DynamicSerializerArray)
)
}
pub fn is_fixed_array(&self) -> bool {
matches!(
self.special,
Some(FieldSpecialDescriptor::FixedArray { .. })
)
}
pub fn fixed_array_length(&self) -> Option<usize> {
match &self.special {
Some(FieldSpecialDescriptor::FixedArray { length }) => Some(*length),
_ => None,
}
}
pub fn is_dynamic_serializer_array(&self) -> bool {
matches!(
self.special,
Some(FieldSpecialDescriptor::DynamicSerializerArray)
)
}
pub fn is_pointer(&self) -> bool {
matches!(self.special, Some(FieldSpecialDescriptor::Pointer))
}
pub fn dynamic_array_inner_metadata(&self) -> FieldMetadata {
match &self.special {
Some(FieldSpecialDescriptor::DynamicArray { inner_decoder }) => FieldMetadata {
decoder: inner_decoder.clone(),
special: None,
},
_ => FieldMetadata::default(),
}
}
}
fn build_f32_decoder(
var_name: &str,
bit_count: Option<i32>,
low_value: Option<f32>,
high_value: Option<f32>,
encode_flags: Option<i32>,
var_encoder: Option<&str>,
) -> Decoder {
if var_name == "m_flSimulationTime" || var_name == "m_flAnimTime" {
return Decoder::F32SimulationTime;
}
if let Some(encoder) = var_encoder {
match encoder {
"coord" => return Decoder::F32Coord,
"normal" => return Decoder::F32Normal,
_ => {}
}
}
let bc = bit_count.unwrap_or(0);
if bc == 0 || bc == 32 {
return Decoder::F32NoScale;
}
match QuantizedFloat::new(
bc,
encode_flags.unwrap_or(0),
low_value.unwrap_or(0.0),
high_value.unwrap_or(0.0),
) {
Ok(qf) => Decoder::F32Quantized(qf),
Err(_) => Decoder::F32NoScale,
}
}
#[allow(clippy::too_many_arguments)]
pub fn get_field_metadata(
profile: DecodeProfile,
var_type: &str,
var_name: &str,
bit_count: Option<i32>,
low_value: Option<f32>,
high_value: Option<f32>,
encode_flags: Option<i32>,
var_encoder: Option<&str>,
has_field_serializer: bool,
) -> FieldMetadata {
if profile.ammo_field == Some(var_name) {
return FieldMetadata {
decoder: Decoder::Ammo,
special: None,
};
}
let trimmed = var_type.trim();
if trimmed.ends_with('*') {
return FieldMetadata {
decoder: Decoder::Bool,
special: Some(FieldSpecialDescriptor::Pointer),
};
}
if let Some(bracket_pos) = trimmed.find('[')
&& trimmed.ends_with(']')
{
let base = trimmed[..bracket_pos].trim();
let len_str = trimmed[bracket_pos + 1..trimmed.len() - 1].trim();
if base == "char" {
return FieldMetadata {
decoder: Decoder::String,
special: None,
};
}
let length = match len_str.parse::<usize>() {
Ok(length) => length,
Err(_) => profile
.symbolic_array_lengths
.iter()
.find_map(|(symbol, length)| (*symbol == len_str).then_some(*length))
.unwrap_or(64),
};
let inner = get_field_metadata(
profile,
base,
var_name,
bit_count,
low_value,
high_value,
encode_flags,
var_encoder,
has_field_serializer,
);
return FieldMetadata {
decoder: inner.decoder,
special: Some(FieldSpecialDescriptor::FixedArray { length }),
};
}
if let Some(angle_pos) = trimmed.find('<')
&& let Some(close_pos) = trimmed.rfind('>')
{
let base = trimmed[..angle_pos].trim();
let inner_type = trimmed[angle_pos + 1..close_pos].trim();
let is_vector_base = matches!(
base,
"CNetworkUtlVectorBase" | "CUtlVectorEmbeddedNetworkVar" | "CUtlVector"
);
if is_vector_base {
if has_field_serializer {
return FieldMetadata {
decoder: Decoder::U64,
special: Some(FieldSpecialDescriptor::DynamicSerializerArray),
};
}
let inner = get_field_metadata(
profile,
inner_type,
var_name,
bit_count,
low_value,
high_value,
encode_flags,
var_encoder,
has_field_serializer,
);
return FieldMetadata {
decoder: Decoder::U64,
special: Some(FieldSpecialDescriptor::DynamicArray {
inner_decoder: inner.decoder,
}),
};
}
return get_field_metadata(
profile,
base,
var_name,
bit_count,
low_value,
high_value,
encode_flags,
var_encoder,
has_field_serializer,
);
}
if profile.pointer_types.contains(&trimmed) {
return FieldMetadata {
decoder: Decoder::Bool,
special: Some(FieldSpecialDescriptor::Pointer),
};
}
if var_encoder == Some("fixed8") {
return FieldMetadata {
decoder: match trimmed {
"int8" | "int16" | "int32" | "int64" => Decoder::I64Fixed8,
_ => Decoder::U64Fixed8,
},
special: None,
};
}
match trimmed {
"int8" | "int16" | "int32" | "int64" => FieldMetadata {
decoder: Decoder::I64,
special: None,
},
"bool" => FieldMetadata {
decoder: Decoder::Bool,
special: None,
},
"float32" | "CNetworkedQuantizedFloat" | "GameTime_t" => {
let decoder = build_f32_decoder(
var_name,
bit_count,
low_value,
high_value,
encode_flags,
var_encoder,
);
FieldMetadata {
decoder,
special: None,
}
}
"CBodyComponentBaseAnimating"
| "CBodyComponentBaseAnimatingOverlay"
| "CBodyComponentBaseModelEntity"
| "CBodyComponent"
| "CBodyComponentSkeletonInstance"
| "CBodyComponentPoint"
| "CLightComponent"
| "CRenderComponent"
| "C_BodyComponentBaseAnimating"
| "C_BodyComponentBaseAnimatingOverlay"
| "CPhysicsComponent" => FieldMetadata {
decoder: Decoder::Bool,
special: Some(FieldSpecialDescriptor::Pointer),
},
"CUtlSymbolLarge" | "CUtlString" | "CGlobalSymbol" => FieldMetadata {
decoder: Decoder::String,
special: None,
},
"char" => FieldMetadata {
decoder: match profile.bare_char {
BareCharEncoding::NullTerminatedString => Decoder::String,
BareCharEncoding::UnsignedVarint => Decoder::U64,
},
special: None,
},
"CUtlBinaryBlock" => FieldMetadata {
decoder: Decoder::BinaryBlock,
special: None,
},
"Quaternion" | "CTransform" => {
let count = if trimmed == "CTransform" { 6 } else { 4 };
let inner = build_f32_decoder(
var_name,
bit_count,
low_value,
high_value,
encode_flags,
var_encoder,
);
FieldMetadata {
decoder: Decoder::FloatVecN {
count,
inner: Box::new(inner),
},
special: None,
}
}
"QAngle" => {
let bit_count = bit_count.unwrap_or(0) as usize;
let decoder = match var_encoder {
Some("qangle_pitch_yaw") if profile.pitch_yaw_qangles => {
Decoder::QAnglePitchYaw { bit_count }
}
Some("qangle_precise") => match profile.precise_qangle {
PreciseQAngleMode::Centered => Decoder::QAnglePrecise,
PreciseQAngleMode::Raw => Decoder::QAnglePreciseRaw,
},
_ if bit_count != 0 => Decoder::QAngleBitCount { bit_count },
_ => Decoder::QAngleCoord,
};
FieldMetadata {
decoder,
special: None,
}
}
"Vector" | "VectorWS" => {
if var_encoder == Some("normal") {
FieldMetadata {
decoder: Decoder::Vector3Normal,
special: None,
}
} else {
let inner = build_f32_decoder(
var_name,
bit_count,
low_value,
high_value,
encode_flags,
var_encoder,
);
FieldMetadata {
decoder: Decoder::Vector3(Box::new(inner)),
special: None,
}
}
}
"Vector2D" => {
let inner = build_f32_decoder(
var_name,
bit_count,
low_value,
high_value,
encode_flags,
var_encoder,
);
FieldMetadata {
decoder: Decoder::Vector2(Box::new(inner)),
special: None,
}
}
"Vector4D" => {
let inner = build_f32_decoder(
var_name,
bit_count,
low_value,
high_value,
encode_flags,
var_encoder,
);
FieldMetadata {
decoder: Decoder::Vector4(Box::new(inner)),
special: None,
}
}
_ if profile.dynamic_serializer_types.contains(&trimmed) => FieldMetadata {
decoder: Decoder::U64,
special: Some(FieldSpecialDescriptor::DynamicSerializerArray),
},
_ => {
let decoder = if var_encoder == Some("fixed64") {
Decoder::U64Fixed64
} else {
Decoder::U64
};
FieldMetadata {
decoder,
special: None,
}
}
}
}
#[inline(never)]
fn skip_binary_block(br: &mut BitReader, limit: usize) -> Result<()> {
let n = br.read_uvarint32()? as usize;
if n > limit {
return Err(Error::LimitExceeded {
resource: "decoded field binary block",
limit,
actual: n,
});
}
let bits = n.checked_mul(8).ok_or_else(|| Error::Parse {
context: "binary block bit length overflow".into(),
})?;
br.skip_bits(bits)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::io::BitReader;
const TEST_PROFILE: DecodeProfile = DecodeProfile::new(
BareCharEncoding::NullTerminatedString,
PreciseQAngleMode::Centered,
)
.with_ammo_field("m_ammo");
fn meta(var_type: &str, var_name: &str) -> FieldMetadata {
get_field_metadata(
TEST_PROFILE,
var_type,
var_name,
None,
None,
None,
None,
None,
false,
)
}
#[allow(clippy::too_many_arguments)]
fn meta_full(
var_type: &str,
var_name: &str,
bit_count: Option<i32>,
low: Option<f32>,
high: Option<f32>,
encode_flags: Option<i32>,
var_encoder: Option<&str>,
has_fs: bool,
) -> FieldMetadata {
get_field_metadata(
TEST_PROFILE,
var_type,
var_name,
bit_count,
low,
high,
encode_flags,
var_encoder,
has_fs,
)
}
#[test]
fn pointer_type() {
let m = meta("CBaseEntity*", "m_hOwner");
assert!(matches!(m.decoder, Decoder::Bool));
assert!(m.is_pointer());
}
#[test]
fn bool_type() {
let m = meta("bool", "m_bActive");
assert!(matches!(m.decoder, Decoder::Bool));
assert!(m.special.is_none());
}
#[test]
fn int32_type() {
let m = meta("int32", "m_iHealth");
assert!(matches!(m.decoder, Decoder::I64));
}
#[test]
fn float32_no_scale() {
let m = meta("float32", "m_flValue");
assert!(matches!(m.decoder, Decoder::F32NoScale));
}
#[test]
fn simulation_time() {
let m = meta("float32", "m_flSimulationTime");
assert!(matches!(m.decoder, Decoder::F32SimulationTime));
}
#[test]
fn coord_encoder() {
let m = meta_full(
"float32",
"m_x",
None,
None,
None,
None,
Some("coord"),
false,
);
assert!(matches!(m.decoder, Decoder::F32Coord));
}
#[test]
fn quantized_float() {
let m = meta_full(
"float32",
"m_val",
Some(8),
Some(0.0),
Some(255.0),
None,
None,
false,
);
assert!(matches!(m.decoder, Decoder::F32Quantized(_)));
}
#[test]
fn string_utl_symbol() {
let m = meta("CUtlSymbolLarge", "m_iszName");
assert!(matches!(m.decoder, Decoder::String));
}
#[test]
fn char_array_is_string() {
let m = meta("char[256]", "m_szName");
assert!(matches!(m.decoder, Decoder::String));
assert!(!m.is_fixed_array());
}
#[test]
fn int32_array_is_fixed_array() {
let m = meta("int32[4]", "m_values");
assert!(m.is_fixed_array());
assert_eq!(m.fixed_array_length(), Some(4));
}
#[test]
fn dynamic_array_without_serializer() {
let m = meta("CNetworkUtlVectorBase< int32 >", "m_items");
assert!(m.is_dynamic_array());
assert!(!m.is_dynamic_serializer_array());
}
#[test]
fn dynamic_serializer_array() {
let m = meta_full(
"CNetworkUtlVectorBase< SomeType >",
"m_items",
None,
None,
None,
None,
None,
true,
);
assert!(m.is_dynamic_serializer_array());
}
#[test]
fn qangle_no_encoder_no_bits() {
let m = meta("QAngle", "m_angle");
assert!(matches!(m.decoder, Decoder::QAngleCoord));
}
#[test]
fn qangle_with_bitcount() {
let m = meta_full("QAngle", "m_angle", Some(16), None, None, None, None, false);
assert!(matches!(
m.decoder,
Decoder::QAngleBitCount { bit_count: 16 }
));
}
#[test]
fn qangle_precise() {
let m = meta_full(
"QAngle",
"m_angle",
Some(10),
None,
None,
None,
Some("qangle_precise"),
false,
);
assert!(matches!(m.decoder, Decoder::QAnglePrecise));
}
#[test]
fn configured_ammo_field_uses_ammo_decoder() {
let m = meta("uint16", "m_ammo");
assert!(matches!(m.decoder, Decoder::Ammo));
assert!(m.special.is_none());
}
#[test]
fn binary_block_type() {
let m = meta("CUtlBinaryBlock", "m_topology");
assert!(matches!(m.decoder, Decoder::BinaryBlock));
}
#[test]
fn quaternion_and_transform_are_float_vectors() {
assert!(matches!(
meta("Quaternion", "m_q").decoder,
Decoder::FloatVecN { count: 4, .. }
));
assert!(matches!(
meta("CTransform", "m_t").decoder,
Decoder::FloatVecN { count: 6, .. }
));
}
#[test]
fn bare_char_is_string() {
assert!(matches!(meta("char", "m_c").decoder, Decoder::String));
}
#[test]
fn decode_ammo_subtracts_one() {
let data = [0x06];
let mut br = BitReader::new(&data);
let mut ctx = FieldDecodeContext::new(1.0 / 64.0);
let val = Decoder::Ammo.decode(&mut ctx, &mut br).unwrap();
assert!(matches!(val, FieldValue::I32(5)));
}
#[test]
fn decode_ammo_zero_stays_zero() {
let data = [0x00];
let mut br = BitReader::new(&data);
let mut ctx = FieldDecodeContext::new(1.0 / 64.0);
let val = Decoder::Ammo.decode(&mut ctx, &mut br).unwrap();
assert!(matches!(val, FieldValue::I32(0)));
}
#[test]
fn decode_binary_block_reads_len_then_bytes() {
let data = [0x03, b'a', b'b', b'c', 0xFF];
let mut br = BitReader::new(&data);
let mut ctx = FieldDecodeContext::new(1.0 / 64.0);
let val = Decoder::BinaryBlock.decode(&mut ctx, &mut br).unwrap();
match val {
FieldValue::String(bytes) => assert_eq!(&bytes, b"abc"),
other => panic!("expected String, got {other:?}"),
}
assert_eq!(br.position(), 32);
}
#[test]
fn decode_poly_reads_bool_and_ubitvar() {
let data = [0b0000_0011];
let mut br = BitReader::new(&data);
let mut ctx = FieldDecodeContext::new(1.0 / 64.0);
let val = Decoder::Poly.decode(&mut ctx, &mut br).unwrap();
assert!(matches!(val, FieldValue::Bool(true)));
assert_eq!(br.position(), 7);
}
#[test]
fn decode_bool_from_1bit() {
let data = [0x01];
let mut br = BitReader::new(&data);
let mut ctx = FieldDecodeContext::new(1.0 / 64.0);
let val = Decoder::Bool.decode(&mut ctx, &mut br).unwrap();
assert!(matches!(val, FieldValue::Bool(true)));
}
#[test]
fn decode_f32_no_scale() {
let bytes = 1.5f32.to_le_bytes();
let mut br = BitReader::new(&bytes);
let mut ctx = FieldDecodeContext::new(1.0 / 64.0);
let val = Decoder::F32NoScale.decode(&mut ctx, &mut br).unwrap();
if let FieldValue::F32(f) = val {
assert!((f - 1.5).abs() < f32::EPSILON);
} else {
panic!("expected F32");
}
}
#[test]
fn skipped_strings_enforce_the_same_limit_and_cursor_as_decoding() {
for alignment in 0..8 {
let mut bits = crate::test_utils::BitWriter::default();
bits.push_bits(0, alignment);
bits.push_c_string("abcd");
let data = bits.finish();
let mut decoded = BitReader::new(&data);
let mut skipped = BitReader::new(&data);
decoded.skip_bits(alignment).unwrap();
skipped.skip_bits(alignment).unwrap();
let mut context = FieldDecodeContext::with_limits(
1.0 / 64.0,
DecodeLimits::default().with_max_field_string_bytes(2),
);
let expected = Decoder::String
.decode(&mut context, &mut decoded)
.unwrap_err();
let actual = Decoder::String
.skip(&mut context, &mut skipped)
.unwrap_err();
assert_eq!(
(actual.to_string(), skipped.position()),
(expected.to_string(), decoded.position())
);
}
}
#[test]
fn skipped_binary_blocks_enforce_the_same_limit_as_decoding() {
let data = [4, 1, 2, 3, 4];
let mut context = FieldDecodeContext::with_limits(
1.0 / 64.0,
DecodeLimits::default().with_max_field_string_bytes(2),
);
let expected = Decoder::BinaryBlock
.decode(&mut context, &mut BitReader::new(&data))
.unwrap_err();
let actual = Decoder::BinaryBlock
.skip(&mut context, &mut BitReader::new(&data))
.unwrap_err();
assert_eq!(actual.to_string(), expected.to_string());
}
#[test]
fn skipped_32_bit_varints_stop_after_five_bytes() {
for decoder in [Decoder::Ammo, Decoder::F32SimulationTime] {
let data = [0x80; 10];
let mut decoded = BitReader::new(&data);
let mut skipped = BitReader::new(&data);
let mut context = FieldDecodeContext::new(1.0 / 64.0);
decoder.decode(&mut context, &mut decoded).unwrap();
decoder.skip(&mut context, &mut skipped).unwrap();
assert_eq!(skipped.position(), decoded.position());
}
}
#[test]
fn decode_string_null_terminated() {
let data = b"hello\0";
let mut br = BitReader::new(data);
let mut ctx = FieldDecodeContext::new(1.0 / 64.0);
let val = Decoder::String.decode(&mut ctx, &mut br).unwrap();
if let FieldValue::String(s) = val {
assert_eq!(&s, b"hello");
} else {
panic!("expected String");
}
}
#[test]
fn vector3_skip_preserves_scalar_errors_and_positions() {
let mut ctx = FieldDecodeContext::new(1.0 / 64.0);
let mut components = vec![
Decoder::F32NoScale,
Decoder::F32Coord,
Decoder::F32Normal,
Decoder::U64Fixed8,
Decoder::Vector2(Box::new(Decoder::F32Coord)),
];
for bit_count in 1..32 {
for flags in 0..16 {
components.push(Decoder::F32Quantized(
QuantizedFloat::new(bit_count, flags, -10.0, 100.0).unwrap(),
));
}
}
for inner in components {
let vector = Decoder::Vector3(Box::new(inner.clone()));
for pattern in [0, 0xa5, 0xff] {
let bytes = [pattern; 13];
for len in 0..=bytes.len() {
for offset in 0..=7.min(len * 8) {
let mut scalar = BitReader::new(&bytes[..len]);
let mut skipped = BitReader::new(&bytes[..len]);
scalar.skip_bits(offset).unwrap();
skipped.skip_bits(offset).unwrap();
let expected = (0..3).try_for_each(|_| inner.skip(&mut ctx, &mut scalar));
let actual = vector.skip(&mut ctx, &mut skipped);
assert_eq!(
actual.map_err(|e| e.to_string()),
expected.map_err(|e| e.to_string())
);
assert_eq!(skipped.position(), scalar.position());
}
}
}
}
}
#[test]
fn fixed8_decode_and_skip_preserve_alignment() {
use crate::test_utils::BitWriter;
let mut ctx = FieldDecodeContext::new(1.0 / 64.0);
for offset in 0..8 {
for byte in 0..=u8::MAX {
let mut writer = BitWriter::default();
writer.push_bits(0, offset);
writer.push_bytes(&[byte, 0xa5]);
let bytes = writer.finish();
for (decoder, expected) in [
(Decoder::U64Fixed8, FieldValue::U64(u64::from(byte))),
(
Decoder::I64Fixed8,
FieldValue::I64(i64::from(i8::from_le_bytes([byte]))),
),
] {
let mut reader = BitReader::new(&bytes);
reader.skip_bits(offset).unwrap();
let mut skipped = BitReader::new(&bytes);
skipped.skip_bits(offset).unwrap();
match (decoder.decode(&mut ctx, &mut reader).unwrap(), expected) {
(FieldValue::I64(actual), FieldValue::I64(expected)) => {
assert_eq!(actual, expected)
}
(FieldValue::U64(actual), FieldValue::U64(expected)) => {
assert_eq!(actual, expected)
}
values => panic!("unexpected fixed8 value types: {values:?}"),
}
decoder.skip(&mut ctx, &mut skipped).unwrap();
assert_eq!(reader.position(), offset + 8);
assert_eq!(skipped.position(), reader.position());
assert_eq!(reader.read_bits(8).unwrap(), 0xa5);
assert_eq!(skipped.read_bits(8).unwrap(), 0xa5);
}
}
}
}
#[test]
fn fixed8_rejects_truncated_bytes() {
let mut ctx = FieldDecodeContext::new(1.0 / 64.0);
for offset in 1..=8 {
for decoder in [Decoder::I64Fixed8, Decoder::U64Fixed8] {
let mut reader = BitReader::new(&[0xff]);
reader.skip_bits(offset).unwrap();
let mut skipped = BitReader::new(&[0xff]);
skipped.skip_bits(offset).unwrap();
assert!(decoder.decode(&mut ctx, &mut reader).is_err());
assert!(decoder.skip(&mut ctx, &mut skipped).is_err());
}
}
}
#[test]
fn fixed8_arrays_keep_their_length_encoding() {
let metadata = |var_type| {
meta_full(
var_type,
"m_values",
None,
None,
None,
None,
Some("fixed8"),
false,
)
};
let fixed = metadata("uint8[4]");
assert_eq!(fixed.fixed_array_length(), Some(4));
assert!(matches!(fixed.decoder, Decoder::U64Fixed8));
let dynamic = metadata("CNetworkUtlVectorBase< int8 >");
assert!(matches!(dynamic.decoder, Decoder::U64));
assert!(matches!(
dynamic.special,
Some(FieldSpecialDescriptor::DynamicArray {
inner_decoder: Decoder::I64Fixed8
})
));
}
#[test]
fn field_metadata_helpers() {
let dyn_arr = FieldMetadata {
decoder: Decoder::U64,
special: Some(FieldSpecialDescriptor::DynamicArray {
inner_decoder: Decoder::I64,
}),
};
assert!(dyn_arr.is_dynamic_array());
assert!(!dyn_arr.is_fixed_array());
assert!(!dyn_arr.is_pointer());
let fixed = FieldMetadata {
decoder: Decoder::I64,
special: Some(FieldSpecialDescriptor::FixedArray { length: 8 }),
};
assert!(fixed.is_fixed_array());
assert_eq!(fixed.fixed_array_length(), Some(8));
let ptr = FieldMetadata {
decoder: Decoder::Bool,
special: Some(FieldSpecialDescriptor::Pointer),
};
assert!(ptr.is_pointer());
}
}