matrix for visibility

synergine2_xyz/physics.py

@@ -5,6 +5,7 @@ from dijkstar import Graph
 from dijkstar import find_path
 
 from synergine2.config import Config
+from synergine2.share import shared
 from synergine2_xyz.map import TMXMap, XYZTile
 from synergine2_xyz.subjects import XYZSubject
 from synergine2_xyz.xyz import get_neighbor_positions
@@ -34,7 +35,32 @@ class MoveCostComputer(object):
         return 1.0
 
 
+class VisibilityMatrix(object):
+    _matrixes = shared.create('matrixes', value=lambda: {})  # type: typing.Dict[str, typing.Dict[float, typing.List[typing.List[float]]]]  # nopep8
+
+    def initialize_empty_matrix(self, name: str, height: float, matrix_width: int, matrix_height: int) -> None:
+        self._matrixes[name] = {}
+        self._matrixes[name][height] = []
+
+        for y in range(matrix_height):
+            x_list = []
+            for x in range(matrix_width):
+                x_list.append(0.0)
+            self._matrixes[name][height].append(x_list)
+
+    def get_matrix(self, name: str, height: float) -> typing.List[typing.List[float]]:
+        return self._matrixes[name][height]
+
+    def update_matrix(self, name: str, height: float, x: int, y: int, value: float) -> None:
+        matrix = self.get_matrix(name, height)
+        matrix[y][x] = value
+        # TODO: Test if working and needed ? This is not perf friendly ...
+        # Force shared data update
+        self._matrixes = dict(self._matrixes)
+
+
 class Physics(object):
+    visibility_matrix = VisibilityMatrix
     move_cost_computer_class = MoveCostComputer
 
     def __init__(
@@ -42,7 +68,8 @@ class Physics(object):
         config: Config,
     ) -> None:
         self.config = config
-        self.graph = Graph()
+        self.graph = Graph()  # Graph of possible movements for dijkstar algorithm lib
+        self.visibility_matrix = self.visibility_matrix()
         self.move_cost_computer = self.move_cost_computer_class(config)
 
     def load(self) -> None:

synergine2_xyz/utils.py

@@ -228,3 +228,64 @@ def get_angle(a: typing.Tuple[int, int], b: typing.Tuple[int, int]) -> int:
     ang2 = numpy.arctan2(*b[::-1])
 
     return numpy.rad2deg((ang1 - ang2) % (2 * numpy.pi))
+
+
+def get_line_xy_path(start, end):
+    """
+    TODO: copied from http://www.roguebasin.com/index.php?title=Bresenham%27s_Line_Algorithm#Python
+    What is the licence ?
+    Bresenham's Line Algorithm
+    Produces a list of tuples from start and end
+
+    >>> points1 = get_line((0, 0), (3, 4))
+    >>> points2 = get_line((3, 4), (0, 0))
+    >>> assert(set(points1) == set(points2))
+    >>> print points1
+    [(0, 0), (1, 1), (1, 2), (2, 3), (3, 4)]
+    >>> print points2
+    [(3, 4), (2, 3), (1, 2), (1, 1), (0, 0)]
+    """
+    # Setup initial conditions
+    x1, y1 = start
+    x2, y2 = end
+    dx = x2 - x1
+    dy = y2 - y1
+
+    # Determine how steep the line is
+    is_steep = abs(dy) > abs(dx)
+
+    # Rotate line
+    if is_steep:
+        x1, y1 = y1, x1
+        x2, y2 = y2, x2
+
+    # Swap start and end points if necessary and store swap state
+    swapped = False
+    if x1 > x2:
+        x1, x2 = x2, x1
+        y1, y2 = y2, y1
+        swapped = True
+
+    # Recalculate differentials
+    dx = x2 - x1
+    dy = y2 - y1
+
+    # Calculate error
+    error = int(dx / 2.0)
+    ystep = 1 if y1 < y2 else -1
+
+    # Iterate over bounding box generating points between start and end
+    y = y1
+    points = []
+    for x in range(x1, x2 + 1):
+        coord = (y, x) if is_steep else (x, y)
+        points.append(coord)
+        error -= abs(dy)
+        if error < 0:
+            y += ystep
+            error += dx
+
+    # Reverse the list if the coordinates were swapped
+    if swapped:
+        points.reverse()
+    return points

