def _get_size(self): """Return the (width, height) for this Image. Returns: Tuple[int, int]: The (width, height) of this Image """ w = ffi.new("int *") h = ffi.new("int *") lib.TCOD_image_get_size(self.image_c, w, h) return w[0], h[0]
def __init__( self, dimensions: int, algorithm: int = 2, implementation: int = SIMPLE, hurst: float = 0.5, lacunarity: float = 2.0, octaves: float = 4, seed: Optional[tcod.random.Random] = None, ): if not 0 < dimensions <= 4: raise ValueError("dimensions must be in range 0 < n <= 4, got %r" % (dimensions, )) self._random = seed _random_c = seed.random_c if seed else ffi.NULL self._algorithm = algorithm self.noise_c = ffi.gc( ffi.cast( "struct TCOD_Noise*", lib.TCOD_noise_new(dimensions, hurst, lacunarity, _random_c), ), lib.TCOD_noise_delete, ) self._tdl_noise_c = ffi.new("TDLNoise*", (self.noise_c, dimensions, 0, octaves)) self.implementation = implementation # sanity check
def __init__(self, width, height, order="C"): self._key_color = None self._ch = np.full((height, width), 0x20, dtype=np.intc) self._fg = np.zeros((height, width), dtype="(3,)u1") self._bg = np.zeros((height, width), dtype="(3,)u1") self._order = tcod._internal.verify_order(order) # libtcod uses the root console for defaults. bkgnd_flag = alignment = 0 if lib.TCOD_ctx.root != ffi.NULL: bkgnd_flag = lib.TCOD_ctx.root.bkgnd_flag alignment = lib.TCOD_ctx.root.alignment self._console_data = self.console_c = ffi.new( "struct TCOD_Console*", { "w": width, "h": height, "ch_array": ffi.cast("int*", self._ch.ctypes.data), "fg_array": ffi.cast("TCOD_color_t*", self._fg.ctypes.data), "bg_array": ffi.cast("TCOD_color_t*", self._bg.ctypes.data), "bkgnd_flag": bkgnd_flag, "alignment": alignment, "fore": (255, 255, 255), "back": (0, 0, 0), }, )
def _setstate_old(self, state): self._random = state[0] self.noise_c = ffi.new('struct TCOD_Noise*') self.noise_c.ndim = state[3] ffi.buffer(self.noise_c.map)[:] = state[4] ffi.buffer(self.noise_c.buffer)[:] = state[5] self.noise_c.H = state[6] self.noise_c.lacunarity = state[7] ffi.buffer(self.noise_c.exponent)[:] = state[8] if state[9]: # high change of this being prematurely garbage collected! self.__waveletTileData = ffi.new('float[]', 32 * 32 * 32) ffi.buffer(self.__waveletTileData)[:] = state[9] self.noise_c.noise_type = state[10] self._tdl_noise_c = ffi.new( 'TDLNoise*', (self.noise_c, self.noise_c.ndim, state[1], state[2]))
def __init__(self, width, height, order='C'): self._key_color = None self._ch = np.zeros((height, width), dtype=np.intc) self._fg = np.zeros((height, width), dtype='(3,)u1') self._bg = np.zeros((height, width), dtype='(3,)u1') self._order = tcod._internal.verify_order(order) # libtcod uses the root console for defaults. bkgnd_flag = alignment = 0 if lib.TCOD_ctx.root != ffi.NULL: bkgnd_flag = lib.TCOD_ctx.root.bkgnd_flag alignment = lib.TCOD_ctx.root.alignment self._console_data = self.console_c = ffi.new( 'struct TCOD_Console*', { 'w': width, 'h': height, 'ch_array': ffi.cast('int*', self._ch.ctypes.data), 'fg_array': ffi.cast('TCOD_color_t*', self._fg.ctypes.data), 'bg_array': ffi.cast('TCOD_color_t*', self._bg.ctypes.data), 'bkgnd_flag': bkgnd_flag, 'alignment': alignment, 'fore': (255, 255, 255), 'back': (0, 0, 0), }, )
def __as_cdata(self): return ffi.new('struct TCOD_Map*', ( self.width, self.height, self.width * self.height, ffi.cast('struct TCOD_MapCell*', self.__buffer.ctypes.data), ))
def __as_cdata(self): return ffi.new('map_t *', ( self.width, self.height, self.width * self.height, ffi.cast('cell_t*', self.__buffer.ctypes.data), ))
def __setstate__(self, state: Any) -> None: """Create a new cdata object with the stored paramaters.""" try: cdata = state["random_c"] except KeyError: # old/deprecated format cdata = state["cdata"] del state["cdata"] state["random_c"] = ffi.new("mersenne_data_t*", cdata) self.__dict__.update(state)
def __setstate__(self, state): """Create a new cdata object with the stored paramaters.""" try: cdata = state['random_c'] except KeyError: # old/deprecated format cdata = state['cdata'] del state['cdata'] state['random_c'] = ffi.new('mersenne_data_t*', cdata) self.__dict__.update(state)
def blit(self, dest, dest_x=0, dest_y=0, src_x=0, src_y=0, width=0, height=0, fg_alpha=1.0, bg_alpha=1.0, key_color=None): """Blit from this console onto the ``dest`` console. Args: dest (Console): The destintaion console to blit onto. dest_x (int): Leftmost coordinate of the destintaion console. dest_y (int): Topmost coordinate of the destintaion console. src_x (int): X coordinate from this console to blit, from the left. src_y (int): Y coordinate from this console to blit, from the top. width (int): The width of the region to blit. If this is 0 the maximum possible width will be used. height (int): The height of the region to blit. If this is 0 the maximum possible height will be used. fg_alpha (float): Foreground color alpha vaule. bg_alpha (float): Background color alpha vaule. key_color (Optional[Tuple[int, int, int]]): None, or a (red, green, blue) tuple with values of 0-255. .. versionchanged:: 4.0 Parameters were rearraged and made optional. Previously they were: `(x, y, width, height, dest, dest_x, dest_y, *)` """ # The old syntax is easy to detect and correct. if hasattr(src_y, 'console_c'): src_x, src_y, width, height, dest, dest_x, dest_y = \ dest, dest_x, dest_y, src_x, src_y, width, height warnings.warn( "Parameter names have been moved around, see documentation.", DeprecationWarning, stacklevel=2, ) if key_color or self._key_color: key_color = ffi.new('TCOD_color_t*', key_color) lib.TCOD_console_blit_key_color(self.console_c, src_x, src_y, width, height, dest.console_c, dest_x, dest_y, fg_alpha, bg_alpha, key_color) else: lib.TCOD_console_blit(self.console_c, src_x, src_y, width, height, dest.console_c, dest_x, dest_y, fg_alpha, bg_alpha)
def __setstate__(self, state: Any) -> None: if isinstance(state, tuple): # deprecated format return self._setstate_old(state) # unpack wavelet tile data if it exists if "_waveletTileData" in state: state["_waveletTileData"] = ffi.new("float[]", state["_waveletTileData"]) state["noise_c"]["waveletTileData"] = state["_waveletTileData"] else: state["noise_c"]["waveletTileData"] = ffi.NULL # unpack TCOD_Noise and link to Random instance state["noise_c"]["rand"] = state["_random"].random_c state["noise_c"] = ffi.new("struct TCOD_Noise*", state["noise_c"]) # unpack TDLNoise and link to libtcod noise state["_tdl_noise_c"]["noise"] = state["noise_c"] state["_tdl_noise_c"] = ffi.new("TDLNoise*", state["_tdl_noise_c"]) self.__dict__.update(state)
def __as_cdata(self) -> Any: return ffi.new( "struct TCOD_Map*", ( self.width, self.height, self.width * self.height, ffi.cast("struct TCOD_MapCell*", self.__buffer.ctypes.data), ), )
def __setstate__(self, state): if isinstance(state, tuple): # deprecated format return self._setstate_old(state) # unpack wavelet tile data if it exists if '_waveletTileData' in state: state['_waveletTileData'] = ffi.new('float[]', state['_waveletTileData']) state['noise_c']['waveletTileData'] = state['_waveletTileData'] else: state['noise_c']['waveletTileData'] = ffi.NULL # unpack TCOD_Noise and link to Random instance state['noise_c']['rand'] = state['_random'].random_c state['noise_c'] = ffi.new('struct TCOD_Noise*', state['noise_c']) # unpack TDLNoise and link to libtcod noise state['_tdl_noise_c']['noise'] = state['noise_c'] state['_tdl_noise_c'] = ffi.new('TDLNoise*', state['_tdl_noise_c']) self.__dict__.update(state)
def get_path(self, x: int, y: int) -> List[Tuple[int, int]]: """Return a list of (x, y) steps to reach the goal point, if possible. """ lib.TCOD_dijkstra_path_set(self._path_c, x, y) path = [] pointer_x = ffi.new("int[2]") pointer_y = pointer_x + 1 while lib.TCOD_dijkstra_path_walk(self._path_c, pointer_x, pointer_y): path.append((pointer_x[0], pointer_y[0])) return path
def __setstate__(self, state): self._key_color = None self.__dict__.update(state) self._console_data.update( { 'ch_array': ffi.cast('int*', self._ch.ctypes.data), 'fg_array': ffi.cast('TCOD_color_t*', self._fg.ctypes.data), 'bg_array': ffi.cast('TCOD_color_t*', self._bg.ctypes.data), } ) self._console_data = self.console_c = ffi.new( 'struct TCOD_Console*', self._console_data)
def __setstate__(self, state): self._key_color = None self.__dict__.update(state) self._console_data.update( { "ch_array": ffi.cast("int*", self._ch.ctypes.data), "fg_array": ffi.cast("TCOD_color_t*", self._fg.ctypes.data), "bg_array": ffi.cast("TCOD_color_t*", self._bg.ctypes.data), } ) self._console_data = self.console_c = ffi.new( "struct TCOD_Console*", self._console_data )
def get_tcod_path_ffi(self) -> Tuple[Any, Any, Tuple[int, int]]: if len(self.shape) != 2: raise ValueError("Array must have a 2d shape, shape is %r" % (self.shape, )) if self.dtype.type not in self._C_ARRAY_CALLBACKS: raise ValueError("dtype must be one of %r, dtype is %r" % (self._C_ARRAY_CALLBACKS.keys(), self.dtype.type)) array_type, callback = self._C_ARRAY_CALLBACKS[self.dtype.type] userdata = ffi.new( "struct PathCostArray*", (ffi.cast("char*", self.ctypes.data), self.strides), ) return callback, userdata, self.shape
def get_tcod_path_ffi(self): if len(self.shape) != 2: raise ValueError('Array must have a 2d shape, shape is %r' % (self.shape, )) if self.dtype.type not in self._C_ARRAY_CALLBACKS: raise ValueError('dtype must be one of %r, dtype is %r' % (self._C_ARRAY_CALLBACKS.keys(), self.dtype.type)) array_type, callback = \ self._C_ARRAY_CALLBACKS[self.dtype.type] userdata = ffi.new( 'PathCostArray*', (self.width, ffi.cast(array_type, self.ctypes.data)), ) return callback, userdata, self.width, self.height
def __init__( self, width: int, height: int, order: str = "C", buffer: Optional[np.array] = None, ): self._key_color = None # type: Optional[Tuple[int, int, int]] self._order = tcod._internal.verify_order(order) if buffer is not None: if self._order == "F": buffer = buffer.transpose() self._ch = np.ascontiguousarray(buffer["ch"], np.intc) self._fg = np.ascontiguousarray(buffer["fg"], "u1") self._bg = np.ascontiguousarray(buffer["bg"], "u1") else: self._ch = np.ndarray((height, width), dtype=np.intc) self._fg = np.ndarray((height, width), dtype=self._DTYPE_RGB) self._bg = np.ndarray((height, width), dtype=self._DTYPE_RGB) # libtcod uses the root console for defaults. default_bg_blend = 0 default_alignment = 0 if lib.TCOD_ctx.root != ffi.NULL: default_bg_blend = lib.TCOD_ctx.root.bkgnd_flag default_alignment = lib.TCOD_ctx.root.alignment self._console_data = self.console_c = ffi.new( "struct TCOD_Console*", { "w": width, "h": height, "ch_array": ffi.cast("int*", self._ch.ctypes.data), "fg_array": ffi.cast("TCOD_color_t*", self._fg.ctypes.data), "bg_array": ffi.cast("TCOD_color_t*", self._bg.ctypes.data), "bkgnd_flag": default_bg_blend, "alignment": default_alignment, "fore": (255, 255, 255), "back": (0, 0, 0), }, ) if buffer is None: self.clear()
def __setstate__(self, state: Any) -> None: self._key_color = None if "_tiles" not in state: tiles = np.ndarray((self.height, self.width), dtype=self.DTYPE) tiles["ch"] = state["_ch"] tiles["fg"][..., :3] = state["_fg"] tiles["fg"][..., 3] = 255 tiles["bg"][..., :3] = state["_bg"] tiles["bg"][..., 3] = 255 state["_tiles"] = tiles del state["_ch"] del state["_fg"] del state["_bg"] self.__dict__.update(state) self._console_data["tiles"] = ffi.cast("struct TCOD_ConsoleTile*", self._tiles.ctypes.data) self._console_data = self.console_c = ffi.new("struct TCOD_Console*", self._console_data)
def get_path(self, start_x, start_y, goal_x, goal_y): """Return a list of (x, y) steps to reach the goal point, if possible. Args: start_x (int): Starting X position. start_y (int): Starting Y position. goal_x (int): Destination X position. goal_y (int): Destination Y position. Returns: List[Tuple[int, int]]: A list of points, or an empty list if there is no valid path. """ lib.TCOD_path_compute(self._path_c, start_x, start_y, goal_x, goal_y) path = [] x = ffi.new('int[2]') y = x + 1 while lib.TCOD_path_walk(self._path_c, x, y, False): path.append((x[0], y[0])) return path
def __init__(self, dimensions, algorithm=2, implementation=SIMPLE, hurst=0.5, lacunarity=2.0, octaves=4, seed=None): if not 0 < dimensions <= 4: raise ValueError('dimensions must be in range 0 < n <= 4, got %r' % (dimensions,)) self._random = seed _random_c = seed.random_c if seed else ffi.NULL self._algorithm = algorithm self.noise_c = ffi.gc( ffi.cast( 'perlin_data_t*', lib.TCOD_noise_new(dimensions, hurst, lacunarity, _random_c), ), lib.TCOD_noise_delete) self._tdl_noise_c = ffi.new('TDLNoise*', (self.noise_c, dimensions, 0, octaves)) self.implementation = implementation # sanity check