early state handling

src/demo/message/gameevent.rs

@@ -34,7 +34,7 @@ impl Parse for GameEventMessage {
             Some(definition) => {
                 let mut values: Vec<GameEventValue> = Vec::with_capacity(definition.entries.len());
                 for entry in &definition.entries {
-                    values.push(read_event_value(stream, &entry)?);
+                    values.push(read_event_value(&mut data, &entry)?);
                 }
 
                 RawGameEvent {
@@ -53,7 +53,7 @@ impl Parse for GameEventMessage {
 
 #[derive(Debug)]
 pub struct GameEventListMessage {
-    event_list: HashMap<GameEventType, GameEventDefinition>,
+    pub event_list: HashMap<GameEventType, GameEventDefinition>,
 }
 
 impl BitRead<LittleEndian> for GameEventDefinition {

src/demo/message/mod.rs

@@ -25,7 +25,7 @@ pub mod gameevent;
 pub mod packetentities;
 pub mod tempentities;
 
-#[derive(Primitive, Debug)]
+#[derive(Primitive, Debug, Clone, Copy)]
 pub enum MessageType {
     Empty = 0,
     File = 2,
@@ -100,7 +100,6 @@ pub enum Message {
 impl Parse for Message {
     fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
         let message_type = MessageType::parse(stream, state)?;
-        dbg!(&message_type);
         Ok(match message_type {
             MessageType::Empty => Message::Empty,
             MessageType::File => Message::File(FileMessage::parse(stream, state)?),

src/demo/message/packetentities.rs

@@ -4,7 +4,7 @@ use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
 use crate::demo::packet::datatable::ServerClass;
 use crate::demo::sendprop::SendProp;
 
-#[derive(Debug)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct EntityId(u32);
 
 #[derive(BitRead, Clone, Copy, Debug)]

src/demo/packet/message.rs

@@ -4,14 +4,14 @@ use crate::demo::vector::Vector;
 
 #[derive(Debug)]
 pub struct MessagePacket {
-    tick: u32,
-    messages: Vec<Message>,
-    view_origin: (Vector, Vector),
-    view_angles: (Vector, Vector),
-    local_view_angles: (Vector, Vector),
-    sequence_in: u32,
-    sequence_out: u32,
-    flags: u32, // TODO
+    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 flags: u32, // TODO
 }
 
 impl Parse for MessagePacket {

src/demo/parser/mod.rs

@@ -97,16 +97,15 @@ impl DemoParser {
         Ok(())
     }
 
-    pub fn parse_demo(mut self) -> Result<(Header, Vec<Packet>)> {
+    pub fn parse_demo(mut self) -> Result<(Header, ParserState)> {
         let header = self.read::<Header>()?;
-        let mut packets = vec![];
         loop {
             let packet = self.read::<Packet>()?;
             match packet {
                 Packet::Stop(_) => break,
-                packet => packets.push(packet),
+                packet => self.state.handle_packet(packet),
             }
         }
-        Ok((header, packets))
+        Ok((header, self.state))
     }
 }

src/demo/parser/state.rs

@@ -1,16 +1,26 @@
+use std::collections::HashMap;
+
+use crate::demo::gameevent_gen::GameEventType;
 use crate::demo::gamevent::GameEventDefinition;
+use crate::demo::message::Message;
+use crate::demo::message::packetentities::EntityId;
+use crate::demo::packet::datatable::{SendTable, ServerClass};
+use crate::demo::packet::Packet;
+use crate::demo::packet::stringtable::StringTable;
 use crate::demo::sendprop::SendProp;
 use crate::Stream;
-use std::collections::HashMap;
-use crate::demo::packet::stringtable::StringTable;
-use crate::demo::gameevent_gen::GameEventType;
 
 #[derive(Default, Debug)]
 pub struct ParserState {
     pub version: u32,
     pub static_baselines: HashMap<u32, StaticBaseline>,
     pub event_definitions: HashMap<GameEventType, GameEventDefinition>,
-    pub string_tables: Vec<StringTable>
+    pub string_tables: Vec<StringTable>,
+    pub entity_classes: HashMap<EntityId, ServerClass>,
+    pub send_tables: HashMap<String, SendTable>,
+    pub server_classes: Vec<ServerClass>,
+    pub instance_baselines: [HashMap<EntityId, Vec<SendProp>>; 2],
+    pub tick: u32,
 }
 
 #[derive(Debug)]
@@ -24,4 +34,24 @@ impl ParserState {
     pub fn new() -> Self {
         ParserState::default()
     }
+
+    pub fn handle_packet(&mut self, packet: Packet) {
+        match packet {
+            Packet::Message(packet) | Packet::Sigon(packet) => {
+                for message in packet.messages {
+                    self.handle_message(message);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn handle_message(&mut self, message: Message) {
+        match message {
+            Message::GameEventList(message) => {
+                self.event_definitions = message.event_list;
+            }
+            _ => {}
+        }
+    }
 }