Merge branch 'master' into pheromones

Author: lsampras

game_map.py

@@ -0,0 +1,39 @@
+class Map:
+
+    def __init__(self, game_map):
+        self.static = game_map
+        self.active = []
+        self.mock = []
+        self.special = {}
+
+    def is_valid_point(self, pos):
+        return self.static[pos.y][pos.x]
+
+    def valid_next_pos(self, cur_unit):
+        return [pos for pos in cur_unit.next_pos() if self.is_valid_point(pos)]
+
+    def visible_units(self, cur_unit):
+        return [unit for unit in self.active if cur_unit.can_see(unit)]
+
+    def _poten(self, next_pos, actors):
+        poten = [0] * len(next_pos)
+
+        for i, pos in enumerate(next_pos):
+            for actor in actors:
+                poten[i] += actor.poten_at(pos)
+
+        return poten
+
+    def mock_poten(self, next_pos):
+        return self._poten(next_pos, self.mock)
+
+    def active_poten(self, cur_unit, next_pos):
+        active_units = self.visible_units(cur_unit)
+        return self._poten(next_pos, active_units)
+
+    def next_pos_potential(self, cur_unit, next_pos):
+        mock_poten = self.mock_poten(next_pos)
+        active_poten = self.active_poten(cur_unit, next_pos)
+        # total_poten = [max(a, b) for a, b in zip(mock_poten, total_poten)]
+        total_poten = [a + b for a, b in zip(mock_poten, active_poten)]
+        return [(score, pos) for score, pos in zip(total_poten, next_pos)]

main.py

@@ -1,10 +1,11 @@
-from timeit import default_timer as timer
-
 import map_generator
+from game_map import Map
+from mock_object import PathObject, WallObject
 from movement_cost import linear_cost
 from moves import adjacent_linear
 from path_finding import PathFinder
 from point import Point
+from unit import SCOUT
 
 map_data = None
 
@@ -16,22 +17,32 @@ def is_valid_pos(cur_pos):
 
 if __name__ == "__main__":
     map_data = map_generator.generate_map(100, 100, seed=25, obstacle_density=0.35)
-    start = Point(59, 45)
-    mid = Point(0, 0)
-    end = Point(86, 40)
-    waypoints = [start, mid, end]
+    start = Point(35, 42)
+    block = Point(39, 42)
+    end = Point(41, 42)
     moves = adjacent_linear()
     cost_func = linear_cost()
-    start = timer()
     path_finder = PathFinder(linear_cost(), linear_cost(), is_valid_pos)
-    path, store = path_finder.find_path_waypoints(moves, waypoints, return_store=True)
-    print(timer() - start)
-    map_generator.view_path(map_data, path, store)
-    # start = timer()
-    # potn = potential.manhattan(map_data)
-    # print(timer() - start)
-    # potential.view_potential(potn)
-    # start = timer()
-    # terrainer = TerrainAnalyzer(map_data)
-    # print(timer() - start)
-    # terrainer.view_terrain(True)
+    path, store = path_finder.find_path(moves, start, end, return_store=True)
+    game_map = Map(map_data)
+    wall = WallObject([block])
+    taken_path = []
+    cur_unit = SCOUT.copy(start)
+    while True:
+        next_step = path[0]
+        if next_step == block:
+            break
+        else:
+            cur_unit.cur_pos = next_step
+            del path[0]
+            taken_path.append(next_step)
+
+    while path:
+        vis_path = [pos for pos in path if cur_unit.can_see_point(pos)]
+        game_map.mock = [PathObject(vis_path), wall]
+        best_step = path_finder.best_potential_step(game_map, cur_unit)
+        taken_path.append(best_step)
+        cur_unit.cur_pos = best_step
+        del path[0]
+
+    map_generator.view_map(map_data, None, [taken_path], [block])

map_generator.py

@@ -1,18 +1,54 @@
 from helper import get_x_and_y_from_store
 from helper import get_x_and_y_from_path
+from point import Point
 
 import matplotlib.pyplot as plt
+import matplotlib.cm as cm
 import numpy as np
 import perlin
 
