added Map class, AStar.getPath is now AStar.get_path, cleaned up map.py

Author: HexDecimal

tdl/map.py

@@ -14,9 +14,6 @@
 
 _FOVTYPES = {'BASIC' : 0, 'DIAMOND': 1, 'SHADOW': 2, 'RESTRICTIVE': 12, 'PERMISSIVE': 11}
 
-
-#_PATHCALL = CFUNCTYPE(c_float, c_int, c_int, c_int, c_int, py_object)
-
 def _get_fov_type(fov):
     "Return a FOV from a string"
     oldFOV = fov
@@ -27,10 +24,182 @@ def _get_fov_type(fov):
         return 4 + int(fov[10])
     raise _tdl.TDLError('No such fov option as %s' % oldFOV)
 
+class Map(object):
+    """Fast field-of-view and path-finding on stored data.
+    
+    Set map conditions with the walkable and transparency attributes, this
+    object can be iterated and checked for containment similar to consoles.
+    
+    For example, you can set all tiles and transparent and walkable with the
+    following code::
+    
+        map = tdl.map.Map(80, 60)
+        for x,y in map:
+            map.transparent[x,y] = true
+            map.walkable[x,y] = true
+    
+    @ivar transparent: Map transparency, access this attribute with
+                       map.transparency[x,y]
+                       
+                       Set to True to allow field-of-view rays, False will
+                       block field-of-view.
+                       
+                       Transparent tiles only affect field-of-view.
+
+    @ivar walkable: Map accessibility, access this attribute with
+                    map.walkable[x,y]
+                    
+                    Set to True to allow path-finding through that tile,
+                    False will block passage to that tile.
+                    
+                    Walkable tiles only affect path-finding.
+                    
+    @ivar fov: Map tiles touched by a field-of-view computation,
+               access this attribute with map.fov[x,y]
+               
+               Is True if a the tile is if view, otherwise False.
+               
+               You can set to this attribute if you want, but you'll typically
+               be using it to read the field-of-view of a L{compute_fov} call.
+    """
+
+    class _MapAttribute(object):
+        def __init__(self, map, bit_index):
+            self.map = map
+            self.bit_index = bit_index
+            self.bit = 1 << bit_index
+            self.bit_inverse = 0xFFFF ^ self.bit
+            
+        def __getitem__(self, key):
+            return bool(self.map._array_cdata[key[1]][key[0]] & self.bit)
+            
+        def __setitem__(self, key, value):
+            self.map._array_cdata[key[1]][key[0]] = (
+                (self.map._array_cdata[key[1]][key[0]] & self.bit_inverse) |
+                (self.bit * bool(value))
+                )
+                
+    def __init__(self, width, height):
+        """Create a new Map with width and height.
+        
+        @type width: int
+        @type height: int
+        @param width: Width of the new Map instance, in tiles.
+        @param width: Height of the new Map instance, in tiles.
+        """
+        self.width = width
+        self.height = height
+        self._map_cdata = _lib.TCOD_map_new(width, height)
+        # cast array into cdata format: int16[y][x]
+        # for quick Python access
+        self._array_cdata = _ffi.new('int16[%i][%i]' % (width, height))
+        # flat array to pass to TDL's C helpers
+        self._array_cdata_flat = _ffi.cast('int16 *', self._array_cdata)
+        self.transparent = self._MapAttribute(self, 0)
+        self.walkable = self._MapAttribute(self, 1)
+        self.fov = self._MapAttribute(self, 2)
+        
+    def __del__(self):
+        if self._map_cdata:
+            _lib.TCOD_map_delete(self._map_cdata)
+            self._map_cdata = None
+        
+    def compute_fov(self, x, y, fov='PERMISSIVE', radius=None, light_walls=True,
+                    sphere=True, cumulative=False):
+        """Compute the field-of-view of this Map and return an iterator of the
+        points touched.
+        
+        @type x: int
+        @type y: int
+    
+        @param x: x center of the field-of-view
+        @param y: y center of the field-of-view
+        @type fov: string
+        @param fov: The type of field-of-view to be used.  Available types are:
+    
+                    'BASIC', 'DIAMOND', 'SHADOW', 'RESTRICTIVE', 'PERMISSIVE',
+                    'PERMISSIVE0', 'PERMISSIVE1', ..., 'PERMISSIVE8'
+        @type radius: int
+        @param radius: Raduis of the field-of-view.
+        @type light_walls: boolean
+        @param light_walls: Include or exclude wall tiles in the field-of-view.
+        @type sphere: boolean
+        @param sphere: True for a spherical field-of-view.
+                       False for a square one.
+        @type cumulative: boolean
+        @param cumulative: 
+    
+        @rtype: iter((x, y), ...)
+        @return: An iterator of (x, y) points of tiles touched by the
+                 field-of-view.
+                 
+                 Unexpected behaviour can happen if you modify the Map while
+                 using the iterator.
+                 
+                 You can use the Map's fov attribute as an alternative to this
+                 iterator.
+        """
+        # refresh cdata
+        _lib.TDL_map_data_from_buffer(self._map_cdata,
+                                      self._array_cdata_flat)
+        if radius is None: # infinite radius
+            radius = max(self.width, self.height)
+        _lib.TCOD_map_compute_fov(self.cdata, x, y, radius, light_walls,
+                                  _get_fov_type(fov))
+        _lib.TDL_map_fov_to_buffer(self._map_cdata,
+                                   self._array_cdata_flat, cumulative)
+        def iterate_fov():
+            _array_cdata = self._array_cdata
+            for y in range(self.width):
+                for x in range(self.height):
+                    if(_array_cdata[y][x] & 4):
+                        yield (x, y)
+        return iterate_fov()
+        
+        
+        
+    def compute_path(self, start_x, start_y, dest_x, dest_y,
+                     diagonal_cost=_math.sqrt(2)):
+        """
+        
+        @type diagnalCost: float
+        @param diagnalCost: Multiplier for diagonal movement.
+        
+                            Can be set to zero to disable diagonal movement
+                            entirely.
+        """
+        # refresh cdata
+        _lib.TDL_map_data_from_buffer(self._map_cdata,
+                                      self._array_cdata_flat)
+        path_cdata = _lib.TCOD_path_new_using_map(self._map_cdata, diagonal_cost)
+        try:
+            _lib.TCOD_path_compute(path_cdata, start_x, start_y, dest_x, dest_y)
+            x = _ffi.new('int *')
+            y = _ffi.new('int *')
+            length = _lib.TCOD_path_size(path_cdata)
+            path = [None] * length
+            for i in range(length):
+                _lib.TCOD_path_get(path_cdata, i, x, y)
+                path[i] = ((x[0], y[0]))
+        finally:
+            _lib.TCOD_path_delete(path_cdata)
+        return path
+    
+    def __iter__(self):
+        return _itertools.product(range(self.width), range(self.height))
+        
+    def __contains__(self, position):
+        x, y = position
+        return (0 <= x < self.width) and (0 <= y < self.height)
+        
+    
+    
 class AStar(object):
     """A* pathfinder
     
     Using this class requires a callback detailed in L{AStar.__init__}
+    
+    @undocumented: getPath
     """
 
     __slots__ = ('_as_parameter_', '_callback', '__weakref__')
