Temp commit of the current changes to vision map. The vision map calculation should be correct here,

Author: DrInfy

src/mapping/chokes.rs

@@ -1,5 +1,5 @@
 use crate::mapping::map_point;
-use crate::path_find::pos::{Pos, PositionAPI, NormalPosAPI};
+use crate::path_find::pos::{NormalPosAPI, Pos, PositionAPI};
 use crate::path_find::pos::{DIAGONAL_MINUS_CARDINAL, MULT, MULTF32, SQRT2};
 use crate::path_find::PathFind;
 use pathfinding::prelude::absdiff;

src/mapping/map.rs

@@ -209,12 +209,19 @@ impl Map {
                      -> (Vec<(usize, usize)>, f32) {
         let start_int = (start.0.round() as usize, start.1.round() as usize);
         let end_int = (end.0.round() as usize, end.1.round() as usize);
-        let window_int = possible_window.map(|((x0, y0), (x1, y1))|
-                                                ((x0.round() as usize, y0.round() as usize),
-                                                 (x1.round() as usize, y1.round() as usize)));
+        let window_int = possible_window.map(|((x0, y0), (x1, y1))| {
+                                            ((x0.round() as usize, y0.round() as usize),
+                                             (x1.round() as usize, y1.round() as usize))
+                                        });
 
         let map = self.get_map(map_type);
-        map.find_path(start_int, end_int, large, influence, possible_heuristic, window_int, possible_distance_from_target)
+        map.find_path(start_int,
+                      end_int,
+                      large,
+                      influence,
+                      possible_heuristic,
+                      window_int,
+                      possible_distance_from_target)
     }
 
     /// Basic version of find_path with all parameters except heuristic set to false or None.
@@ -224,7 +231,6 @@ impl Map {
                            end: (f32, f32),
                            possible_heuristic: Option<u8>)
                            -> (Vec<(usize, usize)>, f32) {
-
         let start_int = (start.0.round() as usize, start.1.round() as usize);
         let end_int = (end.0.round() as usize, end.1.round() as usize);
 
@@ -247,7 +253,32 @@ impl Map {
     pub fn clear_vision(&mut self) { self.vision_map.clear(); }
     pub fn add_vision_unit(&mut self, unit: VisionUnit) { self.vision_map.add_unit(unit); }
     pub fn calculate_vision_map(&mut self) { self.vision_map.calculate_vision_map(&self.points); }
-    pub fn vision_status(& self, point: (f32, f32)) -> usize { self.vision_map.vision_status(point) }
+    pub fn vision_status(&self, point: (f32, f32)) -> usize { self.vision_map.vision_status(point) }
+
+    pub fn add_influence_to_vision(&mut self, map_type: u8, seen_value: usize, detection_value: usize) {
+        let map = self.get_map_mut(map_type);
+        let vision_map = &(self.vision_map); // self.get_vision();
+        map.add_influence_to_map_by_vision(vision_map, seen_value, detection_value);
+
+        // map.add_influence_to_map_by_vision(self.get_vision(), seen_value, detection_value)
+        // self.add_influence_to_map_by_vision(map, seen_value, detection_value);
+    }
+
+    fn add_influence_to_map_by_vision(&mut self, map: &mut  PathFind, seen_value: usize, detection_value: usize) {
+        let vision_map = self.get_vision();
+
+        for x in 0..map.width {
+            for y in 0..map.height {
+                let status = vision_map.vision_status((x as f32, y as f32));
+                if status == 1 {
+                    map.add_influence_spot((x, y), seen_value);
+                }
+                if status == 2 {
+                    map.add_influence_spot((x, y), detection_value);
+                }
+            }
+        }
+    }
 }
 
 impl Map {
@@ -424,6 +455,10 @@ impl Map {
         panic!("Map type {} does not exist", map_type.to_string());
     }
 
+    fn get_vision(&mut self) -> &mut VisionMap{
+        return &mut self.vision_map;
+    }
+
     pub fn get_map_mut(&mut self, map_type: u8) -> &mut PathFind {
         if map_type == 0 {
             return &mut self.ground_pathing;

src/mapping/vision.rs

@@ -9,6 +9,7 @@ use super::map_point;
 #[derive(Copy, Clone)]
 pub enum VisionStatus {
     NotSeen,
+    NotSeenButDetected,
     Seen,
     Detected,
 }
@@ -55,10 +56,11 @@ impl VisionMap {
 
     pub fn add_unit(&mut self, unit: VisionUnit) { self.units.push(unit); }
 
-    pub fn vision_status(& self, position: (f32, f32)) -> usize {
+    pub fn vision_status(&self, position: (f32, f32)) -> usize {
         let int_point = round_point2(position);
         match self.points[int_point.0][int_point.1] {
             VisionStatus::NotSeen => 0,
+            VisionStatus::NotSeenButDetected => 0,
             VisionStatus::Seen => 1,
             VisionStatus::Detected => 2,
         }
@@ -103,6 +105,7 @@ impl VisionMap {
             for y in 0..self.height {
                 match self.points[x][y] {
                     VisionStatus::NotSeen => vision_map[x][y] = 0,
+                    VisionStatus::NotSeenButDetected => vision_map[x][y] = 0,
                     VisionStatus::Seen => vision_map[x][y] = 1,
                     VisionStatus::Detected => vision_map[x][y] = 2,
                 }
@@ -144,8 +147,12 @@ fn set_vision(points: &mut Vec<Vec<VisionStatus>>, position: &(f32, f32), sight_
         for y in rect.y..rect.y_end {
             let d = octile_distance_f32(u_position, (x, y));
 
-            if d <= sight_range && matches!(points[x][y], VisionStatus::NotSeen) {
-                points[x][y] = VisionStatus::Seen;
+            if d <= sight_range {
+                if matches!(points[x][y], VisionStatus::NotSeen) {
+                    points[x][y] = VisionStatus::Seen;
+                } else if matches!(points[x][y], VisionStatus::NotSeenButDetected) {
+                    points[x][y] = VisionStatus::Detected;
+                }
             }
         }
     }
@@ -155,6 +162,27 @@ fn calc_ground_detection(points: &mut Vec<Vec<VisionStatus>>,
                          map_points: &Vec<Vec<map_point::MapPoint>>,
                          position: &(f32, f32),
                          sight_range: f32) {
+    let u_position = round_point2(*position);
+    let size = ((sight_range * 2f32) as usize, (sight_range * 2f32) as usize);
+    let width = points.len();
+    let height = points[0].len();
+
+    let rect = rectangle::Rectangle::init_from_center2(u_position, size, width, height);
+
+    for x in rect.x..rect.x_end {
+        for y in rect.y..rect.y_end {
+            let d = octile_distance_f32(u_position, (x, y));
+
+            if d <= sight_range {
+                if matches!(points[x][y], VisionStatus::NotSeen) || matches!(points[x][y], VisionStatus::NotSeenButDetected) {
+                    points[x][y] = VisionStatus::NotSeenButDetected;
+                } else {
+                    points[x][y] = VisionStatus::Detected;
+                }
+            }
+        }
+    }
+
     let circumference = 2f32 * sight_range * std::f32::consts::PI;
     let rays = circumference as usize;
     let step_mult = 1.3f32;
@@ -217,22 +245,28 @@ fn calc_ground_vision(points: &mut Vec<Vec<VisionStatus>>,
         for step in 0..steps {
             // Rays are only drawn until non-walkable is found and thus the cannot go out of bounds
             let step_f32 = step as f32 / step_mult;
-            let new_pos =
-                ((position.0 + v_x * step_f32) as usize, (position.1 + v_y * step_f32) as usize);
+            let new_pos = ((position.0 + v_x * step_f32) as usize, (position.1 + v_y * step_f32) as usize);
 
-            
             // TODO: Same for height difference
             if map_points[new_pos.0][new_pos.1].height > max_height_seen {
                 // Ray can't reach further
-                println!("Ray {} stopped at ({}, {}), angle was {} and vector was ({}, {}) with step {}", index, new_pos.0, new_pos.1, angle, v_x, v_y, step_f32);
+                println!("Ray {} stopped at ({}, {}), angle was {} and vector was ({}, {}) with step {}",
+                         index, new_pos.0, new_pos.1, angle, v_x, v_y, step_f32);
                 break;
             }
 
             if matches!(points[new_pos.0][new_pos.1], VisionStatus::NotSeen) {
                 // if new_pos.0 == 25 && new_pos.1 == 8 {
-                println!("Ray {} set vision to ({}, {}), angle was {} and vector was ({}, {}) with step {}", index, new_pos.0, new_pos.1, angle, v_x, v_y, step_f32);
+                println!("Ray {} set vision to ({}, {}), angle was {} and vector was ({}, {}) with step {}",
+                         index, new_pos.0, new_pos.1, angle, v_x, v_y, step_f32);
                 // }
                 points[new_pos.0][new_pos.1] = VisionStatus::Seen;
+            } else if matches!(points[new_pos.0][new_pos.1], VisionStatus::NotSeenButDetected) {
+                // if new_pos.0 == 25 && new_pos.1 == 8 {
+                println!("Ray {} set vision to ({}, {}), angle was {} and vector was ({}, {}) with step {}",
+                         index, new_pos.0, new_pos.1, angle, v_x, v_y, step_f32);
+                // }
+                points[new_pos.0][new_pos.1] = VisionStatus::Detected;
             }
         }
     }