from __future__ import absolute_import as _

import os

import sys

import threading as _threading

import numpy as _np

from tcod.libtcod import *

from tcod.tcod import _int, _unpack_char_p

from tcod.tcod import _bytes, _unicode, _fmt_bytes, _fmt_unicode

from tcod.tcod import _CDataWrapper

from tcod.tcod import _PropagateException

import tcod.bsp

from tcod.color import *

import tcod.console

import tcod.image

import tcod.map

import tcod.noise

import tcod.path

import tcod.random

Bsp = tcod.bsp.BSP

class ConsoleBuffer(object):

dest.ch.ravel()[:] = self.char

class Dice(_CDataWrapper):

self.multiplier, self.addsub))

class Key(_CDataWrapper):

return ('%s(%s)' % (self.__class__.__name__, ', '.join(params)))

class Mouse(_CDataWrapper):

return ('%s(%s)' % (self.__class__.__name__, ', '.join(params)))

def bsp_new_with_size(x, y, w, h):

return Bsp(x, y, w, h)

def bsp_split_once(node, horizontal, position):

node.split_once(horizontal, position)

def bsp_split_recursive(node, randomizer, nb, minHSize, minVSize, maxHRatio,

maxHRatio, maxVRatio, randomizer)

def bsp_resize(node, x, y, w, h):

node.height = h

def bsp_left(node):

return None if not node.children else node.children[0]

def bsp_right(node):

return None if not node.children else node.children[1]

def bsp_father(node):

return node.parent

def bsp_is_leaf(node):

return not node.children

def bsp_contains(node, cx, cy):

return node.contains(cx, cy)

def bsp_find_node(node, cx, cy):

return node.find_node(cx, cy)

def _bsp_traverse(node_iter, callback, userData):

callback(node, userData)

def bsp_traverse_pre_order(node, callback, userData=0):

_bsp_traverse(node._iter_pre_order(), callback, userData)

def bsp_traverse_in_order(node, callback, userData=0):

_bsp_traverse(node._iter_in_order(), callback, userData)

def bsp_traverse_post_order(node, callback, userData=0):

_bsp_traverse(node._iter_post_order(), callback, userData)

def bsp_traverse_level_order(node, callback, userData=0):

_bsp_traverse(node._iter_level_order(), callback, userData)

def bsp_traverse_inverted_level_order(node, callback, userData=0):

_bsp_traverse(node._iter_inverted_level_order(), callback, userData)

def bsp_remove_sons(node):

node.children = ()

def bsp_delete(node):

pass

def color_lerp(c1, c2, a):

return Color._new_from_cdata(lib.TCOD_color_lerp(c1, c2, a))

def color_set_hsv(c, h, s, v):

c[:] = new_color.r, new_color.g, new_color.b

def color_get_hsv(c):

return hsv[0], hsv[1], hsv[2]

def color_scale_HSV(c, scoef, vcoef):

c[:] = color_p.r, color_p.g, color_p.b

def color_gen_map(colors, indexes):

return [Color._new_from_cdata(cdata) for cdata in cres]

def console_init_root(w, h, title=None, fullscreen=False,

return tcod.console.Console._from_cdata(ffi.NULL, order)

def console_set_custom_font(fontFile, flags=FONT_LAYOUT_ASCII_INCOL,

nb_char_horiz, nb_char_vertic)

def console_get_width(con):

return lib.TCOD_console_get_width(con.console_c if con else ffi.NULL)

def console_get_height(con):

return lib.TCOD_console_get_height(con.console_c if con else ffi.NULL)

def console_map_ascii_code_to_font(asciiCode, fontCharX, fontCharY):

fontCharY)

def console_map_ascii_codes_to_font(firstAsciiCode, nbCodes, fontCharX,

fontCharX, fontCharY)

def console_map_string_to_font(s, fontCharX, fontCharY):

lib.TCOD_console_map_string_to_font_utf(_unicode(s), fontCharX, fontCharY)