@@ -92,8 +261,8 @@ def newCallback(sourceX, sourceY, destX, destY, null):
                 if pathCost:
                     return pathCost
                 return 0.0
+        # float(int, int, int, int, void*)
         self._callback = _ffi.callback('TCOD_path_func_t')(newCallback)
-        """A cffi callback to be kept in memory."""
 
         self._as_parameter_ = _lib.TCOD_path_new_using_function(width, height,
                                      self._callback, _ffi.NULL, diagnalCost)
@@ -103,7 +272,7 @@ def __del__(self):
             _lib.TCOD_path_delete(self._as_parameter_)
             self._as_parameter_ = None
 
-    def getPath(self, origX, origY, destX, destY):
+    def get_path(self, origX, origY, destX, destY):
         """
         Get the shortest path from origXY to destXY.
         
@@ -175,25 +344,18 @@ def quick_fov(x, y, callback, fov='PERMISSIVE', radius=7.5, lightWalls=True, sph
     setProp = _lib.TCOD_map_set_properties # make local
     inFOV = _lib.TCOD_map_is_in_fov
 
-    #cTrue = _ffi.new('bool *', True)
-    #cFalse = _ffi.new('bool *', False)
-    #cFalse = _ctypes.c_bool(False)
     tcodMap = _lib.TCOD_map_new(mapSize, mapSize)
     try:
-        # pass one, write callback data to the tcodMap
-        #for (x_, cX), (y_, cY) in _itertools.product(((i, _ctypes.c_int(i)) for i in range(mapSize)),
-        #                                            ((i, _ctypes.c_int(i)) for i in range(mapSize))):
+        # pass no.1, write callback data to the tcodMap
         for x_, y_ in _itertools.product(range(mapSize), range(mapSize)):
             pos = (x_ + x - radius, 
                    y_ + y - radius)
             transparent = bool(callback(*pos))
             setProp(tcodMap, x_, y_, transparent, False)
 
-        # pass two, compute fov and build a list of points
+        # pass no.2, compute fov and build a list of points
         _lib.TCOD_map_compute_fov(tcodMap, radius, radius, radius, lightWalls, fov)
         touched = set() # points touched by field of view
-        #for (x_, cX),(y_, cY) in _itertools.product(((i, _ctypes.c_int(i)) for i in range(mapSize)),
-        #                                           ((i, _ctypes.c_int(i)) for i in range(mapSize))):
         for x_, y_ in _itertools.product(range(mapSize), range(mapSize)):
             if sphere and _math.hypot(x_ - radius, y_ - radius) > trueRadius:
                 continue
@@ -245,6 +407,8 @@ def bresenham(x1, y1, x2, y2):
         points.reverse()
     return points
 
+    
 __all__ = [_var for _var in locals().keys() if _var[0] != '_']
 
 quickFOV = _style.backport(quick_fov)
+AStar.getPath = _style.backport(AStar.get_path)