userinfo in player, pitch angle, ticker.next()

src/demo/parser/gamestateanalyser.rs

@@ -1,12 +1,14 @@
 use crate::demo::message::packetentities::{EntityId, PacketEntity};
 use crate::demo::message::Message;
 use crate::demo::packet::datatable::{ParseSendTable, SendTableName, ServerClass, ServerClassName};
+use crate::demo::packet::stringtable::StringTableEntry;
+use crate::demo::parser::analyser::UserInfo;
 pub use crate::demo::parser::analyser::{Class, Team, UserId};
 use crate::demo::parser::handler::BorrowMessageHandler;
 use crate::demo::parser::MessageHandler;
 use crate::demo::sendprop::{SendProp, SendPropIdentifier, SendPropName, SendPropValue};
 use crate::demo::vector::{Vector, VectorXY};
-use crate::{MessageType, ParserState};
+use crate::{MessageType, ParserState, ReadResult, Stream};
 use fnv::FnvHashMap;
 use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
@@ -42,7 +44,9 @@ pub struct Player {
     pub class: Class,
     pub team: Team,
     pub view_angle: f32,
+    pub pitch_angle: f32,
     pub state: PlayerState,
+    pub info: Option<UserInfo>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -127,7 +131,9 @@ impl GameState {
                     class: Class::Other,
                     team: Team::Other,
                     view_angle: 0.0,
+                    pitch_angle: 0.0,
                     state: PlayerState::Alive,
+                    info: None,
                 };
 
                 let index = self.players.len();
@@ -183,6 +189,15 @@ impl MessageHandler for GameStateAnalyser {
             .collect();
     }
 
+    fn handle_string_entry(&mut self, table: &str, _index: usize, entry: &StringTableEntry) {
+        if table == "userinfo" {
+            let _ = self.parse_user_info(
+                entry.text.as_ref().map(|s| s.as_ref()),
+                entry.extra_data.as_ref().map(|data| data.data.clone()),
+            );
+        }
+    }
+
     fn into_output(self, _state: &ParserState) -> Self::Output {
         self.state
     }
@@ -278,6 +293,9 @@ impl GameStateAnalyser {
                             "m_angEyeAngles[1]" => {
                                 player.view_angle = f32::try_from(&prop.value).unwrap_or_default()
                             }
+                            "m_angEyeAngles[0]" => {
+                                player.pitch_angle = f32::try_from(&prop.value).unwrap_or_default()
+                            }
                             _ => {}
                         }
                     }
@@ -307,4 +325,13 @@ impl GameStateAnalyser {
             })
         }
     }
+
+    fn parse_user_info(&mut self, text: Option<&str>, data: Option<Stream>) -> ReadResult<()> {
+        if let Some(user_info) = crate::demo::data::UserInfo::parse_from_string_table(text, data)? {
+            let id = user_info.entity_id;
+            self.state.get_or_create_player(id).info = Some(user_info.into());
+        }
+
+        Ok(())
+    }
 }

src/demo/parser/handler.rs

@@ -23,7 +23,7 @@ pub trait MessageHandler {
 }
 
 pub trait BorrowMessageHandler: MessageHandler {
-    fn borrow_output(&self, state: &ParserState) -> &Self::Output;
+    fn borrow_output(&self, _state: &ParserState) -> &Self::Output;
 }
 
 pub struct NullHandler;
@@ -162,12 +162,12 @@ impl<'a, T: MessageHandler> DemoHandler<'a, T> {
         self.analyser.into_output(&self.state_handler)
     }
 
-    pub fn get_parser_state(&'a self) -> &ParserState {
+    pub fn get_parser_state(&self) -> &ParserState {
         &self.state_handler
     }
 }
 
-impl<'a, T: MessageHandler + BorrowMessageHandler> DemoHandler<'a, T> {
+impl<T: MessageHandler + BorrowMessageHandler> DemoHandler<'_, T> {
     pub fn borrow_output(&self) -> &T::Output {
         self.analyser.borrow_output(&self.state_handler)
     }

src/demo/parser/mod.rs

@@ -177,8 +177,36 @@ impl<'a, A: MessageHandler> DemoTicker<'a, A> {
     }
 }
 
-impl<A: MessageHandler + BorrowMessageHandler> DemoTicker<'_, A> {
+impl<'a, A: MessageHandler + BorrowMessageHandler> DemoTicker<'a, A> {
     pub fn state(&self) -> &A::Output {
         self.handler.borrow_output()
     }
+
+    pub fn parser_state(&self) -> &ParserState {
+        self.handler.get_parser_state()
+    }
+
+    /// Process the next packet
+    pub fn next(&mut self) -> Result<Option<Tick<A::Output>>> {
+        Ok(
+            if let Some(packet) = self.packets.next(&self.handler.state_handler)? {
+                let tick = packet.tick();
+                self.handler.handle_packet(packet)?;
+
+                Some(Tick {
+                    state: self.handler.borrow_output(),
+                    parser_state: self.handler.get_parser_state(),
+                    tick,
+                })
+            } else {
+                None
+            },
+        )
+    }
+}
+
+pub struct Tick<'a, State> {
+    pub state: &'a State,
+    pub parser_state: &'a ParserState,
+    pub tick: u32,
 }

src/demo/vector.rs

@@ -11,6 +11,12 @@ pub struct Vector {
     pub z: f32,
 }
 
+impl From<Vector> for [f32; 3] {
+    fn from(vec: Vector) -> Self {
+        [vec.x, vec.y, vec.z]
+    }
+}
+
 impl PartialEq for Vector {
     fn eq(&self, other: &Self) -> bool {
         (self.x - other.x < 0.001) && (self.y - other.y < 0.001) && (self.z - other.z < 0.001)