Merge pull request #23 from DrInfy/find_low_inside_fixes

Find low inside fixes

Author: DrInfy

kite_test.py

@@ -19,9 +19,9 @@ def read_maze(file_name: str) -> List[List[int]]:
 
 maze = read_maze("tests/empty10x10.txt")
 pf = sc2pathlibp.PathFinder(maze)
-pf.normalize_influence(1)
+pf.normalize_influence(10)
 enemy_pos = (4, 0)
-start_pos = (5, 5)
+start_pos = (5, 2)
 pf.add_influence_walk([enemy_pos], 100, 7)
 end_result = pf.find_low_inside_walk(start_pos, enemy_pos, 5)
 print(end_result)

sc2pathlibp/map.py

@@ -7,6 +7,8 @@
 
 
 class Sc2Map:
+    __slots__ = ['_overlord_spots', '_chokes', 'heuristic_accuracy', 'height_map', '_map']
+
     def __init__(
         self,
         pathing_grid: np.ndarray,
@@ -119,10 +121,10 @@ def add_walk_influence(self, points: List["sc.Point2"], influence: float, range:
         self._map.add_influence_walk(points, influence, range)
 
     def add_tank_influence(
-        self, points: List["sc.Point2"], influence: float, tank_min_range: float = 3, tank_max_range: float = 14.5
+        self, points: List["sc.Point2"], influence: float, tank_min_range: float = 2.5, tank_max_range: float = 14.5
     ):
         """
-        :param tank_min_range: Tank minimum range is 2, adding both unit radiuses to that and we'll estimate it to be 3.
+        :param tank_min_range: Tank minimum range is 2, adding both unit radiuses to that and we'll estimate it to be 2.5.
         :param tank_max_range: Same for max range, 13, but but with unit radius, let's say it's 14.5 instead to err on the safe side
         """
         self._map.add_influence_flat_hollow(points, influence, tank_min_range, tank_max_range)

src/helpers/mod.rs

@@ -1,5 +1,11 @@
 pub fn round_point2(point: (f32, f32)) -> (usize, usize) {
     let x = point.0.round() as usize;
     let y = point.1.round() as usize;
-    return (x, y);
+    (x, y)
+}
+
+pub fn point2_f32(point: (usize, usize)) -> (f32, f32) {
+    let x = point.0 as f32;
+    let y = point.1 as f32;
+    (x, y)
 }

src/mapping/chokes.rs

@@ -331,5 +331,5 @@ fn distance(first: (usize, usize), second: (usize, usize)) -> f32 {
     let pos1 = Pos(first.0, first.1);
     let pos2 = Pos(second.0, second.1);
 
-    return pos1.euclidean_distance(&pos2) as f32 / MULTF32;
+    pos1.euclidean_distance(&pos2) as f32 / MULTF32
 }

src/mapping/influence.rs

@@ -151,7 +151,7 @@ impl Map {
             maps.push(&mut self.reaper_pathing);
         }
 
-        return maps;
+        maps
     }
 
     fn get_pure_ground_influence_maps(&mut self) -> Vec<&mut PathFind> {
@@ -162,7 +162,7 @@ impl Map {
             maps.push(&mut self.reaper_pathing);
         }
 
-        return maps;
+        maps
     }
 
     pub fn get_ground_influence_maps(&mut self) -> Vec<&mut PathFind> {
@@ -176,7 +176,7 @@ impl Map {
             maps.push(&mut self.reaper_pathing);
         }
 
-        return maps;
+        maps
     }
 
     pub fn get_air_influence_maps(&mut self) -> Vec<&mut PathFind> {
@@ -187,6 +187,6 @@ impl Map {
             maps.push(&mut self.colossus_pathing);
         }
 
-        return maps;
+        maps
     }
 }

src/mapping/map.rs

@@ -150,29 +150,29 @@ impl Map {
             }
         }
 
-        return result;
+        result
     }
 
     /// Returns current influence value
     fn current_influence(&self, map_type: u8, position: (f32, f32)) -> f32 {
         let map = self.get_map(map_type);
         let position_int = round_point2(position);
 
-        return map.current_influence(position_int) as f32;
+        map.current_influence(position_int) as f32
     }
 
     /// Finds the first reachable position within specified walking distance from the center point with lowest value
     fn lowest_influence_walk(&self, map_type: u8, center: (f32, f32), distance: f32) -> ((usize, usize), f32) {
         let map = self.get_map(map_type);
         let center_int = round_point2(center);
 
-        return map.lowest_influence_walk(center_int, distance);
+        map.lowest_influence_walk(center_int, distance)
     }
 
     /// Finds the first reachable position within specified distance from the center point with lowest value
     pub fn lowest_influence(&self, map_type: u8, center: (f32, f32), distance: usize) -> ((usize, usize), f32) {
         let map = self.get_map(map_type);
-        return map.inline_lowest_value(center, distance);
+        map.inline_lowest_value(center, distance)
     }
 
     /// Find the shortest path values without considering influence and returns the path and distance
@@ -186,7 +186,7 @@ impl Map {
         let end_int = (end.0.round() as usize, end.1.round() as usize);
 
         let map = self.get_map(map_type);
-        return map.find_path(start_int, end_int, possible_heuristic);
+        map.find_path(start_int, end_int, possible_heuristic)
     }
 
     /// Find the shortest path values without considering influence and returns the path and distance
@@ -200,7 +200,7 @@ impl Map {
         let end_int = (end.0.round() as usize, end.1.round() as usize);
 
         let map = self.get_map(map_type);
-        return map.find_path_large(start_int, end_int, possible_heuristic);
+        map.find_path_large(start_int, end_int, possible_heuristic)
     }
 
     /// Find the path using influence values and returns the path and distance
