0.2.0 - filters support

Author: Tails8521

Cargo.lock

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

Cargo.toml

@@ -15,9 +15,9 @@ Tip: You can use setpos \<x> \<y> \<z> to position yourself accurately
 3: Drag and drop the screenshot over the program's window  
 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
+6: The "Export image" button lets you export the heatmap as an image file
 
 # How to build
 
+(This step is only needed if you want to build from source, if you're on Windows you can simply download a pre-built exe from the [releases page](https://github.com/Tails8521/coldmaps/releases))  
 Download and install [Rust](https://www.rust-lang.org/learn/get-started) then `cargo build` or `cargo build --release`

README.md

@@ -1,5 +1,6 @@
-use crate::heatmap_analyser::{Class, Death, PlayerEntity, Team};
+use crate::heatmap_analyser::{Death, PlayerEntity, Team, PlayerState};
 use enum_dispatch::enum_dispatch;
+use std::fmt::Display;
 use tf_demo_parser::demo::vector::Vector;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -12,13 +13,91 @@ pub enum OrderedOperator {
     SmallerOrEqual,
 }
 
+impl OrderedOperator {
+    pub const ALL: [OrderedOperator; 6] = [
+        OrderedOperator::Equal,
+        OrderedOperator::NotEqual,
+        OrderedOperator::Greater,
+        OrderedOperator::Smaller,
+        OrderedOperator::GreaterOrEqual,
+        OrderedOperator::SmallerOrEqual,
+    ];
+}
+
+impl Default for OrderedOperator {
+    fn default() -> Self {
+        OrderedOperator::Equal
+    }
+}
+
+impl Display for OrderedOperator {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            OrderedOperator::Equal => write!(f, "="),
+            OrderedOperator::NotEqual => write!(f, "≠"),
+            OrderedOperator::Greater => write!(f, ">"),
+            OrderedOperator::Smaller => write!(f, "<"),
+            OrderedOperator::GreaterOrEqual => write!(f, "≥"),
+            OrderedOperator::SmallerOrEqual => write!(f, "≤"),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum UnorderedOperator {
-    Is,
-    IsNot,
+pub enum PropertyOperator {
+    IsPresent,
+    IsNotPresent,
+}
+
+impl PropertyOperator {
+    pub const ALL: [PropertyOperator; 2] = [PropertyOperator::IsPresent, PropertyOperator::IsNotPresent];
+}
+
+impl Default for PropertyOperator {
+    fn default() -> Self {
+        PropertyOperator::IsPresent
+    }
+}
+
+impl Display for PropertyOperator {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            PropertyOperator::IsPresent => write!(f, "present"),
+            PropertyOperator::IsNotPresent => write!(f, "not present"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Property {
+    Suicide,
+    Posthumous,
+}
+
+impl Property {
+    pub const ALL: [Property; 2] = [
+        Property::Suicide,
+        Property::Posthumous,
+    ];
+}
+
+impl Default for Property {
+    fn default() -> Self {
+        Property::Suicide
+    }
+}
+
+impl Display for Property {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Property::Suicide => write!(f, "Suicide"),
+            Property::Posthumous => write!(f, "Posthumous"),
+        }
+    }
 }
 
 #[enum_dispatch]
+#[derive(Debug)]
 pub enum Filter {
     KillerTeamFilter,
     VictimTeamFilter,
@@ -28,73 +107,72 @@ pub enum Filter {
     VictimElevationFilter,
     Distance2DFilter,
     Distance3DFilter,
+    RoundFilter,
+    PropertyFilter,
 }
 
 #[enum_dispatch(Filter)]
 pub trait FilterTrait {
     fn apply(&self, death: &Death) -> bool;
 }
 
+#[derive(Debug)]
 pub struct KillerTeamFilter {
-    pub op: UnorderedOperator,
     pub team: Team,
 }
 
 impl FilterTrait for KillerTeamFilter {
     fn apply(&self, death: &Death) -> bool {
-        match (&death.killer_entity_state, self.op) {
-            (Some(PlayerEntity { team, .. }), UnorderedOperator::Is) => *team == self.team,
-            (Some(PlayerEntity { team, .. }), UnorderedOperator::IsNot) => *team != self.team,
-            (None, _) => false,
+        match &death.killer_entity_state {
+            Some(PlayerEntity { team, .. }) => *team == self.team,
+            None => false,
         }
     }
 }
 
+#[derive(Debug)]
 pub struct VictimTeamFilter {
-    pub op: UnorderedOperator,
     pub team: Team,
 }
 
 impl FilterTrait for VictimTeamFilter {
     fn apply(&self, death: &Death) -> bool {
-        match (&death.victim_entity_state, self.op) {
-            (Some(PlayerEntity { team, .. }), UnorderedOperator::Is) => *team == self.team,
-            (Some(PlayerEntity { team, .. }), UnorderedOperator::IsNot) => *team != self.team,
-            (None, _) => false,
+        match &death.victim_entity_state {
+            Some(PlayerEntity { team, .. }) => *team == self.team,
+            None => false,
         }
     }
 }
 
+#[derive(Debug)]
 pub struct KillerClassFilter {
-    pub op: UnorderedOperator,
-    pub class: Class,
+    pub classes: [bool; 10],
 }
 
 impl FilterTrait for KillerClassFilter {
     fn apply(&self, death: &Death) -> bool {
-        match (&death.killer_entity_state, self.op) {
-            (Some(PlayerEntity { class, .. }), UnorderedOperator::Is) => *class == self.class,
-            (Some(PlayerEntity { class, .. }), UnorderedOperator::IsNot) => *class != self.class,
-            (None, _) => false,
+        match &death.killer_entity_state {
+            Some(PlayerEntity { class, .. }) => self.classes[*class as usize],
+            None => false,
         }
     }
 }
 
+#[derive(Debug)]
 pub struct VictimClassFilter {
-    pub op: UnorderedOperator,
-    pub class: Class,
+    pub classes: [bool; 10],
 }
 
 impl FilterTrait for VictimClassFilter {
     fn apply(&self, death: &Death) -> bool {
-        match (&death.victim_entity_state, self.op) {
-            (Some(PlayerEntity { class, .. }), UnorderedOperator::Is) => *class == self.class,
-            (Some(PlayerEntity { class, .. }), UnorderedOperator::IsNot) => *class != self.class,
-            (None, _) => false,
+        match &death.victim_entity_state {
+            Some(PlayerEntity { class, .. }) => self.classes[*class as usize],
+            None => false,
         }
     }
 }
 
+#[derive(Debug)]
 pub struct KillerElevationFilter {
     pub op: OrderedOperator,
     pub z: f32,
@@ -114,6 +192,7 @@ impl FilterTrait for KillerElevationFilter {
     }
 }
 
+#[derive(Debug)]
 pub struct VictimElevationFilter {
     pub op: OrderedOperator,
     pub z: f32,
@@ -133,6 +212,7 @@ impl FilterTrait for VictimElevationFilter {
     }
 }
 
+#[derive(Debug)]
 pub struct Distance2DFilter {
     pub op: OrderedOperator,
     pub distance: f32,
@@ -158,6 +238,7 @@ impl FilterTrait for Distance2DFilter {
     }
 }
 
+#[derive(Debug)]
 pub struct Distance3DFilter {
     pub op: OrderedOperator,
     pub distance: f32,
@@ -183,3 +264,44 @@ impl FilterTrait for Distance3DFilter {
         }
     }
 }
+
+#[derive(Debug)]
+pub struct RoundFilter {
+    pub op: OrderedOperator,
+    pub round: u32,
+}
+
+impl FilterTrait for RoundFilter {
+    fn apply(&self, death: &Death) -> bool {
+        match self.op {
+            OrderedOperator::Equal => death.round == self.round,
+            OrderedOperator::NotEqual => death.round != self.round,
+            OrderedOperator::Greater => death.round > self.round,
+            OrderedOperator::Smaller => death.round < self.round,
+            OrderedOperator::GreaterOrEqual => death.round >= self.round,
+            OrderedOperator::SmallerOrEqual => death.round <= self.round,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PropertyFilter {
+    pub op: PropertyOperator,
+    pub property: Property,
+}
+
+impl FilterTrait for PropertyFilter {
+    fn apply(&self, death: &Death) -> bool {
+        let ret = match self.property {
+            Property::Suicide => death.killer == death.victim,
+            Property::Posthumous => match death.killer_entity_state {
+                Some(PlayerEntity { state: PlayerState::Alive, .. } ) => false,
+                _ => true
+            }
+        };
+        match self.op {
+            PropertyOperator::IsPresent => ret,
+            PropertyOperator::IsNotPresent => !ret,
+        }
+    }
+}