tests/test_physics.py

@@ -0,0 +1,48 @@
+# coding: utf-8
+import pytest
+
+from synergine2_xyz.physics import VisibilityMatrix
+from tests import BaseTest
+
+
+class TestVisibilityMatrix(BaseTest):
+    def test_initialize_empty_matrix(self):
+        visibility = VisibilityMatrix()
+        visibility.initialize_empty_matrix('testing', height=0.5, matrix_width=3, matrix_height=2)
+        matrix = visibility.get_matrix('testing', height=0.5)
+
+        assert isinstance(matrix, list)
+
+        assert [0.0, 0.0, 0.0] == matrix[0]
+        assert [0.0, 0.0, 0.0] == matrix[1]
+
+    def test_update_matrix(self):
+        visibility = VisibilityMatrix()
+        visibility.initialize_empty_matrix('testing', height=0.5, matrix_width=3, matrix_height=2)
+        visibility.update_matrix('testing', height=0.5, x=2, y=1, value=0.5)
+        visibility.update_matrix('testing', height=0.5, x=0, y=0, value=0.7)
+        matrix = visibility.get_matrix('testing', height=0.5)
+
+        assert [0.7, 0.0, 0.0] == matrix[0]
+        assert [0.0, 0.0, 0.5] == matrix[1]
+
+    @pytest.mark.skip(reason='Not implemented yet')
+    def test_get_path_positions(self):
+        visibility = VisibilityMatrix()
+        visibility.initialize_empty_matrix('testing', height=0.5, matrix_width=3, matrix_height=2)
+        visibility.update_matrix('testing', height=0.5, x=2, y=1, value=0.5)
+        visibility.update_matrix('testing', height=0.5, x=0, y=0, value=0.7)
+
+        path_positions = visibility.get_path_positions(from_=(0, 0), to=(2, 1))
+        assert [(0, 0), (0, 1), (1, 2)] == path_positions
+
+    @pytest.mark.skip(reason='Not implemented yet')
+    def test_get_path_values(self):
+        visibility = VisibilityMatrix()
+        visibility.initialize_empty_matrix('testing', height=0.5, matrix_width=3, matrix_height=2)
+        visibility.update_matrix('testing', height=0.5, x=2, y=1, value=0.5)
+        visibility.update_matrix('testing', height=0.5, x=0, y=0, value=0.7)
+
+        path_positions = visibility.get_path_positions(from_=(0, 0), to=(2, 1))
+        path_values = visibility.get_values_for_path(path_positions=path_positions)
+        assert [0.7, 0.0, 0.5] == path_values

tests/test_share.py

@@ -228,6 +228,36 @@ class TestShare(BaseTest):
         # In this case local data is used
         assert shared.get('data') == {'foo': 'buz'}
 
+    def test_update_dict_in_dict_with_pointer(self):
+        shared = share.SharedDataManager()
+
+        class Foo(IdentifiedObject):
+            data = shared.create_self('data', lambda: {})
+
+        foo = Foo()
+        foo.data = {'foo': {'bar': 'baz'}}
+
+        assert foo.data == {'foo': {'bar': 'baz'}}
+
+        foo.data['foo'] = {'bar': 'baz'}
+        # In this case local data is used
+        assert foo.data == {'foo': {'bar': 'baz'}}
+
+        shared.commit()
+        shared.purge_data()
+
+        # In this case, "data" key was pending and has been commit
+        assert foo.data == {'foo': {'bar': 'baz'}}
+
+        # In this case "data" key was NOT pending and has not been commit
+        foo.data['foo']['bar'] = 'biz'
+        foo.data = dict(foo.data)
+
+        shared.commit()
+        shared.purge_data()
+
+        assert foo.data == {'foo': {'bar': 'biz'}}
+
 
 class TestIndexes(BaseTest):
     def test_list_index(self):