Added libtcod pathfinding. Untested.

Author: 4b796c65

tdl/__tcod.py

@@ -484,7 +484,7 @@ def __repr__(self):
 # PATH
 
 TCOD_path_t = c_void_p
-PATHCALL = CFUNCTYPE(c_float, (c_int, c_int, c_int, c_int, c_void_p))
+PATHCALL = CFUNCTYPE(c_float, c_int, c_int, c_int, c_int, c_void_p)
 
 _lib.TCOD_path_new_using_map.restype = TCOD_path_t
 _lib.TCOD_path_new_using_map.argtypes = (TCOD_map_t, c_float)

tdl/fov.py

@@ -1,23 +1,41 @@
 
 import itertools
+import ctypes
+import array
 
 from .__tcod import _lib
 
 class Map(object):
 
-    def __init__(self, width, height):
+    def __init__(self, width, height, callback):
         self._width = int(width)
         self._height = int(height)
         self._size = self._width * self._height
         self._tcodMap = _lib.TCOD_map_new(width, height)
         self._as_parameter_ = self._tcodMap
-        self._fovConf = (0, 0, 0) # fov settings (x, y, radius)
+        self._callback = callback
+        self._clean = set()
         #self._walkable = array.array('b', [0] * self._size)
         #self._transparent = array.array('b', [0] * self._size)
 
     def __del__(self):
         _lib.TCOD_map_delete(self)
 
+    def _pointsInRadius(self, x, y, radius):
+        'returns a list of (x, y) items'
+        x = range(max(0, x - radius), min(x + radius + 1, self._width))
+        y = range(max(0, y - radius), min(y + radius + 1, self._height))
+        return itertools.product(x, y)
+    
+    def _pointsInRadiusC(self, x, y, radius):
+        'returns a list of ((x, ctypeX), (y, ctypeY)) items'
+        c_int = ctypes.c_int
+        x = ((i, c_int(i)) for i in
+             range(max(0, x - radius), min(x + radius + 1, self._width)))
+        y = ((i, c_int(i)) for i in
+             range(max(0, y - radius), min(y + radius + 1, self._height)))
+        return itertools.product(x, y)
+        
     def setFromCallbacks(self, walkableCall, transparentCall):
         for x, y in itertools.product(range(self._width), range(self._height)):
             _lib.TCOD_map_set_properties(self._tcodMap, x, y,
@@ -30,6 +48,15 @@ def set(self, x, y, walkable, transparent):
         _lib.TCOD_map_set_properties(self._as_parameter_,
                                      x, y, walkable, transparent)
 
+    def _updateMap(self, x, y, radius):
+        c_bool = ctypes.c_bool
+        for (x, cX),(y, cY) in self._pointsInRadiusC(x, y, radius):
+            #if (x, y) not in self._clean:
+            #    self._clean.add((x,y))
+                transparent = c_bool(self._callback(x, y))
+                _lib.TCOD_map_set_properties(self._as_parameter_,
+                                         cX, cY, transparent, transparent)
+        
     def computeFOV(self, x, y, fov='PERMISSIVE', radius=8, lightWalls=True):
         oldFOV = fov
         fov = str(fov).upper()
@@ -41,15 +68,19 @@ def computeFOV(self, x, y, fov='PERMISSIVE', radius=8, lightWalls=True):
             fov = 4 + int(fov[10])
         else:
             raise TDLError('No such fov as %s' % oldFOV)
+            
+        self._updateMap(x, y, radius)
         _lib.TCOD_map_compute_fov(self, x, y, radius, lightWalls, fov)
-        self._fovConf = (x, y, radius)
-        return self._iterFOV()
+        return self._listFOV(x, y, radius)
 
-    def _iterFOV(self):
-        x, y, radius = self._fovConf
+    def _iterFOV(self, x, y, radius):
         inFOV = _lib.TCOD_map_is_in_fov
         map = self._as_parameter_
-        for x,y in itertools.product(range(x - radius, x + radius + 1),
-                                     range(y - radius, y + radius + 1)):
-            if inFOV(map, x, y):
+        for (x, cX),(y, cY) in self._pointsInRadiusC(x, y, radius):
+            if inFOV(map, cX, cY):
                 yield(x, y)
+                
+    def _listFOV(self, x, y, radius):
+        return list(self._iterFOV(x, y, radius))
+
+__all__ = [Map]

tdl/path.py

@@ -1,5 +1,52 @@
 
+import math
+import ctypes
 
+from .__tcod import _lib
+
+class AStar(object):
+
+    def __init__(self, width, height, callback, diagnalCost=math.sqrt(2)):
+        def newCallback(fromX, fromY, toX, toY, null):
+            pathCost = callback(toX, toY) # expecting a float or 0
+            return pathCost
+        self.callback = newCallback
+        self._as_parameter_ = _lib.TCOD_path_new_using_function(width, height,
+                                                newCallback, None, diagnalCost)
+
+    def getPath(self, origX, origY, destX, destY):
+        found = _lib.TCOD_path_compute(self, origX, origY, destX, destY)
+        if not found:
+            pass # path not found, not sure what to do
+        x, y = ctypes.c_int(), ctypes.c_int()
+        xRef, yRef = ctypes.byref(x), ctypes.byref(y)
+        recalculate = ctypes.c_bool(False)
+        path = []
+        while _lib.TCOD_path_walk(self, xRef, yRef, recalculate):
+            path.append(x.value, y.value)
+        return path
+        
+                                                
+    def __del__(self):
+        _lib.TCOD_path_delete(self)
+    
+class Dijkstra(object):
+
+    def __init__(self, width, height, callback, diagnalCost=math.sqrt(2)):
+        def newCallback(fromX, fromY, toX, toY, null):
+            pathCost = callback(toX, toY) # expecting a float or 0
+            return pathCost
+        self.callback = newCallback
+        self._as_parameter_ = _lib.TCOD_dijkstra_new_using_function(width, height,
+                                                newCallback, None, diagnalCost)
+        # add code to compute here with x,y
+        
+    def getPathFrom(self, startX, startY):
+        pass
+        
+    def getPathTo(self, destX, destY):
+        pass
+    
 def bresenham(x1, y1, x2, y2):
     points = []
     issteep = abs(y2-y1) > abs(x2-x1)