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

read some common, but rarely important for us, values lazily

Browse source
This commit is contained in:
Robin Appelman 2019-03-03 17:51:07 +01:00
commit 5886debbfb
4 changed files with 44 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/demo/packet/consolecmd.rs
View file

@ -1,11 +1,11 @@
use bitstream_reader::{BitRead, LittleEndian};
use bitstream_reader::{BitRead, LittleEndian, LazyBitReadSized};
use crate::{ReadResult, Stream};
#[derive(Debug)]
pub struct ConsoleCmdPacket {
tick: u32,
command: String,
command: LazyBitReadSized<String, LittleEndian>,
}
impl BitRead<LittleEndian> for ConsoleCmdPacket {
@ -13,7 +13,7 @@ impl BitRead<LittleEndian> for ConsoleCmdPacket {
let tick = stream.read_int(32)?;
let len = stream.read_int::<usize>(32)?;
let mut packet_data = stream.read_bits(len * 8)?;
let command = packet_data.read_string(Some(len))?;
let command = packet_data.read_sized(len)?;
Ok(ConsoleCmdPacket { tick, command })
}
}

46
src/demo/packet/message.rs
View file

@ -1,30 +1,54 @@
use bitstream_reader::{BitRead, BitSize, LittleEndian, LazyBitRead};
use crate::{Parse, ParseError, ParserState, Result, Stream, ReadResult};
use crate::demo::message::Message;
use crate::demo::vector::Vector;
use crate::{Parse, ParseError, ParserState, Result, Stream};
#[derive(Debug)]
pub struct MessagePacket {
pub tick: u32,
pub messages: Vec<Message>,
pub view_origin: (Vector, Vector),
pub view_angles: (Vector, Vector),
pub local_view_angles: (Vector, Vector),
pub sequence_in: u32,
pub sequence_out: u32,
pub view_angles: LazyBitRead<ViewAngles, LittleEndian>,
pub flags: u32, // TODO
}
#[derive(Clone, Debug)]
pub struct ViewAngles {
pub origin: (Vector, Vector),
pub angles: (Vector, Vector),
pub local_angles: (Vector, Vector),
}
impl BitSize for ViewAngles {
fn bit_size() -> usize {
Vector::bit_size() * 6
}
}
impl BitRead<LittleEndian> for ViewAngles {
fn read(stream: &mut Stream) -> ReadResult<Self> {
let view_origin_1 = Vector::read(stream)?;
let view_angle_1 = Vector::read(stream)?;
let local_view_angle_1 = Vector::read(stream)?;
let origin = (Vector::read(stream)?, view_origin_1);
let angles = (Vector::read(stream)?, view_angle_1);
let local_angles = (Vector::read(stream)?, local_view_angle_1);
Ok(ViewAngles {
origin,
angles,
local_angles,
})
}
}
impl Parse for MessagePacket {
fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
let tick = stream.read()?;
let flags = stream.read()?;
let view_origin_1 = Vector::parse(stream, state)?;
let view_angle_1 = Vector::parse(stream, state)?;
let local_view_angle_1 = Vector::parse(stream, state)?;
let view_origin = (Vector::parse(stream, state)?, view_origin_1);
let view_angles = (Vector::parse(stream, state)?, view_angle_1);
let local_view_angles = (Vector::parse(stream, state)?, local_view_angle_1);
let view_angles = stream.read()?;
let sequence_in = stream.read()?;
let sequence_out = stream.read()?;
@ -43,9 +67,7 @@ impl Parse for MessagePacket {
let packet = MessagePacket {
tick,
messages,
view_origin,
view_angles,
local_view_angles,
sequence_in,
sequence_out,
flags,

8
src/demo/packet/usercmd.rs
View file

@ -10,10 +10,10 @@ pub struct UserCmdPacket {
impl BitRead<LittleEndian> for UserCmdPacket {
fn read(stream: &mut Stream) -> ReadResult<Self> {
let tick = stream.read_int(32)?;
let sequence_out = stream.read_int(32)?;
let len = stream.read_int::<usize>(32)?;
let mut _packet_data = stream.read_bits(len * 8)?;
let tick = stream.read()?;
let sequence_out = stream.read()?;
let len:u32 = stream.read()?;
let mut _packet_data = stream.read_bits(len as usize * 8)?;
// TODO parse the packet data
Ok(UserCmdPacket { tick, sequence_out })
}

16
src/demo/vector.rs
View file

@ -1,26 +1,16 @@
use bitstream_reader::{BitRead, LittleEndian};
use bitstream_reader::{BitRead, LittleEndian, BitSize};
use serde::Serialize;
use crate::{ReadResult, Stream};
#[derive(Debug, Clone, Copy, Default, Serialize)]
#[derive(BitRead, BitSize, Debug, Clone, Copy, Default, Serialize)]
pub struct Vector {
pub x: f32,
pub y: f32,
pub z: f32,
}
impl BitRead<LittleEndian> for Vector {
fn read(stream: &mut Stream) -> ReadResult<Self> {
Ok(Vector {
x: stream.read()?,
y: stream.read()?,
z: stream.read()?,
})
}
}
#[derive(BitRead, Debug, Clone, Copy, Default, Serialize)]
#[derive(BitRead, BitSize, Debug, Clone, Copy, Default, Serialize)]
pub struct VectorXY {
pub x: f32,
pub y: f32,