halve framerate

src/lib.rs

@@ -1,8 +1,9 @@
 #![feature(const_generics)]
+#![allow(incomplete_features)]
 #![macro_use]
 
 use crate::state::ParsedDemo;
-use tf_demo_parser::demo::parser::gamestateanalyser::{GameState, GameStateAnalyser};
+use tf_demo_parser::demo::parser::gamestateanalyser::GameStateAnalyser;
 use tf_demo_parser::{Demo, DemoParser, ParseError};
 use wasm_bindgen::prelude::*;
 
@@ -17,7 +18,7 @@ pub fn parse_demo(buffer: Box<[u8]>) -> Result<(), JsValue> {
     let buffer = buffer.into_vec();
     let parsed = parse_demo_inner(buffer).map_err(|e| JsValue::from(e.to_string()))?;
 
-    log!("{:?}", parsed.players[2].get(10));
+    log!("{:?}, size {}", parsed.players[2].get(10), parsed.size());
 
     Ok(())
 }
@@ -25,12 +26,17 @@ pub fn parse_demo(buffer: Box<[u8]>) -> Result<(), JsValue> {
 pub fn parse_demo_inner(buffer: Vec<u8>) -> Result<ParsedDemo, ParseError> {
     let demo = Demo::new(buffer);
     let parser = DemoParser::new_with_analyser(demo.get_stream(), GameStateAnalyser::default());
-    let (header, mut ticker) = parser.ticker()?;
+    let (_header, mut ticker) = parser.ticker()?;
 
     let mut parsed_demo = ParsedDemo::new();
 
+    let mut skip = false;
     while ticker.tick()? {
-        parsed_demo.push_state(ticker.state());
+        if !skip {
+            // halve framerate
+            parsed_demo.push_state(ticker.state());
+        }
+        skip = !skip;
     }
 
     Ok(parsed_demo)

src/state.rs

@@ -1,10 +1,7 @@
 use std::ops::Index;
 use tf_demo_parser::demo::parser::gamestateanalyser::{Class, GameState, Team};
 use tf_demo_parser::demo::vector::VectorXY;
-
-macro_rules! log {
-    ($($arg:tt)*) => (web_sys::console::log_1(&wasm_bindgen::prelude::JsValue::from(format!($($arg)*))))
-}
+use wasm_bindgen::prelude::*;
 
 #[derive(Debug, Clone, Copy, Default)]
 pub struct Angle(u16);
@@ -53,6 +50,12 @@ impl ParsedDemo {
         }
         self.tick += 1;
     }
+
+    pub fn size(&self) -> usize {
+        self.players
+            .iter()
+            .fold(0, |size, player| size + player.size())
+    }
 }
 
 #[derive(Debug, Default, Clone)]
@@ -113,6 +116,14 @@ impl ParsedPlayer {
             class: self.class[index],
         }
     }
+
+    pub fn size(&self) -> usize {
+        self.position.len() * std::mem::size_of::<VectorXY>()
+            + self.team.size()
+            + self.class.size()
+            + self.health.size()
+            + self.angle.size()
+    }
 }
 
 #[derive(Debug, Default, Clone)]
@@ -120,6 +131,12 @@ pub struct SparseVec<T: Default, const N: usize> {
     inner: Vec<T>,
 }
 
+impl<T: Default, const N: usize> SparseVec<T, N> {
+    pub fn size(&self) -> usize {
+        self.inner.len() * std::mem::size_of::<T>()
+    }
+}
+
 impl<T: Default, const N: usize> SparseVec<T, N> {
     fn push_index(&mut self, index: usize, val: T) {
         if index % N == 0 {