Add the option to generate heatmaps with the killer position rather than the victim position

Author: Tails8521

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "coldmaps"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Tails8521 <tails8521@gmail.com>"]
 edition = "2018"
 

Cargo.toml

@@ -5,7 +5,7 @@ A tool for creating heatmaps from Team Fortress 2 demos
 
 # Download
 
-Check the [releases page](https://github.com/Tails8521/coldmaps/releases) and download the latest version, the .exe is under Assets
+Check the [releases page](https://github.com/Tails8521/coldmaps/releases) and download the latest version
 
 # How to use
 
@@ -16,7 +16,7 @@ Tip: You can use setpos \<x> \<y> \<z> to position yourself accurately
 4: Drag and drop the demo(s) you want to use for the heatmap  
 5: Fill the camera coordinates and zoom level, don't forget to tick the checkbox corresponding to what type of coordinates you used (cl_showpos or the console)  
 6: Click on the "Process demos" button to begin the demo analysis, once it has completed, you can click on the "Generate heatmap" and the heatmap should appear in the preview pane  
-7: The "Export image" button lets you export the heatmap as an image file, don't forget to specify the file extension in the file name you save as (don't type "my heatmap" but rather "my heatmap.png")
+7: The "Export image" button lets you export the heatmap as an image file
 
 # How to build
 

README.md

@@ -26,6 +26,27 @@ impl Display for CoordsType {
     }
 }
 
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum HeatmapType {
+    VictimPosition,
+    KillerPosition,
+}
+
+impl Default for HeatmapType {
+    fn default() -> Self {
+        Self::VictimPosition
+    }
+}
+
+impl Display for HeatmapType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            HeatmapType::VictimPosition => write!(f, "Victim position"),
+            HeatmapType::KillerPosition => write!(f, "Killer position"),
+        }
+    }
+}
+
 #[derive(Debug)]
 struct HeatMapParameters {
     screen_width: f32,
@@ -79,6 +100,7 @@ impl HeatMapGenerator {
 
     pub fn generate_heatmap<'a>(
         &self,
+        heatmap_type: HeatmapType,
         deaths: impl IntoIterator<Item = &'a Death>,
         image: &mut ImageBuffer<Rgb<u8>, Vec<u8>>,
     ) {
@@ -96,7 +118,11 @@ impl HeatMapGenerator {
             // LinSrgba::new(1.0, 1.0, 1.0, 1.0),
         ]);
         for death in deaths {
-            if let Some(entity_state) = &death.victim_entity_state {
+            let entity_state = match heatmap_type {
+                HeatmapType::VictimPosition => &death.victim_entity_state,
+                HeatmapType::KillerPosition => &death.killer_entity_state,
+            };
+            if let Some(entity_state) = entity_state {
                 let game_coords = entity_state.position;
                 let (x_f, y_f) = self.game_coords_to_screen_coords(game_coords.x, game_coords.y);
                 let x_i = x_f.round() as i32;

screenshot.png

@@ -6,7 +6,7 @@ use image::{ImageBuffer, Rgb};
 use rayon::prelude::*;
 use std::{fs, mem, path::PathBuf, rc::Rc};
 
-use heatmap::CoordsType;
+use heatmap::{CoordsType, HeatmapType};
 use tf_demo_parser::{Demo, DemoParser};
 
 pub fn process_demos(input_paths: Vec<PathBuf>) -> (Vec<Death>, Vec<String>) {
@@ -49,6 +49,7 @@ pub fn process_demos(input_paths: Vec<PathBuf>) -> (Vec<Death>, Vec<String>) {
 }
 
 pub fn generate_heatmap(
+    heatmap_type: HeatmapType,
     deaths: Vec<Death>,
     mut image: ImageBuffer<Rgb<u8>, Vec<u8>>,
     screen_width: u32,
@@ -66,6 +67,6 @@ pub fn generate_heatmap(
         scale,
         coords_type,
     );
-    heatmap_generator.generate_heatmap(deaths.iter(), &mut image);
+    heatmap_generator.generate_heatmap(heatmap_type, deaths.iter(), &mut image);
     image
 }

src/heatmap.rs

@@ -1,7 +1,7 @@
 use coldmaps::*;
 mod style;
 
-use heatmap::CoordsType;
+use heatmap::{CoordsType, HeatmapType};
 use heatmap_analyser::Death;
 use iced::{
     button, executor, image::Handle, pane_grid, scrollable, text_input, window, Align, Application,
@@ -74,6 +74,7 @@ enum Message {
     DemoRemoved(usize),
     ThemeChanged(style::Theme),
     CoordsTypeChanged(CoordsType),
+    HeatmapTypeChanged(HeatmapType),
     XPosInputChanged(String),
     YPosInputChanged(String),
     ScaleInputChanged(String),
@@ -246,6 +247,7 @@ struct SettingsPane {
     demos_need_processing: bool, // has the current list not been processed?
     image_ready: bool,
     coords_type: CoordsType,
+    heatmap_type: HeatmapType,
 }
 
 impl SettingsPane {
@@ -285,6 +287,22 @@ impl SettingsPane {
                 )
             },
         );
+        let choose_heatmap_type = [HeatmapType::VictimPosition, HeatmapType::KillerPosition]
+            .iter()
+            .fold(
+                Column::new().spacing(10).push(Text::new("Heatmap type:")),
+                |column, heatmap_type| {
+                    column.push(
+                        Radio::new(
+                            *heatmap_type,
+                            &format!("{}", heatmap_type),
+                            Some(self.heatmap_type),
+                            Message::HeatmapTypeChanged,
+                        )
+                        .style(self.theme),
+                    )
+                },
+            );
 
         let x_pos_input = TextInput::new(
             &mut self.x_pos_input_state,
@@ -376,6 +394,7 @@ impl SettingsPane {
             CoordsType::Console => "Camera coordinates (use the console)",
         };
         let settings_content: Element<_> = Column::new()
+            .push(choose_heatmap_type)
             .push(Text::new(coords_label))
             .push(x_pos_border)
             .push(y_pos_border)
@@ -605,6 +624,9 @@ impl Application for App {
             Message::CoordsTypeChanged(coords_type) => {
                 self.get_settings_pane().coords_type = coords_type;
             }
+            Message::HeatmapTypeChanged(heatmap_type) => {
+                self.get_settings_pane().heatmap_type = heatmap_type;
+            }
             Message::XPosInputChanged(input) => {
                 let settings_pane = self.get_settings_pane();
                 settings_pane.x_pos = input.parse().ok();
@@ -667,6 +689,7 @@ impl Application for App {
                 let pos_y = settings_pane.y_pos.unwrap();
                 let scale = settings_pane.scale.unwrap();
                 let coords_type = settings_pane.coords_type;
+                let heatmap_type = settings_pane.heatmap_type;
                 let preview_pane = self.get_preview_pane();
                 let image = match &preview_pane.heatmap_image {
                     Some(image) => image.image.clone(),
@@ -676,6 +699,7 @@ impl Application for App {
                 let screen_height = image.height();
                 return Command::perform(
                     generate_heatmap_async(
+                        heatmap_type,
                         deaths,
                         image,
                         screen_width,
@@ -689,11 +713,12 @@ impl Application for App {
                 );
             }
             Message::HeatmapGenerationDone(heatmap_generation_output) => {
+                let heatmap_type = self.get_settings_pane().heatmap_type;
                 match heatmap_generation_output.result {
                     Ok(image) => {
                         self.log(&format!(
-                            "Heatmap generated in {:.2}s",
-                            heatmap_generation_output.time_elapsed
+                            "{} heatmap generated in {:.2}s",
+                            heatmap_type, heatmap_generation_output.time_elapsed
                         ));
                         match &mut self.get_preview_pane().heatmap_image {
                             Some(heatmap_image) => {
@@ -857,6 +882,7 @@ async fn process_demos_async<'a>(input_paths: Vec<PathBuf>) -> DemoProcessingOut
 }
 
 async fn generate_heatmap_async(
+    heatmap_type: HeatmapType,
     deaths: Vec<Death>,
     image: ImageBuffer<Rgb<u8>, Vec<u8>>,
     screen_width: u32,
@@ -869,6 +895,7 @@ async fn generate_heatmap_async(
     let chrono = Instant::now();
     let result = tokio::task::spawn_blocking(move || {
         coldmaps::generate_heatmap(
+            heatmap_type,
             deaths,
             image,
             screen_width,