def console_is_fullscreen():

return bool(lib.TCOD_console_is_fullscreen())

def console_set_fullscreen(fullscreen):

lib.TCOD_console_set_fullscreen(fullscreen)

def console_is_window_closed():

"""Returns True if the window has received and exit event."""

return lib.TCOD_console_is_window_closed()

def console_set_window_title(title):

lib.TCOD_console_set_window_title(_bytes(title))

def console_credits():

lib.TCOD_console_credits()

def console_credits_reset():

lib.TCOD_console_credits_reset()

def console_credits_render(x, y, alpha):

return lib.TCOD_console_credits_render(x, y, alpha)

def console_flush():

"""Update the display to represent the root consoles current state."""

lib.TCOD_console_flush()

def console_set_default_background(con, col):

con.console_c if con else ffi.NULL, col)

def console_set_default_foreground(con, col):

con.console_c if con else ffi.NULL, col)

def console_clear(con):

return lib.TCOD_console_clear(con.console_c if con else ffi.NULL)

def console_put_char(con, x, y, c, flag=BKGND_DEFAULT):

con.console_c if con else ffi.NULL, x, y, _int(c), flag)

def console_put_char_ex(con, x, y, c, fore, back):

_int(c), fore, back)

def console_set_char_background(con, x, y, col, flag=BKGND_SET):

con.console_c if con else ffi.NULL, x, y, col, flag)

def console_set_char_foreground(con, x, y, col):

con.console_c if con else ffi.NULL, x, y, col)

def console_set_char(con, x, y, c):

con.console_c if con else ffi.NULL, x, y, _int(c))

def console_set_background_flag(con, flag):

con.console_c if con else ffi.NULL, flag)

def console_get_background_flag(con):

con.console_c if con else ffi.NULL)

def console_set_alignment(con, alignment):

con.console_c if con else ffi.NULL, alignment)

def console_get_alignment(con):

return lib.TCOD_console_get_alignment(con.console_c if con else ffi.NULL)

def console_print(con, x, y, fmt):

con.console_c if con else ffi.NULL, x, y, _fmt_unicode(fmt))

def console_print_ex(con, x, y, flag, alignment, fmt):

x, y, flag, alignment, _fmt_unicode(fmt))

def console_print_rect(con, x, y, w, h, fmt):

con.console_c if con else ffi.NULL, x, y, w, h, _fmt_unicode(fmt))

def console_print_rect_ex(con, x, y, w, h, flag, alignment, fmt):

x, y, w, h, flag, alignment, _fmt_unicode(fmt))

def console_get_height_rect(con, x, y, w, h, fmt):

con.console_c if con else ffi.NULL, x, y, w, h, _fmt_unicode(fmt))

def console_rect(con, x, y, w, h, clr, flag=BKGND_DEFAULT):

con.console_c if con else ffi.NULL, x, y, w, h, clr, flag)

def console_hline(con, x, y, l, flag=BKGND_DEFAULT):

lib.TCOD_console_hline(con.console_c if con else ffi.NULL, x, y, l, flag)

def console_vline(con, x, y, l, flag=BKGND_DEFAULT):

lib.TCOD_console_vline(con.console_c if con else ffi.NULL, x, y, l, flag)

def console_print_frame(con, x, y, w, h, clear=True, flag=BKGND_DEFAULT, fmt=b''):

x, y, w, h, clear, flag, _fmt_bytes(fmt))

def console_set_color_control(con, fore, back):

lib.TCOD_console_set_color_control(con, fore, back)

def console_get_default_background(con):

con.console_c if con else ffi.NULL))

def console_get_default_foreground(con):

con.console_c if con else ffi.NULL))

def console_get_char_background(con, x, y):

con.console_c if con else ffi.NULL, x, y))

def console_get_char_foreground(con, x, y):

con.console_c if con else ffi.NULL, x, y))