from __future__ import absolute_import as _

import os

import sys

import threading as _threading

import warnings

import numpy as _np

import numpy as np

from tcod.libtcod import *

from tcod._internal import deprecate

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

from tcod.tcod import _console

import tcod.bsp

from tcod.color import Color

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))

_LOOKUP_VK = {

value:'KEY_%s' % key[6:] for key,value in lib.__dict__.items()

if key.startswith('TCODK')

}

class Key(_CDataWrapper):

return 'tcod.Key(%s)' % ', '.join(params)

class Mouse(_CDataWrapper):

return 'tcod.Mouse(%s)' % ', '.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):

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._get_root(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(_console(con))

def console_get_height(con):

return lib.TCOD_console_get_height(_console(con))

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_has_mouse_focus():

"""Return True if the window has mouse focus."""

return lib.TCOD_console_has_mouse_focus()

def console_is_active():

"""Return True if the window has keyboard focus."""

return lib.TCOD_console_is_active()

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):

lib.TCOD_console_set_default_background(_console(con), col)

def console_set_default_foreground(con, col):

lib.TCOD_console_set_default_foreground(_console(con), col)

def console_clear(con):

return lib.TCOD_console_clear(_console(con))

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

lib.TCOD_console_put_char(_console(con), x, y, _int(c), flag)

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

lib.TCOD_console_put_char_ex(_console(con), x, y, _int(c), fore, back)

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

lib.TCOD_console_set_char_background(_console(con), x, y, col, flag)

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

lib.TCOD_console_set_char_foreground(_console(con), x, y, col)

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

lib.TCOD_console_set_char(_console(con), x, y, _int(c))

def console_set_background_flag(con, flag):

lib.TCOD_console_set_background_flag(_console(con), flag)

def console_get_background_flag(con):

return lib.TCOD_console_get_background_flag(_console(con))

def console_set_alignment(con, alignment):

lib.TCOD_console_set_alignment(_console(con), alignment)

def console_get_alignment(con):

return lib.TCOD_console_get_alignment(_console(con))

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

lib.TCOD_console_print(_console(con), 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):

_console(con), x, y, w, h, _fmt_unicode(fmt))

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

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

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

_console(con), x, y, w, h, _fmt_unicode(fmt))

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

lib.TCOD_console_rect(_console(con), x, y, w, h, clr, flag)

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

lib.TCOD_console_hline(_console(con), x, y, l, flag)