demostf/parser
1
0
Fork 0
mirror of https://codeberg.org/demostf/parser.git synced 2026-06-03 18:24:05 +02:00
Code Issues Releases Wiki Activity

strongly typed sendpropdefinition

Browse source
This commit is contained in:
Robin Appelman 2021-02-13 01:25:03 +01:00
commit df9a6a138e
10 changed files with 384 additions and 206 deletions
Download patch file Download diff file Expand all files Collapse all files

2
benches/allmessages.rs
View file

@ -14,7 +14,7 @@ use tf_demo_parser::demo::message::Message;
use tf_demo_parser::demo::packet::datatable::{ParseSendTable, SendTableName};
use tf_demo_parser::demo::packet::stringtable::StringTableEntry;
use tf_demo_parser::demo::parser::MessageHandler;
use tf_demo_parser::demo::sendprop::SendPropDefinition;
use tf_demo_parser::demo::sendprop::RawSendPropDefinition;
use tf_demo_parser::{Demo, DemoParser, MatchState, MessageType, MessageTypeAnalyser, ParserState};
struct AllMessages;

82
benches/sendprop.rs
View file

@ -14,48 +14,48 @@ use tf_demo_parser::demo::message::Message;
use tf_demo_parser::demo::packet::datatable::{ParseSendTable, SendTableName};
use tf_demo_parser::demo::packet::stringtable::StringTableEntry;
use tf_demo_parser::demo::parser::MessageHandler;
use tf_demo_parser::demo::sendprop::SendPropDefinition;
use tf_demo_parser::demo::sendprop::RawSendPropDefinition;
use tf_demo_parser::{Demo, DemoParser, MatchState, MessageType, MessageTypeAnalyser, ParserState};
pub struct SendPropAnalyser;
impl MessageHandler for SendPropAnalyser {
type Output = Vec<ParseSendTable>;
fn does_handle(message_type: MessageType) -> bool {
false
}
fn into_output(self, state: &ParserState) -> Self::Output {
state
.send_tables
.iter()
.map(|v| ParseSendTable {
name: v.name.clone(),
props: v.props.clone(),
needs_decoder: v.needs_decoder,
})
.collect()
}
}
fn flatten_bench(input_file: &str, b: &mut Bencher) {
let file = fs::read(input_file).expect("Unable to read file");
let demo = Demo::new(&file);
let stream = demo.get_stream();
let (_, send_tables) = DemoParser::new_with_analyser(stream.clone(), SendPropAnalyser)
.parse()
.unwrap();
b.iter(|| {
let flat: Vec<_> = send_tables
.iter()
.map(|table| table.flatten_props(&send_tables))
.collect();
test::black_box(flat);
});
}
#[bench]
fn sendprop_test_gully(b: &mut Bencher) {
flatten_bench("data/gully.dem", b);
}
// impl MessageHandler for SendPropAnalyser {
// type Output = Vec<ParseSendTable>;
//
// fn does_handle(message_type: MessageType) -> bool {
// false
// }
//
// fn into_output(self, state: &ParserState) -> Self::Output {
// state
// .send_tables
// .iter()
// .map(|v| ParseSendTable {
// name: v.name.clone(),
// props: v.props.clone(),
// needs_decoder: v.needs_decoder,
// })
// .collect()
// }
// }
//
// fn flatten_bench(input_file: &str, b: &mut Bencher) {
// let file = fs::read(input_file).expect("Unable to read file");
// let demo = Demo::new(&file);
// let stream = demo.get_stream();
// let (_, send_tables) = DemoParser::new_with_analyser(stream.clone(), SendPropAnalyser)
// .parse()
// .unwrap();
// b.iter(|| {
// let flat: Vec<_> = send_tables
// .iter()
// .map(|table| table.flatten_props(&send_tables))
// .collect();
// test::black_box(flat);
// });
// }
//
// #[bench]
// fn sendprop_test_gully(b: &mut Bencher) {
// flatten_bench("data/gully.dem", b);
// }

15
src/demo/message/packetentities.rs
View file

