Update some other minor parts

analysis/src/heatmap.rs

@@ -44,7 +44,8 @@ impl HeatMap {
 
 #[derive(Debug)]
 pub struct HeatMapOutput {
-    pub player_heatmaps: std::collections::HashMap<csdemo::UserId, HeatMap>,
+    pub player_heatmaps: std::collections::HashMap<i32, HeatMap>,
+    pub entity_to_player: std::collections::HashMap<i32, csdemo::UserId>,
     pub player_info: std::collections::HashMap<csdemo::UserId, csdemo::parser::Player>,
 }
 
@@ -89,10 +90,9 @@ pub fn parse(config: &Config, buf: &[u8]) -> Result<HeatMapOutput, ()> {
     tracing::debug!("Pawn-IDs: {:?}", pawn_ids);
 
     let mut entity_id_to_user = std::collections::HashMap::<i32, csdemo::UserId>::new();
-    let mut player_lifestate = std::collections::HashMap::<csdemo::UserId, u32>::new();
+    let mut player_lifestate = std::collections::HashMap::<i32, u32>::new();
-    let mut player_position = std::collections::HashMap::<csdemo::UserId, (f32, f32, f32)>::new();
+    let mut player_position = std::collections::HashMap::<i32, (f32, f32, f32)>::new();
     let mut player_cells = std::collections::HashMap::new();
-    let mut unknown_player_entities = std::collections::HashSet::new();
 
     let mut heatmaps = std::collections::HashMap::new();
     for tick_state in output.entity_states.ticks.iter() {
@@ -107,16 +107,13 @@ pub fn parse(config: &Config, buf: &[u8]) -> Result<HeatMapOutput, ()> {
             &mut player_position,
             &mut player_cells,
             &mut heatmaps,
-            &mut unknown_player_entities,
         );
     }
 
-    if !unknown_player_entities.is_empty() {
-        tracing::warn!("Unknown Player Entities: {:?}", unknown_player_entities);
-    }
 
     Ok(HeatMapOutput {
         player_heatmaps: heatmaps,
+        entity_to_player: entity_id_to_user,
         player_info: output.player_info,
     })
 }
@@ -141,37 +138,25 @@ fn process_tick(
     tick_state: &csdemo::parser::EntityTickStates,
     entity_id_to_user: &mut std::collections::HashMap<i32, csdemo::UserId>,
     pawn_ids: &std::collections::HashMap<i32, csdemo::UserId>,
-    player_lifestate: &mut std::collections::HashMap<csdemo::UserId, u32>,
+    player_lifestate: &mut std::collections::HashMap<i32, u32>,
-    player_position: &mut std::collections::HashMap<csdemo::UserId, (f32, f32, f32)>,
+    player_position: &mut std::collections::HashMap<i32, (f32, f32, f32)>,
-    player_cells: &mut std::collections::HashMap<csdemo::UserId, (u32, u32, u32)>,
+    player_cells: &mut std::collections::HashMap<i32, (u32, u32, u32)>,
-    heatmaps: &mut std::collections::HashMap<csdemo::UserId, HeatMap>,
+    heatmaps: &mut std::collections::HashMap<i32, HeatMap>,
-    unknown_player_entities: &mut std::collections::HashSet<i32>,
 ) {
     for entity_state in tick_state
         .states
         .iter()
         .filter(|s| s.class == "CCSPlayerPawn")
     {
-        let user_id = match get_entityid(&entity_state.props) {
+        if let Some(pawn_id) = get_entityid(&entity_state.props) {
-            Some(pawn_id) => {
+            let user_id = pawn_ids.get(&pawn_id).cloned().unwrap();
-                let user_id = pawn_ids.get(&pawn_id).cloned().unwrap();
+            entity_id_to_user.insert(entity_state.id, user_id.clone());
+        }
 
-                entity_id_to_user.insert(entity_state.id, user_id.clone());
+        let user_id = entity_state.id;
-                user_id.clone()
-            }
-            None => {
-                match entity_id_to_user.get(&entity_state.id).cloned() {
-                    Some(user) => user,
-                    None => {
-                        unknown_player_entities.insert(entity_state.id);
-                        continue;
-                    }
-                }
-            }
-        }; 
 
         let _inner_guard =
-            tracing::trace_span!("Entity", ?user_id, entity_id=?entity_state.id).entered();
+            tracing::trace_span!("Entity", entity_id=?entity_state.id).entered(); 
 
         let x_cell = match entity_state.get_prop("CCSPlayerPawn.CBodyComponentBaseAnimGraph.m_cellX").map(|prop| prop.value.as_u32()).flatten() {
             Some(c) => c,

analysis/tests/heatmap.rs

@@ -26,3 +26,29 @@ fn heatmap_inferno() {
 
     assert_eq!(result.player_heatmaps.len(), result.player_info.len(), "Players: {:?}", result.player_heatmaps.keys().collect::<Vec<_>>());
 }
+
+#[test]
+#[traced_test]
+fn heatmap_dust2() {
+    let path = concat!(env!("CARGO_MANIFEST_DIR"), "/../testfiles/dust2.dem");
+    dbg!(path);
+    let input_bytes = std::fs::read(path).unwrap();
+
+    let config = heatmap::Config { cell_size: 5.0 };
+    let result = heatmap::parse(&config, &input_bytes).unwrap();
+
+    assert_eq!(result.player_heatmaps.len(), result.player_info.len(), "Players: {:?}", result.player_heatmaps.keys().collect::<Vec<_>>());
+    assert_eq!(
+        result.player_info.len(),
+        result.entity_to_player.len(),
+        "Missing Entity-to-Player: {:?} - Missing Player-Info: {:?}",
+        result.player_heatmaps.keys().filter(|entity| !result.entity_to_player.contains_key(*entity)).collect::<Vec<_>>(),
+        result.player_info.iter().filter_map(|(user_id, info)| {
+            if result.entity_to_player.values().any(|p| p == user_id) {
+                return None;
+            }
+
+            Some(info)
+        }).collect::<Vec<_>>(),
+    );
+}

backend/src/analysis.rs

@@ -133,9 +133,17 @@ pub fn analyse_heatmap(input: AnalysisInput) -> std::collections::HashMap<String
     };
     let result = analysis::heatmap::parse(&config, &mmap).unwrap();
 
-    tracing::info!("Got {} Heatmaps", result.player_heatmaps.len());
+    tracing::info!("Got {} Entity-Heatmaps", result.player_heatmaps.len());
-    result.player_heatmaps.into_iter().filter_map(|(userid, heatmap)| {
+    result.player_heatmaps.into_iter().filter_map(|(entity_id, heatmap)| {
-        let player = match result.player_info.get(&userid) {
+        let userid = match result.entity_to_player.get(&entity_id) {
+            Some(u) => u,
+            None => {
+                tracing::warn!("Could not find User for Entity: {:?}", entity_id);
+                return None;
+            }
+        };
+
+        let player = match result.player_info.get(userid) {
             Some(p) => p,
             None => {
                 tracing::warn!("Could not find player: {:?}", userid);

frontend/src/demo/heatmap.rs

@@ -72,7 +72,7 @@ fn heatmap_view(heatmaps: Vec<common::demo_analysis::PlayerHeatmap>) -> impl lep
                     move || {
                         match value.get() {
                             Some(heatmap) => view! {
-                                <img class="heatmap_img" src=format!("data:image/jpeg;base64,{}", heatmap.png_data) />
+                                <img class="heatmap_img" src=format!("data:image/png;base64,{}", heatmap.png_data) />
                             }.into_any(),
                             None => view! { <p>ERROR</p> }.into_any(),
                         }

frontend/src/main.rs

@@ -14,8 +14,6 @@ async fn load_demos() -> Vec<common::BaseDemoInfo> {
 }
 
 fn main() {
-    let async_data = create_resource(|| (), |_| async move { load_demos().await });
-
     let (upload_demo_read, upload_demo_write) = create_signal(frontend::DemoUploadStatus::Hidden);
 
     mount_to_body(move || {