+def view_map(map_data, stores=None, paths=None, points=None, grid=True):
+    """
+    View map with entities like paths, stores, and points. Each
+    entity argument is a list and the z-order (visibility) increases
+    with index in the list. Among entities z-order varies as
+    stores < paths < points.
 
-def view_map(map_data, grid=True):
-    """View map
-    a) map_data:    Boolean numpy array. True for passable, False for impassable.
-    b) grid:        Display grid. Defaults to True.
-    c) color code:  yellow for passable(1), purple for impassable(0).
-    d) coordinates: click anywhere on the map to view coordinates of that point.
+    The map shows passable as yellow and impassable as purple. Each
+    entity list cycles through an indepedent color map, i.e. each
+    path in paths will have a different color. All points are
+    displayed in black color.
+
+    Args:
+        map_data:    Boolean numpy array. True for passable, False
+            for impassable.
+        coordinates: click anywhere on the map to view coordinates
+            of that point.
+        paths:       List of paths to be shown.
+        stores:      Point stores to be shown.
+        points:      Special points to be displayed.
+        grid:        Display grid. Defaults to True.
     """
+
+    if stores:
+        colors = cm.autumn(np.linspace(0, 1, len(stores)))
+        for c, store in zip(colors, stores):
+            x, y = get_x_and_y_from_store(store)
+            plt.scatter(x, y, color=c)
+
+    if paths:
+        colors = cm.winter(np.linspace(0, 1, len(paths)))
+        for c, path in zip(colors, paths):
+            start, end = path[0], path[-1]
+            x, y = get_x_and_y_from_path(path)
+            plt.scatter(x, y, color=c)
+            plt.plot(start.x, start.y, marker='x')
+            plt.plot(end.x, end.y, marker='x')
+
+    if points:
+        for point in points:
+            plt.plot(point.x, point.y, color='black', marker='o')
+
     m, n = map_data.shape
     plt.imshow(map_data)
     plt.xticks(np.arange(0.5, n, 1.0), [])
@@ -76,3 +112,18 @@ def mouse_move(event):
     x, y = int(round(event.xdata)), int(round(event.ydata))
     print(x, y)
     return
+
+
+if __name__ == "__main__":
+    map_data = generate_map(100, 100, 0.35, 0.1, 25)
+    offsets = []
+    for i in range(3):
+        for j in range(3):
+            offsets.append(Point(i, j))
+
+    store_1 = {Point(41, 25) + offset: True for offset in offsets}
+    store_2 = {Point(42, 26) + offset: True for offset in offsets}
+    path = [Point(41, 25), Point(41, 26), Point(41, 27), Point(42, 27), Point(43, 27)]
+    point = Point(42, 37)
+    view_map(map_data, [store_1, store_2], [path], [point])
+

mock_object.py

@@ -0,0 +1,61 @@
+import math
+
+
+class PathObject:
+    """
+    Path points attract a point with degrading field upto
+    a certain cutoff. The field strength increases with
+    increasing index along the path.
+    """
+
+    def __init__(self, points):
+        self.points = points
+
+    def poten_at(self, pos, slope=-2, cutoff=4):
+        """
+        Calculate potential at point pos
+
+        Args:
+            pos: point to calculate potential at
+            slope: slope of degrading field
+            cutoff: maximum range of affect for field
+
+        Returns:
+            value: minimum potential value possible
+        """
+
+        def score(path_point, i, pos):
+            dist = pos.dist(path_point)
+            if dist == 0:
+                return -math.inf
+            else:
+                return (i + 1) * ((1 / dist - 1 / cutoff) * (slope - i))
+
+        scores = [score(path_point, i, pos) for i, path_point in enumerate(self.points)]
+        return min(scores)
+
+
+class WallObject:
+    """
+    Wall objects behave as inert tiles, not allowing
+    any unit to step on them while not affecting any other tile
+    """
+
+    def __init__(self, points):
+        self.points = points
+
+    def poten_at(self, pos):
+        """
+        Inert function stepping on wall in not possible. No other
+        point is affected.
+
+        Args:
+            pos: point to calculate potential at
+
+        Returns:
+            value: inf or 0
+        """
+        if pos in self.points:
+            return math.inf
+        else:
+            return 0

movement_cost.py

@@ -1,4 +1,5 @@
 import random
+
 import math
 
 
@@ -107,4 +108,3 @@ def cost(start, end):
         return h_func(start, end) * random.normalvariate(mu, sigma)
 
     return cost
-

path_finding.py

@@ -1,9 +1,9 @@
+import functools
+import itertools
+
 import helper
 import priority_queue
 
-import itertools
-import functools
-
 
 class PathFinder:
     def __init__(self, movement_cost, heuristic_cost, is_valid_move):
@@ -194,19 +194,43 @@ def total_cost(cur_pos, next_pos, end):
 
         return {}
 
-    def best_potential_step(self, cur_pos, path=None, range=None):
+    def best_potential_step(self, game_map, cur_unit):
         """
         Finds the point with the best potential score for the next step.
         If path and range is given, finds the best potential score point
         within the range of the next step prescribed by path.
 
         Args:
-            cur_pos Point: current position
+            cur_pos Point: current unit
             path List(Point): prescribed path from source to destination
             range int: cutoff range from points along the path
 
         Return:
             Point: best step
         """
-        return None
+        next_pos = game_map.valid_next_pos(cur_unit)
+        potential_values = game_map.next_pos_potential(cur_unit, next_pos)
+        best_state = min(potential_values)
+        return best_state[1]
 
+    def reconstruct_path(self, cur_pos, path):
+        """
+        TODO
+        Reconstructs a new path from current position,
+        that joins the given path at some point
+
+        Args:
+            cur_pos: current position of unit
+            path: previous path from which unit has deviated
+
+        Return:
+            New path
+        """
+        # check if path is None and return None
+        # Find position of intersection with path,
+        # simple case is head of path
+        # complex case can be to analyze sensitivity of path points
+        # and set intersection at most sensitive point
+        # calculate path from cur_pos to intersection
+        # return concatenated path
+        return None

point.py

@@ -1,3 +1,5 @@
+import math
+
 class Point:
     __slots__ = 'x', 'y'
 
@@ -32,6 +34,19 @@ def __lt__(self, other):
         else:
             return False
 
+    def __str__(self):
+        return "({}, {})".format(self.x, self.y)
+
+    def __repr__(self):
+        return "Point({}, {})".format(self.x, self.y)
+
     def __hash__(self):
         return hash((self.x, self.y))
 
+    def dist(self, other, squared=True):
+        dist_squared = (self.x - other.x)**2 + (self.y - other.y)**2
+        if squared:
+            return dist_squared
+        else:
+            return math.sqrt(dist_squared)
+