@ -5,7 +5,7 @@ use serde_repr::{Deserialize_repr, Serialize_repr};
use crate::demo::message::stringtable::log_base2;
use crate::demo::packet::datatable::{ClassId, SendTable};
use crate::demo::parser::ParseBitSkip;
use crate::demo::sendprop::{SendProp, SendPropDefinition, SendPropValue};
use crate::demo::sendprop::{SendProp, SendPropIdentifier, SendPropValue};
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
use parse_display::{Display, FromStr};
use std::cmp::min;
@ -13,7 +13,6 @@ use std::cmp::min;
use std::fmt;
use std::hint::unreachable_unchecked;
use std::num::NonZeroU32;
use std::rc::Rc;
#[derive(
Debug,
@ -70,15 +69,15 @@ impl fmt::Display for PacketEntity {
}
impl PacketEntity {
fn get_prop_by_definition(&mut self, definition: &SendPropDefinition) -> Option<&mut SendProp> {
fn get_prop_by_identifier(&mut self, identifier: &SendPropIdentifier) -> Option<&mut SendProp> {
self.props
.iter_mut()
.find(|prop| prop.definition.index == definition.index)
.find(|prop| prop.identifier.index == identifier.index)
}
pub fn apply_update(&mut self, props: Vec<SendProp>) {
for prop in props {
match self.get_prop_by_definition(&prop.definition) {
match self.get_prop_by_identifier(&prop.identifier) {
Some(existing_prop) => existing_prop.value = prop.value,
None => self.props.push(prop),
}
@ -87,8 +86,8 @@ impl PacketEntity {
pub fn get_prop_by_name(&self, table_name: &str, name: &str) -> Option<&SendProp> {
self.props.iter().find(|prop| {
prop.definition.owner_table.as_str() == table_name
&& prop.definition.name.as_str() == name
prop.identifier.owner_table.as_str() == table_name
&& prop.identifier.name.as_str() == name
})
}
}
@ -252,7 +251,7 @@ impl PacketEntitiesMessage {
Some(definition) => {
let value = SendPropValue::parse(stream, definition)?;
props.push(SendProp {
definition: Rc::clone(definition),
identifier: definition.identifier(),
value,
});
}

39
src/demo/packet/datatable.rs
View file

@ -2,7 +2,8 @@ use bitbuffer::BitRead;
use crate::demo::parser::MalformedSendPropDefinitionError;
use crate::demo::sendprop::{
SendPropDefinition, SendPropDefinitionIndex, SendPropFlag, SendPropName, SendPropType,
RawSendPropDefinition, SendPropDefinition, SendPropDefinitionIndex, SendPropFlag, SendPropName,
SendPropType,
};
use crate::{Parse, ParseError, ParserState, Result, Stream};
use parse_display::{Display, FromStr};
@ -50,7 +51,18 @@ pub struct ServerClass {
}
#[derive(
BitRead, PartialEq, Eq, Hash, Debug, Serialize, Deserialize, Clone, Display, PartialOrd, Ord,
BitRead,
PartialEq,
Eq,
Hash,
Debug,
Serialize,
Deserialize,
Clone,
Display,
PartialOrd,
Ord,
Default,
)]
pub struct SendTableName(Rc<String>);
@ -69,7 +81,7 @@ impl From<String> for SendTableName {
#[derive(Debug, Clone)]
pub struct ParseSendTable {
pub name: SendTableName,
pub props: Vec<Rc<SendPropDefinition>>,
pub props: Vec<Rc<RawSendPropDefinition>>,
pub needs_decoder: bool,
}
@ -85,8 +97,8 @@ impl ParseSendTable {
for prop_index in 0..prop_count {
let definition_index = SendPropDefinitionIndex::new(table_index, prop_index);
let prop: SendPropDefinition =
SendPropDefinition::read(stream, name.clone(), definition_index)?;
let prop: RawSendPropDefinition =
RawSendPropDefinition::read(stream, name.clone(), definition_index)?;
if prop.flags.contains(SendPropFlag::InsideArray) {
if array_element_prop.is_some() || prop.flags.contains(SendPropFlag::ChangesOften) {
return Err(MalformedSendPropDefinitionError::ArrayChangesOften.into());
@ -112,7 +124,7 @@ impl ParseSendTable {
}
impl ParseSendTable {
pub fn flatten_props(&self, tables: &[ParseSendTable]) -> Vec<Rc<SendPropDefinition>> {
pub fn flatten_props(&self, tables: &[ParseSendTable]) -> Vec<Rc<RawSendPropDefinition>> {
let mut flat = Vec::with_capacity(32);
self.get_all_props(tables, &self.get_excludes(tables), &mut flat);
@ -137,7 +149,7 @@ impl ParseSendTable {
if let Some(exclude_table) = prop.get_exclude_table() {
excludes.push(Exclude {
table: exclude_table,
prop: &prop.name,
prop: &prop.identifier.name,
})
} else if let Some(table) = prop.get_data_table(tables) {
excludes.extend_from_slice(&table.get_excludes(tables));
@ -152,7 +164,7 @@ impl ParseSendTable {
&self,
tables: &[ParseSendTable],
excludes: &[Exclude],
props: &mut Vec<Rc<SendPropDefinition>>,
props: &mut Vec<Rc<RawSendPropDefinition>>,
) {
let mut local_props = Vec::new();
@ -164,8 +176,8 @@ impl ParseSendTable {
&self,
tables: &[ParseSendTable],
excludes: &[Exclude],
local_props: &mut Vec<Rc<SendPropDefinition>>,
props: &mut Vec<Rc<SendPropDefinition>>,
local_props: &mut Vec<Rc<RawSendPropDefinition>>,
props: &mut Vec<Rc<RawSendPropDefinition>>,
) {
self.props
.iter()
@ -192,17 +204,16 @@ struct Exclude<'a> {
}
impl<'a> Exclude<'a> {
pub fn matches(&self, prop: &SendPropDefinition) -> bool {
self.table == &prop.owner_table && *self.prop == prop.name
pub fn matches(&self, prop: &RawSendPropDefinition) -> bool {
self.table == &prop.identifier.owner_table && *self.prop == prop.identifier.name
}
}
#[derive(Debug, Clone)]
pub struct SendTable {
pub name: SendTableName,
pub props: Vec<Rc<SendPropDefinition>>,
pub needs_decoder: bool,
pub flattened_props: Vec<Rc<SendPropDefinition>>,
pub flattened_props: Vec<SendPropDefinition>,
}
#[derive(Debug)]

10
src/demo/parser/gamestateanalyser.rs
View file

@ -206,7 +206,7 @@ impl GameStateAnalyser {
pub fn handle_player_resource(&mut self, entity: &PacketEntity) {
for prop in &entity.props {
if let Ok(player_id) = u32::from_str(prop.definition.name.as_str()) {
if let Ok(player_id) = u32::from_str(prop.identifier.name.as_str()) {
let entity_id = EntityId::from(player_id);
if let Some(player) = self
.state
@ -214,7 +214,7 @@ impl GameStateAnalyser {
.iter_mut()
.find(|player| player.entity == entity_id)
{
match prop.definition.owner_table.as_str() {
match prop.identifier.owner_table.as_str() {
"m_iTeam" => {
player.team = Team::new(i64::try_from(&prop.value).unwrap_or_default())
}
@ -237,8 +237,8 @@ impl GameStateAnalyser {
let player = self.state.get_or_create_player(entity.entity_index);
for prop in &entity.props {
match prop.definition.owner_table.as_str() {
"DT_BasePlayer" => match prop.definition.name.as_str() {
match prop.identifier.owner_table.as_str() {
"DT_BasePlayer" => match prop.identifier.name.as_str() {
"m_iHealth" => {
player.health = i64::try_from(&prop.value).unwrap_or_default() as u16
}
@ -252,7 +252,7 @@ impl GameStateAnalyser {
_ => {}
},
"DT_TFLocalPlayerExclusive" | "DT_TFNonLocalPlayerExclusive" => {
match prop.definition.name.as_str() {
match prop.identifier.name.as_str() {
"m_vecOrigin" => {
let pos_xy = VectorXY::try_from(&prop.value).unwrap_or_default();
player.position.x = pos_xy.x;

6
src/demo/parser/handler.rs
View file

@ -71,7 +71,7 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
pub fn handle_packet(&mut self, packet: Packet<'a>) -> Result<()> {
match packet {
Packet::DataTables(packet) => {
self.handle_data_table(packet.tables, packet.server_classes);
self.handle_data_table(packet.tables, packet.server_classes)?;
}
Packet::StringTables(packet) => {
for table in packet.tables.into_iter() {
@ -127,11 +127,11 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
&mut self,
send_tables: Vec<ParseSendTable>,
server_classes: Vec<ServerClass>,
) {
) -> Result<()> {
self.analyser
.handle_data_tables(&send_tables, &server_classes);
self.state_handler
.handle_data_table(send_tables, server_classes);
.handle_data_table(send_tables, server_classes)
}
fn handle_message(&mut self, message: Message<'a>) {

19
src/demo/parser/state.rs
View file

@ -11,10 +11,11 @@ use crate::demo::packet::datatable::{
};
use crate::demo::packet::stringtable::StringTableEntry;
use crate::demo::sendprop::SendProp;
use crate::demo::sendprop::{SendProp, SendPropDefinition};
use crate::nullhasher::NullHasherBuilder;
use crate::{Result, Stream};
use std::cell::RefCell;
use std::convert::TryFrom;
#[derive(Default, Clone)]
pub struct DemoMeta {
@ -100,7 +101,7 @@ impl<'a> ParserState {
&mut self,
parse_tables: Vec<ParseSendTable>,
server_classes: Vec<ServerClass>,
) {
) -> Result<()> {
if self.handle_entities {
let flat_props: Vec<_> = parse_tables
.iter()
@ -111,17 +112,19 @@ impl<'a> ParserState {
.into_iter()
.zip(flat_props.into_iter())
.map(|(parse_table, flat)| {
(
Ok((
parse_table.name.clone(),
SendTable {
name: parse_table.name,
props: parse_table.props,
needs_decoder: parse_table.needs_decoder,
flattened_props: flat,
flattened_props: flat
.into_iter()
.map(|raw| SendPropDefinition::try_from(raw.as_ref()))
.collect::<std::result::Result<Vec<_>, _>>()?,
},
)
))
})
.collect();
.collect::<Result<_>>()?;
self.server_classes = server_classes;
@ -133,6 +136,8 @@ impl<'a> ParserState {
}
}
}
Ok(())
}
pub fn handle_string_table_meta(&mut self, table: StringTableMeta) {

391
src/demo/sendprop.rs
View file

@ -40,34 +40,32 @@ impl From<String> for SendPropName {
}
#[derive(Debug, Clone)]
pub struct SendPropDefinition {
pub struct RawSendPropDefinition {
pub prop_type: SendPropType,
pub name: SendPropName,
pub identifier: Rc<SendPropIdentifier>,
pub flags: SendPropFlags,
pub table_name: Option<SendTableName>,
pub owner_table: SendTableName,
pub low_value: Option<f32>,
pub high_value: Option<f32>,
pub bit_count: Option<u32>,
pub element_count: Option<u16>,
pub array_property: Option<Box<SendPropDefinition>>,
pub index: SendPropDefinitionIndex,
pub array_property: Option<Box<RawSendPropDefinition>>,
}
impl PartialEq for SendPropDefinition {
impl PartialEq for RawSendPropDefinition {
fn eq(&self, other: &Self) -> bool {
self.index == other.index
self.identifier.index == other.identifier.index
}
}
impl fmt::Display for SendPropDefinition {
impl fmt::Display for RawSendPropDefinition {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.prop_type {
SendPropType::Vector | SendPropType::VectorXY => write!(
f,
"{}::{}({})(flags: {}, low: {}, high: {}, bits: {})",
self.owner_table,
self.name,
self.identifier.owner_table,
self.identifier.name,
self.prop_type,
self.flags,
self.low_value.unwrap_or_default(),
@ -77,8 +75,8 @@ impl fmt::Display for SendPropDefinition {
SendPropType::Float => write!(
f,
"{}::{}({})(flags: {}, low: {}, high: {}, bits: {})",
self.owner_table,
self.name,
self.identifier.owner_table,
self.identifier.name,
self.prop_type,
self.flags,
self.low_value.unwrap_or_default(),
@ -88,47 +86,55 @@ impl fmt::Display for SendPropDefinition {
SendPropType::Int => write!(
f,
"{}::{}({})(flags: {}, bits: {})",
self.owner_table,
self.name,
self.identifier.owner_table,
self.identifier.name,
self.prop_type,
self.flags,
self.bit_count.unwrap_or(32)
),
SendPropType::String => {
write!(f, "{}::{}({})", self.owner_table, self.name, self.prop_type)
write!(
f,
"{}::{}({})",
self.identifier.owner_table, self.identifier.name, self.prop_type
)
}
SendPropType::Array => match &self.array_property {
Some(array_prop) => write!(
f,
"{}::{}([{}({})] * {})",
self.owner_table,
self.name,
self.identifier.owner_table,
self.identifier.name,
array_prop.prop_type,
array_prop.flags,
self.element_count.unwrap_or_default(),
),
None => write!(f, "{}(Malformed array)", self.name),
None => write!(f, "{}(Malformed array)", self.identifier.name),
},
SendPropType::DataTable => match &self.table_name {
Some(sub_table) => write!(
f,
"{}::{}(DataTable = {})",
self.owner_table, self.name, sub_table
self.identifier.owner_table, self.identifier.name, sub_table
),
None => write!(f, "{}(Malformed DataTable)", self.name),
None => write!(f, "{}(Malformed DataTable)", self.identifier.name),
},
SendPropType::NumSendPropTypes => {
write!(f, "{}::{}(NumSendPropTypes)", self.owner_table, self.name)
write!(
f,
"{}::{}(NumSendPropTypes)",
self.identifier.owner_table, self.identifier.name
)
}
}
}
}
impl SendPropDefinition {
impl RawSendPropDefinition {
pub fn with_array_property(self, array_property: Self) -> Self {
SendPropDefinition {
RawSendPropDefinition {
prop_type: self.prop_type,
name: self.name,
identifier: self.identifier,
flags: self.flags,
table_name: self.table_name,
low_value: self.low_value,
@ -136,8 +142,6 @@ impl SendPropDefinition {
bit_count: self.bit_count,
element_count: self.element_count,
array_property: Some(Box::new(array_property)),
owner_table: self.owner_table,
index: self.index,
}
}
@ -187,9 +191,13 @@ impl SendPropDefinition {
}
}
Ok(SendPropDefinition {
Ok(RawSendPropDefinition {
prop_type,
identifier: Rc::new(SendPropIdentifier {
index,
name,
owner_table,
}),
flags,
table_name,
low_value,
@ -197,8 +205,6 @@ impl SendPropDefinition {
bit_count,
element_count,
array_property: None,
owner_table,
index,
})
}
@ -304,6 +310,173 @@ impl BitRead<'_, LittleEndian> for SendPropFlags {
}
}
#[derive(Debug, Clone)]
pub enum FloatDefinition {
Coord,
CoordMP,
CoordMPLowPrecision,
CoordMPIntegral,
FloatNoScale,
NormalVarFloat,
Scaled { bit_count: u8, high: f32, low: f32 },
}
impl FloatDefinition {
pub fn new(
flags: SendPropFlags,
bit_count: Option<u32>,
high: Option<f32>,
low: Option<f32>,
) -> std::result::Result<Self, MalformedSendPropDefinitionError> {
if flags.contains(SendPropFlag::Coord) {
Ok(FloatDefinition::Coord)
} else if flags.contains(SendPropFlag::CoordMP) {
Ok(FloatDefinition::CoordMP)
} else if flags.contains(SendPropFlag::CoordMPLowPrecision) {
Ok(FloatDefinition::CoordMPLowPrecision)
} else if flags.contains(SendPropFlag::CoordMPIntegral) {
Ok(FloatDefinition::CoordMPIntegral)
} else if flags.contains(SendPropFlag::NoScale) {
Ok(FloatDefinition::FloatNoScale)
} else if flags.contains(SendPropFlag::NormalVarInt) {
Ok(FloatDefinition::NormalVarFloat)
} else if let (Some(bit_count), Some(high), Some(low)) = (bit_count, high, low) {
Ok(FloatDefinition::Scaled {
bit_count: bit_count as u8,
high,
low,
})
} else {
Err(MalformedSendPropDefinitionError::UnsizedFloat)
}
}
}
#[derive(Debug, Clone)]
pub enum SendPropDefinition {
NormalVarInt {
identifier: Rc<SendPropIdentifier>,
unsigned: bool,
},
UnsignedInt {
identifier: Rc<SendPropIdentifier>,
bit_count: u8,
},
Int {
identifier: Rc<SendPropIdentifier>,
bit_count: u8,
},
Float {
identifier: Rc<SendPropIdentifier>,
definition: FloatDefinition,
},
String {
identifier: Rc<SendPropIdentifier>,
},
Vector {
identifier: Rc<SendPropIdentifier>,
definition: FloatDefinition,
},
VectorXY {
identifier: Rc<SendPropIdentifier>,
definition: FloatDefinition,
},
Array {
identifier: Rc<SendPropIdentifier>,
inner_definition: Box<SendPropDefinition>,
count_bit_count: u16,
},
}
impl SendPropDefinition {
pub fn identifier(&self) -> Rc<SendPropIdentifier> {
match self {
SendPropDefinition::NormalVarInt { identifier, .. } => identifier.clone(),
SendPropDefinition::UnsignedInt { identifier, .. } => identifier.clone(),
SendPropDefinition::Int { identifier, .. } => identifier.clone(),
SendPropDefinition::Float { identifier, .. } => identifier.clone(),
SendPropDefinition::String { identifier, .. } => identifier.clone(),
SendPropDefinition::Vector { identifier, .. } => identifier.clone(),
SendPropDefinition::VectorXY { identifier, .. } => identifier.clone(),
SendPropDefinition::Array { identifier, .. } => identifier.clone(),
}
}
}
impl TryFrom<&RawSendPropDefinition> for SendPropDefinition {
type Error = MalformedSendPropDefinitionError;
fn try_from(definition: &RawSendPropDefinition) -> std::result::Result<Self, Self::Error> {
let identifier = definition.identifier.clone();
match definition.prop_type {
SendPropType::Int => {
if definition.flags.contains(SendPropFlag::NormalVarInt) {
Ok(SendPropDefinition::NormalVarInt {
identifier,
unsigned: definition.flags.contains(SendPropFlag::Unsigned),
})
} else if definition.flags.contains(SendPropFlag::Unsigned) {
Ok(SendPropDefinition::UnsignedInt {
identifier,
bit_count: definition.bit_count.unwrap_or(32) as u8,
})
} else {
Ok(SendPropDefinition::Int {
identifier,
bit_count: definition.bit_count.unwrap_or(32) as u8,
})
}
}
SendPropType::Float => Ok(SendPropDefinition::Float {
identifier,
definition: FloatDefinition::new(
definition.flags,
definition.bit_count,
definition.high_value,
definition.low_value,
)?,
}),
SendPropType::String => Ok(SendPropDefinition::String { identifier }),
SendPropType::Vector => Ok(SendPropDefinition::Vector {
identifier,
definition: FloatDefinition::new(
definition.flags,
definition.bit_count,
definition.high_value,
definition.low_value,
)?,
}),
SendPropType::VectorXY => Ok(SendPropDefinition::VectorXY {
identifier,
definition: FloatDefinition::new(
definition.flags,
definition.bit_count,
definition.high_value,
definition.low_value,
)?,
}),
SendPropType::Array => {
let count_bit_count = log_base2(
definition
.element_count
.ok_or(MalformedSendPropDefinitionError::UnsizedArray)?,
) as u16
+ 1;
let child_definition = definition
.array_property
.as_deref()
.ok_or(MalformedSendPropDefinitionError::UntypedArray)?;
Ok(SendPropDefinition::Array {
identifier,
inner_definition: Box::new(SendPropDefinition::try_from(child_definition)?),
count_bit_count,
})
}
_ => Err(MalformedSendPropDefinitionError::InvalidPropType),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SendPropValue {
@ -385,108 +558,90 @@ impl fmt::Display for SendPropValue {
impl SendPropValue {
pub fn parse(stream: &mut Stream, definition: &SendPropDefinition) -> Result<Self> {
match definition.prop_type {
SendPropType::Int => Self::read_int(stream, definition).map(SendPropValue::from),
SendPropType::Float => Self::read_float(stream, definition).map(SendPropValue::from),
SendPropType::String => Self::read_string(stream, definition).map(SendPropValue::from),
SendPropType::Vector => Self::read_vector(stream, definition).map(SendPropValue::from),
SendPropType::VectorXY => {
Self::read_vector_xy(stream, definition).map(SendPropValue::from)
}
SendPropType::Array => Self::read_array(stream, definition).map(SendPropValue::from),
_ => Err(MalformedSendPropDefinitionError::InvalidPropType.into()),
}
}
fn read_int(stream: &mut Stream, definition: &SendPropDefinition) -> Result<i64> {
if definition.flags.contains(SendPropFlag::NormalVarInt) {
read_var_int(stream, !definition.flags.contains(SendPropFlag::Unsigned))
match definition {
SendPropDefinition::NormalVarInt { unsigned, .. } => read_var_int(stream, !*unsigned)
.map_err(ParseError::from)
.map(|int| int as i64)
} else if definition.flags.contains(SendPropFlag::Unsigned) {
let unsigned: u32 = stream.read_sized(definition.bit_count.unwrap_or(32) as usize)?;
Ok(unsigned as i64)
} else {
stream
.read_int(definition.bit_count.unwrap_or(32) as usize)
.map(SendPropValue::from),
SendPropDefinition::UnsignedInt { bit_count, .. } => {
Ok((stream.read_sized::<u32>(*bit_count as usize)? as i64).into())
}
SendPropDefinition::Int { bit_count, .. } => stream
.read_int::<i32>((*bit_count) as usize)
.map_err(ParseError::from)
.map(SendPropValue::from),
SendPropDefinition::Float {
definition: float_definition,
..
} => Self::read_float(stream, float_definition).map(SendPropValue::from),
SendPropDefinition::String { .. } => {
let length = stream.read_int(9)?;
stream
.read_sized::<String>(length)
.map_err(ParseError::from)
.map(SendPropValue::from)
}
SendPropDefinition::Vector {
definition: float_definition,
..
} => Ok(Vector {
x: Self::read_float(stream, float_definition)?,
y: Self::read_float(stream, float_definition)?,
z: Self::read_float(stream, float_definition)?,
}
fn read_array(
stream: &mut Stream,
definition: &SendPropDefinition,
) -> Result<Vec<SendPropValue>> {
let num_bits = log_base2(
definition
.element_count
.ok_or(MalformedSendPropDefinitionError::UnsizedArray)?,
) + 1;
let count = stream.read_int(num_bits as usize)?;
.into()),
SendPropDefinition::VectorXY {
definition: float_definition,
..
} => Ok(VectorXY {
x: Self::read_float(stream, float_definition)?,
y: Self::read_float(stream, float_definition)?,
}
.into()),
SendPropDefinition::Array {
count_bit_count,
inner_definition,
..
} => {
let count = stream.read_int(*count_bit_count as usize)?;
let mut values = Vec::with_capacity(min(count, 128));
let child_definition = definition
.array_property
.as_ref()
.ok_or(MalformedSendPropDefinitionError::UntypedArray)?;
for _ in 0..count {
values.push(Self::parse(stream, child_definition)?);
values.push(Self::parse(stream, inner_definition)?);
}
Ok(values)
Ok(values.into())
}
}
}
fn read_string(stream: &mut Stream, _definition: &SendPropDefinition) -> Result<String> {
let length = stream.read_int(9)?;
stream.read_sized(length).map_err(ParseError::from)
}
fn read_vector(stream: &mut Stream, definition: &SendPropDefinition) -> Result<Vector> {
Ok(Vector {
x: Self::read_float(stream, definition)?,
y: Self::read_float(stream, definition)?,
z: Self::read_float(stream, definition)?,
})
}
fn read_vector_xy(stream: &mut Stream, definition: &SendPropDefinition) -> Result<VectorXY> {
Ok(VectorXY {
x: Self::read_float(stream, definition)?,
y: Self::read_float(stream, definition)?,
})
}
fn read_float(stream: &mut Stream, definition: &SendPropDefinition) -> Result<f32> {
if definition.flags.contains(SendPropFlag::Coord) {
read_bit_coord(stream).map_err(ParseError::from)
} else if definition.flags.contains(SendPropFlag::CoordMP) {
fn read_float(stream: &mut Stream, definition: &FloatDefinition) -> Result<f32> {
match definition {
FloatDefinition::Coord => read_bit_coord(stream).map_err(ParseError::from),
FloatDefinition::CoordMP => {
read_bit_coord_mp(stream, false, false).map_err(ParseError::from)
} else if definition.flags.contains(SendPropFlag::CoordMPLowPrecision) {
}
FloatDefinition::CoordMPLowPrecision => {
read_bit_coord_mp(stream, false, true).map_err(ParseError::from)
} else if definition.flags.contains(SendPropFlag::CoordMPIntegral) {
}
FloatDefinition::CoordMPIntegral => {
read_bit_coord_mp(stream, true, false).map_err(ParseError::from)
} else if definition.flags.contains(SendPropFlag::NoScale) {
stream.read().map_err(ParseError::from)
} else if definition.flags.contains(SendPropFlag::NormalVarInt) {
read_bit_normal(stream).map_err(ParseError::from)
} else {
let bit_count = definition
.bit_count
.ok_or(MalformedSendPropDefinitionError::UnsizedFloat)?;
let high = definition
.high_value
.ok_or(MalformedSendPropDefinitionError::UnsizedFloat)?;
let low = definition
.low_value
.ok_or(MalformedSendPropDefinitionError::UnsizedFloat)?;
let raw: u32 = stream.read_int(bit_count as usize)?;
}
FloatDefinition::FloatNoScale => stream.read().map_err(ParseError::from),
FloatDefinition::NormalVarFloat => read_bit_normal(stream).map_err(ParseError::from),
FloatDefinition::Scaled {
bit_count,
low,
high,
} => {
let raw: u32 = stream.read_int(*bit_count as usize)?;
// is this -1 correct?, it is consistent with the js version but seems weird
let percentage = (raw as f32) / ((1i32.wrapping_shl(bit_count)) as f32 - 1.0);
let percentage =
(raw as f32) / ((1i32.wrapping_shl(*bit_count as u32)) as f32 - 1.0);
Ok(low + ((high - low) * percentage))
}
}
}
}
impl From<i32> for SendPropValue {
@ -601,10 +756,18 @@ impl SendPropDefinitionIndex {
}
}
#[derive(Debug, Display)]
#[display("{owner_table}::{name}")]
pub struct SendPropIdentifier {
pub index: SendPropDefinitionIndex,
pub name: SendPropName,
pub owner_table: SendTableName,
}
#[derive(Debug, Clone, Display)]
#[display("{definition.owner_table}::{definition.name} = {value}")]
#[display("{identifier} = {value}")]
pub struct SendProp {
pub definition: Rc<SendPropDefinition>,
pub identifier: Rc<SendPropIdentifier>,
pub value: SendPropValue,
}

2
tests/entity.rs
View file

@ -54,7 +54,7 @@ impl EntityDump {
.into_iter()
.map(|prop| {
(
format!("{}.{}", prop.definition.owner_table, prop.definition.name),
format!("{}.{}", prop.identifier.owner_table, prop.identifier.name),
prop.value,
)
})

2
tests/sendprops.rs
View file

@ -48,7 +48,7 @@ fn flatten_test(input_file: &str, snapshot_file: &str) {
table
.flatten_props(&send_tables)
.into_iter()
.map(|prop| format!("{}.{}", prop.owner_table, prop.name))
.map(|prop| format!("{}.{}", prop.identifier.owner_table, prop.identifier.name))
.collect(),
)
})