@@ -213,7 +213,7 @@ impl Map {
         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 map = self.get_map(map_type);
-        return map.find_path_influence(start_int, end_int, possible_heuristic);
+        map.find_path_influence(start_int, end_int, possible_heuristic)
     }
 
     /// Find the path using influence values and returns the path and distance
@@ -226,7 +226,7 @@ impl Map {
         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 map = self.get_map(map_type);
-        return map.find_path_influence_large(start_int, end_int, possible_heuristic);
+        map.find_path_influence_large(start_int, end_int, possible_heuristic)
     }
 
     /// Find the shortest path values without considering influence and returns the path and distance
@@ -241,7 +241,7 @@ impl Map {
         let end_int = (end.0.round() as usize, end.1.round() as usize);
 
         let map = self.get_map(map_type);
-        return map.find_path_closer_than(start_int, end_int, possible_heuristic, distance_from_target);
+        map.find_path_closer_than(start_int, end_int, possible_heuristic, distance_from_target)
     }
 
     /// Find the shortest path values without considering influence and returns the path and distance
@@ -256,7 +256,7 @@ impl Map {
         let end_int = (end.0.round() as usize, end.1.round() as usize);
 
         let map = self.get_map(map_type);
-        return map.find_path_large_closer_than(start_int, end_int, possible_heuristic, distance_from_target);
+        map.find_path_large_closer_than(start_int, end_int, possible_heuristic, distance_from_target)
     }
 
     /// Find the path using influence values and returns the path and distance
@@ -270,7 +270,7 @@ impl Map {
         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 map = self.get_map(map_type);
-        return map.find_path_influence_closer_than(start_int, end_int, possible_heuristic, distance_from_target);
+        map.find_path_influence_closer_than(start_int, end_int, possible_heuristic, distance_from_target)
     }
 
     /// Find the path using influence values and returns the path and distance
@@ -284,7 +284,7 @@ impl Map {
         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 map = self.get_map(map_type);
-        return map.find_path_influence_large_closer_than(start_int, end_int, possible_heuristic, distance_from_target);
+        map.find_path_influence_large_closer_than(start_int, end_int, possible_heuristic, distance_from_target)
     }
 
     /// Finds a compromise where low influence matches with close position to the start position.
@@ -295,7 +295,7 @@ impl Map {
                             distance: f32)
                             -> ((f32, f32), f32) {
         let map = self.get_map(map_type);
-        return map.find_low_inside_walk(start, target, distance);
+        map.find_low_inside_walk(start, target, distance)
     }
 }
 
@@ -402,14 +402,13 @@ impl Map {
 
                 let c = points[x][y].cliff_type;
 
-                if c != Cliff::None {
-                    if points[x + 1][y].cliff_type != c
-                       && points[x - 1][y].cliff_type != c
-                       && points[x][y + 1].cliff_type != c
-                       && points[x][y - 1].cliff_type != c
-                    {
-                        points[x][y].cliff_type = Cliff::None;
-                    }
+                if c != Cliff::None
+                   && points[x + 1][y].cliff_type != c
+                   && points[x - 1][y].cliff_type != c
+                   && points[x][y + 1].cliff_type != c
+                   && points[x][y - 1].cliff_type != c
+                {
+                    points[x][y].cliff_type = Cliff::None;
                 }
 
                 if !set_handled_overlord_spots.contains(&point_hash) && points[x][y].overlord_spot {
@@ -515,7 +514,7 @@ fn flood_fill_overlord(points: &mut Vec<Vec<map_point::MapPoint>>,
 
     let mut result = true;
     points[x][y].overlord_spot = replacement;
-    // if points[x][y].overlord_spot == target {
+
     if y > 0 {
         result &= flood_fill_overlord(points, x, ((y as u32) - 1) as usize, target_height, replacement, set);
     }
@@ -528,7 +527,6 @@ fn flood_fill_overlord(points: &mut Vec<Vec<map_point::MapPoint>>,
     if x < points.len() - 1 {
         result &= flood_fill_overlord(points, x + 1, y, target_height, replacement, set);
     }
-    // }
 
-    return result;
+    result
 }

src/mapping/zones.rs

@@ -73,14 +73,13 @@ impl Map {
 
     pub fn get_zone(&self, position: (f32, f32)) -> i8 {
         let u_position = round_point2(position);
-        let index = self.points[u_position.0][u_position.1].zone_index;
-        index
+        self.points[u_position.0][u_position.1].zone_index
     }
 }
 
 impl Map {
-    fn borrow(&mut self, x: usize, y: usize) -> &mut MapPoint { return &mut self.points[x][y]; }
-    fn zone_index(&mut self, x: usize, y: usize) -> i8 { return self.points[x][y].zone_index; }
+    fn borrow(&mut self, x: usize, y: usize) -> &mut MapPoint { &mut self.points[x][y] }
+    fn zone_index(&mut self, x: usize, y: usize) -> i8 { self.points[x][y].zone_index }
 }
 
 fn flood_fill(map: &mut Map,
@@ -128,7 +127,6 @@ fn flood_fill(map: &mut Map,
         return;
     }
 
-    // if points[x][y].overlord_spot == target {
     if y > 0 {
         flood_fill(map, x, ((y as u32) - 1) as usize, target_height, zone_index, origin, sorted_base_locations);
     }
@@ -141,7 +139,4 @@ fn flood_fill(map: &mut Map,
     if x < map.points.len() - 1 {
         flood_fill(map, x + 1, y, target_height, zone_index, origin, sorted_base_locations);
     }
-    // }
-
-    return;
 }