text: #
  # libtcod 1.6.0 python wrapper
  # Copyright (c) 2008,2009,2010,2012,2013 Jice & Mingos
  # All rights reserved.
  #
  # Redistribution and use in source and binary forms, with or without
  # modification, are permitted provided that the following conditions are met:
  #     * Redistributions of source code must retain the above copyright
  #       notice, this list of conditions and the following disclaimer.
  #     * Redistributions in binary form must reproduce the above copyright
  #       notice, this list of conditions and the following disclaimer in the
  #       documentation and/or other materials provided with the distribution.
  #     * The name of Jice or Mingos may not be used to endorse or promote products
  #       derived from this software without specific prior written permission.
  #
  # THIS SOFTWARE IS PROVIDED BY JICE AND MINGOS ``AS IS'' AND ANY
  # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  # DISCLAIMED. IN NO EVENT SHALL JICE OR MINGOS BE LIABLE FOR ANY
  # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  #
  
  import sys
  import ctypes
  import struct
  from ctypes import *
  
  if not hasattr(ctypes, "c_bool"):   # for Python < 2.6
      c_bool = c_uint8
  
  try:  #import NumPy if available
      import numpy
      numpy_available = True
  except ImportError:
      numpy_available = False
  
  LINUX=False
  MAC=False
  MINGW=False
  MSVC=False
  if sys.platform.find('linux') != -1:
      _lib = ctypes.cdll['./libtcod.so']
      LINUX=True
  elif sys.platform.find('darwin') != -1:
      _lib = ctypes.cdll['./libtcod.dylib']
      MAC = True
  elif sys.platform.find('haiku') != -1:
      _lib = ctypes.cdll['./libtcod.so']
      HAIKU = True
  else:
      try:
          _lib = ctypes.cdll['./libtcod-mingw.dll']
          MINGW=True
      except WindowsError:
          _lib = ctypes.cdll['./libtcod-VS.dll']
          MSVC=True
      # On Windows, ctypes doesn't work well with function returning structs,
      # so we have to user the _wrapper functions instead
      _lib.TCOD_color_multiply = _lib.TCOD_color_multiply_wrapper
      _lib.TCOD_color_add = _lib.TCOD_color_add_wrapper
      _lib.TCOD_color_multiply_scalar = _lib.TCOD_color_multiply_scalar_wrapper
      _lib.TCOD_color_subtract = _lib.TCOD_color_subtract_wrapper
      _lib.TCOD_color_lerp = _lib.TCOD_color_lerp_wrapper
      _lib.TCOD_console_get_default_background = _lib.TCOD_console_get_default_background_wrapper
      _lib.TCOD_console_get_default_foreground = _lib.TCOD_console_get_default_foreground_wrapper
      _lib.TCOD_console_get_char_background = _lib.TCOD_console_get_char_background_wrapper
      _lib.TCOD_console_get_char_foreground = _lib.TCOD_console_get_char_foreground_wrapper
      _lib.TCOD_console_get_fading_color = _lib.TCOD_console_get_fading_color_wrapper
      _lib.TCOD_image_get_pixel = _lib.TCOD_image_get_pixel_wrapper
      _lib.TCOD_image_get_mipmap_pixel = _lib.TCOD_image_get_mipmap_pixel_wrapper
      _lib.TCOD_parser_get_color_property = _lib.TCOD_parser_get_color_property_wrapper
  
  HEXVERSION = 0x010600
  STRVERSION = "1.6.0"
  TECHVERSION = 0x01060000
  
  ############################
  # color module
  ############################
  class Color(Structure):
      _fields_ = [('r', c_uint8),
                  ('g', c_uint8),
                  ('b', c_uint8),
                  ]
  
      def __eq__(self, c):
          return _lib.TCOD_color_equals(self, c)
  
      def __mul__(self, c):
          if isinstance(c,Color):
              return _lib.TCOD_color_multiply(self, c)
          else:
              return _lib.TCOD_color_multiply_scalar(self, c_float(c))
  
      def __add__(self, c):
          return _lib.TCOD_color_add(self, c)
  
      def __sub__(self, c):
          return _lib.TCOD_color_subtract(self, c)
  
      def __repr__(self):
          return "Color(%d,%d,%d)" % (self.r, self.g, self.b)
  
      def __getitem__(self, i):
          if type(i) == str:
              return getattr(self, i)
          else:
              return getattr(self, "rgb"[i])
  
      def __setitem__(self, i, c):
          if type(i) == str:
              setattr(self, i, c)
          else:
              setattr(self, "rgb"[i], c)
  
      def __iter__(self):
          yield self.r
          yield self.g
          yield self.b
  
  # Should be valid on any platform, check it!  Has to be done after Color is defined.
  if MAC:
      from cprotos import setup_protos
      setup_protos(_lib)
  
  _lib.TCOD_color_equals.restype = c_bool
  _lib.TCOD_color_multiply.restype = Color
  _lib.TCOD_color_multiply_scalar.restype = Color
  _lib.TCOD_color_add.restype = Color
  _lib.TCOD_color_subtract.restype = Color
  
  # default colors
  # grey levels
  black=Color(0,0,0)
  darkest_grey=Color(31,31,31)
  darker_grey=Color(63,63,63)
  dark_grey=Color(95,95,95)
  grey=Color(127,127,127)
  light_grey=Color(159,159,159)
  lighter_grey=Color(191,191,191)
  lightest_grey=Color(223,223,223)
  darkest_gray=Color(31,31,31)
  darker_gray=Color(63,63,63)
  dark_gray=Color(95,95,95)
  gray=Color(127,127,127)
  light_gray=Color(159,159,159)
  lighter_gray=Color(191,191,191)
  lightest_gray=Color(223,223,223)
  white=Color(255,255,255)
  
  # sepia
  darkest_sepia=Color(31,24,15)
  darker_sepia=Color(63,50,31)
  dark_sepia=Color(94,75,47)
  sepia=Color(127,101,63)
  light_sepia=Color(158,134,100)
  lighter_sepia=Color(191,171,143)
  lightest_sepia=Color(222,211,195)
  
  #standard colors
  red=Color(255,0,0)
  flame=Color(255,63,0)
  orange=Color(255,127,0)
  amber=Color(255,191,0)
  yellow=Color(255,255,0)
  lime=Color(191,255,0)
  chartreuse=Color(127,255,0)
  green=Color(0,255,0)
  sea=Color(0,255,127)
  turquoise=Color(0,255,191)
  cyan=Color(0,255,255)
  sky=Color(0,191,255)
  azure=Color(0,127,255)
  blue=Color(0,0,255)
  han=Color(63,0,255)
  violet=Color(127,0,255)
  purple=Color(191,0,255)
  fuchsia=Color(255,0,255)
  magenta=Color(255,0,191)
  pink=Color(255,0,127)
  crimson=Color(255,0,63)
  
  # dark colors
  dark_red=Color(191,0,0)
  dark_flame=Color(191,47,0)
  dark_orange=Color(191,95,0)
  dark_amber=Color(191,143,0)
  dark_yellow=Color(191,191,0)
  dark_lime=Color(143,191,0)
  dark_chartreuse=Color(95,191,0)
  dark_green=Color(0,191,0)
  dark_sea=Color(0,191,95)
  dark_turquoise=Color(0,191,143)
  dark_cyan=Color(0,191,191)
  dark_sky=Color(0,143,191)
  dark_azure=Color(0,95,191)
  dark_blue=Color(0,0,191)
  dark_han=Color(47,0,191)
  dark_violet=Color(95,0,191)
  dark_purple=Color(143,0,191)
  dark_fuchsia=Color(191,0,191)
  dark_magenta=Color(191,0,143)
  dark_pink=Color(191,0,95)
  dark_crimson=Color(191,0,47)
  
  # darker colors
  darker_red=Color(127,0,0)
  darker_flame=Color(127,31,0)
  darker_orange=Color(127,63,0)
  darker_amber=Color(127,95,0)
  darker_yellow=Color(127,127,0)
  darker_lime=Color(95,127,0)
  darker_chartreuse=Color(63,127,0)
  darker_green=Color(0,127,0)
  darker_sea=Color(0,127,63)
  darker_turquoise=Color(0,127,95)
  darker_cyan=Color(0,127,127)
  darker_sky=Color(0,95,127)
  darker_azure=Color(0,63,127)
  darker_blue=Color(0,0,127)
  darker_han=Color(31,0,127)
  darker_violet=Color(63,0,127)
  darker_purple=Color(95,0,127)
  darker_fuchsia=Color(127,0,127)
  darker_magenta=Color(127,0,95)
  darker_pink=Color(127,0,63)
  darker_crimson=Color(127,0,31)
  
  # darkest colors
  darkest_red=Color(63,0,0)
  darkest_flame=Color(63,15,0)
  darkest_orange=Color(63,31,0)
  darkest_amber=Color(63,47,0)
  darkest_yellow=Color(63,63,0)
  darkest_lime=Color(47,63,0)
  darkest_chartreuse=Color(31,63,0)
  darkest_green=Color(0,63,0)
  darkest_sea=Color(0,63,31)
  darkest_turquoise=Color(0,63,47)
  darkest_cyan=Color(0,63,63)
  darkest_sky=Color(0,47,63)
  darkest_azure=Color(0,31,63)
  darkest_blue=Color(0,0,63)
  darkest_han=Color(15,0,63)
  darkest_violet=Color(31,0,63)
  darkest_purple=Color(47,0,63)
  darkest_fuchsia=Color(63,0,63)
  darkest_magenta=Color(63,0,47)
  darkest_pink=Color(63,0,31)
  darkest_crimson=Color(63,0,15)
  
  # light colors
  light_red=Color(255,114,114)
  light_flame=Color(255,149,114)
  light_orange=Color(255,184,114)
  light_amber=Color(255,219,114)
  light_yellow=Color(255,255,114)
  light_lime=Color(219,255,114)
  light_chartreuse=Color(184,255,114)
  light_green=Color(114,255,114)
  light_sea=Color(114,255,184)
  light_turquoise=Color(114,255,219)
  light_cyan=Color(114,255,255)
  light_sky=Color(114,219,255)
  light_azure=Color(114,184,255)
  light_blue=Color(114,114,255)
  light_han=Color(149,114,255)
  light_violet=Color(184,114,255)
  light_purple=Color(219,114,255)
  light_fuchsia=Color(255,114,255)
  light_magenta=Color(255,114,219)
  light_pink=Color(255,114,184)
  light_crimson=Color(255,114,149)
  
  #lighter colors
  lighter_red=Color(255,165,165)
  lighter_flame=Color(255,188,165)
  lighter_orange=Color(255,210,165)
  lighter_amber=Color(255,232,165)
  lighter_yellow=Color(255,255,165)
  lighter_lime=Color(232,255,165)
  lighter_chartreuse=Color(210,255,165)
  lighter_green=Color(165,255,165)
  lighter_sea=Color(165,255,210)
  lighter_turquoise=Color(165,255,232)
  lighter_cyan=Color(165,255,255)
  lighter_sky=Color(165,232,255)
  lighter_azure=Color(165,210,255)
  lighter_blue=Color(165,165,255)
  lighter_han=Color(188,165,255)
  lighter_violet=Color(210,165,255)
  lighter_purple=Color(232,165,255)
  lighter_fuchsia=Color(255,165,255)
  lighter_magenta=Color(255,165,232)
  lighter_pink=Color(255,165,210)
  lighter_crimson=Color(255,165,188)
  
  # lightest colors
  lightest_red=Color(255,191,191)
  lightest_flame=Color(255,207,191)
  lightest_orange=Color(255,223,191)
  lightest_amber=Color(255,239,191)
  lightest_yellow=Color(255,255,191)
  lightest_lime=Color(239,255,191)
  lightest_chartreuse=Color(223,255,191)
  lightest_green=Color(191,255,191)
  lightest_sea=Color(191,255,223)
  lightest_turquoise=Color(191,255,239)
  lightest_cyan=Color(191,255,255)
  lightest_sky=Color(191,239,255)
  lightest_azure=Color(191,223,255)
  lightest_blue=Color(191,191,255)
  lightest_han=Color(207,191,255)
  lightest_violet=Color(223,191,255)
  lightest_purple=Color(239,191,255)
  lightest_fuchsia=Color(255,191,255)
  lightest_magenta=Color(255,191,239)
  lightest_pink=Color(255,191,223)
  lightest_crimson=Color(255,191,207)
  
  # desaturated colors
  desaturated_red=Color(127,63,63)
  desaturated_flame=Color(127,79,63)
  desaturated_orange=Color(127,95,63)
  desaturated_amber=Color(127,111,63)
  desaturated_yellow=Color(127,127,63)
  desaturated_lime=Color(111,127,63)
  desaturated_chartreuse=Color(95,127,63)
  desaturated_green=Color(63,127,63)
  desaturated_sea=Color(63,127,95)
  desaturated_turquoise=Color(63,127,111)
  desaturated_cyan=Color(63,127,127)
  desaturated_sky=Color(63,111,127)
  desaturated_azure=Color(63,95,127)
  desaturated_blue=Color(63,63,127)
  desaturated_han=Color(79,63,127)
  desaturated_violet=Color(95,63,127)
  desaturated_purple=Color(111,63,127)
  desaturated_fuchsia=Color(127,63,127)
  desaturated_magenta=Color(127,63,111)
  desaturated_pink=Color(127,63,95)
  desaturated_crimson=Color(127,63,79)
  
  # metallic
  brass=Color(191,151,96)
  copper=Color(197,136,124)
  gold=Color(229,191,0)
  silver=Color(203,203,203)
  
  # miscellaneous
  celadon=Color(172,255,175)
  peach=Color(255,159,127)
  
  # color functions
  _lib.TCOD_color_lerp.restype = Color
  def color_lerp(c1, c2, a):
      return _lib.TCOD_color_lerp(c1, c2, c_float(a))
  
  def color_set_hsv(c, h, s, v):
      _lib.TCOD_color_set_HSV(byref(c), c_float(h), c_float(s), c_float(v))
  
  def color_get_hsv(c):
      h = c_float()
      s = c_float()
      v = c_float()
      _lib.TCOD_color_get_HSV(c, byref(h), byref(s), byref(v))
      return h.value, s.value, v.value
  
  def color_scale_HSV(c, scoef, vcoef) :
      _lib.TCOD_color_scale_HSV(byref(c),c_float(scoef),c_float(vcoef))
  
  def color_gen_map(colors, indexes):
      ccolors = (Color * len(colors))(*colors)
      cindexes = (c_int * len(indexes))(*indexes)
      cres = (Color * (max(indexes) + 1))()
      _lib.TCOD_color_gen_map(cres, len(colors), ccolors, cindexes)
      return cres
  
  ############################
  # console module
  ############################
  class Key(Structure):
      _fields_=[('vk', c_int),
                ('c', c_uint8),
                ('pressed', c_bool),
                ('lalt', c_bool),
                ('lctrl', c_bool),
                ('ralt', c_bool),
                ('rctrl', c_bool),
                ('shift', c_bool),
                ]
  
  class ConsoleBuffer:
      # simple console that allows direct (fast) access to cells. simplifies
      # use of the "fill" functions.
      def __init__(self, width, height, back_r=0, back_g=0, back_b=0, fore_r=0, fore_g=0, fore_b=0, char=' '):
          # initialize with given width and height. values to fill the buffer
          # are optional, defaults to black with no characters.
          n = width * height
          self.width = width
          self.height = height
          self.clear(back_r, back_g, back_b, fore_r, fore_g, fore_b, char)
  
      def clear(self, back_r=0, back_g=0, back_b=0, fore_r=0, fore_g=0, fore_b=0, char=' '):
          # clears the console. values to fill it with are optional, defaults
          # to black with no characters.
          n = self.width * self.height
          self.back_r = [back_r] * n
          self.back_g = [back_g] * n
          self.back_b = [back_b] * n
          self.fore_r = [fore_r] * n
          self.fore_g = [fore_g] * n
          self.fore_b = [fore_b] * n
          self.char = [ord(char)] * n
      
      def copy(self):
          # returns a copy of this ConsoleBuffer.
          other = ConsoleBuffer(0, 0)
          other.width = self.width
          other.height = self.height
          other.back_r = list(self.back_r)  # make explicit copies of all lists
          other.back_g = list(self.back_g)
          other.back_b = list(self.back_b)
          other.fore_r = list(self.fore_r)
          other.fore_g = list(self.fore_g)
          other.fore_b = list(self.fore_b)
          other.char = list(self.char)
          return other
      
      def set_fore(self, x, y, r, g, b, char):
          # set the character and foreground color of one cell.
          i = self.width * y + x
          self.fore_r[i] = r
          self.fore_g[i] = g
          self.fore_b[i] = b
          self.char[i] = ord(char)
      
      def set_back(self, x, y, r, g, b):
          # set the background color of one cell.
          i = self.width * y + x
          self.back_r[i] = r
          self.back_g[i] = g
          self.back_b[i] = b
      
      def set(self, x, y, back_r, back_g, back_b, fore_r, fore_g, fore_b, char):
          # set the background color, foreground color and character of one cell.
          i = self.width * y + x
          self.back_r[i] = back_r
          self.back_g[i] = back_g
          self.back_b[i] = back_b
          self.fore_r[i] = fore_r
          self.fore_g[i] = fore_g
          self.fore_b[i] = fore_b
          self.char[i] = ord(char)
      
      def blit(self, dest, fill_fore=True, fill_back=True):
          # use libtcod's "fill" functions to write the buffer to a console.
          if (console_get_width(dest) != self.width or
              console_get_height(dest) != self.height):
              raise ValueError('ConsoleBuffer.blit: Destination console has an incorrect size.')
  
          s = struct.Struct('%di' % len(self.back_r))
  
          if fill_back:
              _lib.TCOD_console_fill_background(dest, (c_int * len(self.back_r))(*self.back_r), (c_int * len(self.back_g))(*self.back_g), (c_int * len(self.back_b))(*self.back_b))
  
          if fill_fore:
              _lib.TCOD_console_fill_foreground(dest, (c_int * len(self.fore_r))(*self.fore_r), (c_int * len(self.fore_g))(*self.fore_g), (c_int * len(self.fore_b))(*self.fore_b))
              _lib.TCOD_console_fill_char(dest, (c_int * len(self.char))(*self.char))
  
  _lib.TCOD_console_credits_render.restype = c_bool
  _lib.TCOD_console_is_fullscreen.restype = c_bool
  _lib.TCOD_console_is_window_closed.restype = c_bool
  _lib.TCOD_console_has_mouse_focus.restype = c_bool
  _lib.TCOD_console_is_active.restype = c_bool
  _lib.TCOD_console_get_default_background.restype = Color
  _lib.TCOD_console_get_default_foreground.restype = Color
  _lib.TCOD_console_get_char_background.restype = Color
  _lib.TCOD_console_get_char_foreground.restype = Color
  _lib.TCOD_console_get_fading_color.restype = Color
  _lib.TCOD_console_is_key_pressed.restype = c_bool
  
  # background rendering modes
  BKGND_NONE = 0
  BKGND_SET = 1
  BKGND_MULTIPLY = 2
  BKGND_LIGHTEN = 3
  BKGND_DARKEN = 4
  BKGND_SCREEN = 5
  BKGND_COLOR_DODGE = 6
  BKGND_COLOR_BURN = 7
  BKGND_ADD = 8
  BKGND_ADDA = 9
  BKGND_BURN = 10
  BKGND_OVERLAY = 11
  BKGND_ALPH = 12
  BKGND_DEFAULT=13
  
  def BKGND_ALPHA(a):
      return BKGND_ALPH | (int(a * 255) << 8)
  
  def BKGND_ADDALPHA(a):
      return BKGND_ADDA | (int(a * 255) << 8)
  
  # non blocking key events types
  KEY_PRESSED = 1
  KEY_RELEASED = 2
  # key codes
  KEY_NONE = 0
  KEY_ESCAPE = 1
  KEY_BACKSPACE = 2
  KEY_TAB = 3
  KEY_ENTER = 4
  KEY_SHIFT = 5
  KEY_CONTROL = 6
  KEY_ALT = 7
  KEY_PAUSE = 8
  KEY_CAPSLOCK = 9
  KEY_PAGEUP = 10
  KEY_PAGEDOWN = 11
  KEY_END = 12
  KEY_HOME = 13
  KEY_UP = 14
  KEY_LEFT = 15
  KEY_RIGHT = 16
  KEY_DOWN = 17
  KEY_PRINTSCREEN = 18
  KEY_INSERT = 19
  KEY_DELETE = 20
  KEY_LWIN = 21
  KEY_RWIN = 22
  KEY_APPS = 23
  KEY_0 = 24
  KEY_1 = 25
  KEY_2 = 26
  KEY_3 = 27
  KEY_4 = 28
  KEY_5 = 29
  KEY_6 = 30
  KEY_7 = 31
  KEY_8 = 32
  KEY_9 = 33
  KEY_KP0 = 34
  KEY_KP1 = 35
  KEY_KP2 = 36
  KEY_KP3 = 37
  KEY_KP4 = 38
  KEY_KP5 = 39
  KEY_KP6 = 40
  KEY_KP7 = 41
  KEY_KP8 = 42
  KEY_KP9 = 43
  KEY_KPADD = 44
  KEY_KPSUB = 45
  KEY_KPDIV = 46
  KEY_KPMUL = 47
  KEY_KPDEC = 48
  KEY_KPENTER = 49
  KEY_F1 = 50
  KEY_F2 = 51
  KEY_F3 = 52
  KEY_F4 = 53
  KEY_F5 = 54
  KEY_F6 = 55
  KEY_F7 = 56
  KEY_F8 = 57
  KEY_F9 = 58
  KEY_F10 = 59
  KEY_F11 = 60
  KEY_F12 = 61
  KEY_NUMLOCK = 62
  KEY_SCROLLLOCK = 63
  KEY_SPACE = 64
  KEY_CHAR = 65
  # special chars
  # single walls
  CHAR_HLINE = 196
  CHAR_VLINE = 179
  CHAR_NE = 191
  CHAR_NW = 218
  CHAR_SE = 217
  CHAR_SW = 192
  CHAR_TEEW = 180
  CHAR_TEEE = 195
  CHAR_TEEN = 193
  CHAR_TEES = 194
  CHAR_CROSS = 197
  # double walls
  CHAR_DHLINE = 205
  CHAR_DVLINE = 186
  CHAR_DNE = 187
  CHAR_DNW = 201
  CHAR_DSE = 188
  CHAR_DSW = 200
  CHAR_DTEEW = 185
  CHAR_DTEEE = 204
  CHAR_DTEEN = 202
  CHAR_DTEES = 203
  CHAR_DCROSS = 206
  # blocks
  CHAR_BLOCK1 = 176
  CHAR_BLOCK2 = 177
  CHAR_BLOCK3 = 178
  # arrows
  CHAR_ARROW_N = 24
  CHAR_ARROW_S = 25
  CHAR_ARROW_E = 26
  CHAR_ARROW_W = 27
  # arrows without tail
  CHAR_ARROW2_N = 30
  CHAR_ARROW2_S = 31
  CHAR_ARROW2_E = 16
  CHAR_ARROW2_W = 17
  # double arrows
  CHAR_DARROW_H = 29
  CHAR_DARROW_V = 18
  # GUI stuff
  CHAR_CHECKBOX_UNSET = 224
  CHAR_CHECKBOX_SET = 225
  CHAR_RADIO_UNSET = 9
  CHAR_RADIO_SET = 10
  # sub-pixel resolution kit
  CHAR_SUBP_NW = 226
  CHAR_SUBP_NE = 227
  CHAR_SUBP_N = 228
  CHAR_SUBP_SE = 229
  CHAR_SUBP_DIAG = 230
  CHAR_SUBP_E = 231
  CHAR_SUBP_SW = 232
  # misc characters
  CHAR_BULLET = 7
  CHAR_BULLET_INV = 8
  CHAR_BULLET_SQUARE = 254
  CHAR_CENT = 189
  CHAR_CLUB = 5
  CHAR_COPYRIGHT = 184
  CHAR_CURRENCY = 207
  CHAR_DIAMOND = 4
  CHAR_DIVISION = 246
  CHAR_EXCLAM_DOUBLE = 19
  CHAR_FEMALE = 12
  CHAR_FUNCTION = 159
  CHAR_GRADE = 248
  CHAR_HALF = 171
  CHAR_HEART = 3
  CHAR_LIGHT = 15
  CHAR_MALE = 11
  CHAR_MULTIPLICATION = 158
  CHAR_NOTE = 13
  CHAR_NOTE_DOUBLE = 14
  CHAR_ONE_QUARTER = 172
  CHAR_PILCROW = 20
  CHAR_POUND = 156
  CHAR_POW1 = 251
  CHAR_POW2 = 253
  CHAR_POW3 = 252
  CHAR_RESERVED = 169
  CHAR_SECTION = 21
  CHAR_SMILIE = 1
  CHAR_SMILIE_INV = 2
  CHAR_SPADE = 6
  CHAR_THREE_QUARTERS = 243
  CHAR_UMLAUT = 249
  CHAR_YEN = 190
  # font flags
  FONT_LAYOUT_ASCII_INCOL = 1
  FONT_LAYOUT_ASCII_INROW = 2
  FONT_TYPE_GREYSCALE = 4
  FONT_TYPE_GRAYSCALE = 4
  FONT_LAYOUT_TCOD = 8
  # color control codes
  COLCTRL_1=1
  COLCTRL_2=2
  COLCTRL_3=3
  COLCTRL_4=4
  COLCTRL_5=5
  COLCTRL_NUMBER=5
  COLCTRL_FORE_RGB=6
  COLCTRL_BACK_RGB=7
  COLCTRL_STOP=8
  # renderers
  RENDERER_GLSL=0
  RENDERER_OPENGL=1
  RENDERER_SDL=2
  NB_RENDERERS=3
  # alignment
  LEFT=0
  RIGHT=1
  CENTER=2
  # initializing the console
  def console_init_root(w, h, title, fullscreen=False, renderer=RENDERER_SDL):
      _lib.TCOD_console_init_root(w, h, c_char_p(title), fullscreen, renderer)
  
  def console_get_width(con):
      return _lib.TCOD_console_get_width(con)
  
  def console_get_height(con):
      return _lib.TCOD_console_get_height(con)
  
  def console_set_custom_font(fontFile, flags=FONT_LAYOUT_ASCII_INCOL, nb_char_horiz=0, nb_char_vertic=0):
      _lib.TCOD_console_set_custom_font(c_char_p(fontFile), flags, nb_char_horiz, nb_char_vertic)
  
  def console_map_ascii_code_to_font(asciiCode, fontCharX, fontCharY):
      if type(asciiCode) == str or type(asciiCode) == bytes:
          _lib.TCOD_console_map_ascii_code_to_font(ord(asciiCode), fontCharX,
                                                   fontCharY)
      else:
          _lib.TCOD_console_map_ascii_code_to_font(asciiCode, fontCharX,
                                                   fontCharY)
  
  def console_map_ascii_codes_to_font(firstAsciiCode, nbCodes, fontCharX,
                                      fontCharY):
      if type(firstAsciiCode) == str or type(firstAsciiCode) == bytes:
          _lib.TCOD_console_map_ascii_codes_to_font(ord(firstAsciiCode), nbCodes,
                                                    fontCharX, fontCharY)
      else:
          _lib.TCOD_console_map_ascii_codes_to_font(firstAsciiCode, nbCodes,
                                                    fontCharX, fontCharY)
  
  def console_map_string_to_font(s, fontCharX, fontCharY):
      if type(s) == bytes:
          _lib.TCOD_console_map_string_to_font(s, fontCharX, fontCharY)
      else:
          _lib.TCOD_console_map_string_to_font_utf(s, fontCharX, fontCharY)
  
  def console_is_fullscreen():
      return _lib.TCOD_console_is_fullscreen()
  
  def console_set_fullscreen(fullscreen):
      _lib.TCOD_console_set_fullscreen(c_int(fullscreen))
  
  def console_is_window_closed():
      return _lib.TCOD_console_is_window_closed()
  
  def console_has_mouse_focus():
      return _lib.TCOD_console_has_mouse_focus()
  
  def console_is_active():
      return _lib.TCOD_console_is_active()
  
  def console_set_window_title(title):
      _lib.TCOD_console_set_window_title(c_char_p(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, c_int(alpha))
  
  def console_flush():
      _lib.TCOD_console_flush()
  
  # drawing on a console
  def console_set_default_background(con, col):
      _lib.TCOD_console_set_default_background(con, col)
  
  def console_set_default_foreground(con, col):
      _lib.TCOD_console_set_default_foreground(con, col)
  
  def console_clear(con):
      return _lib.TCOD_console_clear(con)
  
  def console_put_char(con, x, y, c, flag=BKGND_DEFAULT):
      if type(c) == str or type(c) == bytes:
          _lib.TCOD_console_put_char(con, x, y, ord(c), flag)
      else:
          _lib.TCOD_console_put_char(con, x, y, c, flag)
  
  def console_put_char_ex(con, x, y, c, fore, back):
      if type(c) == str or type(c) == bytes:
          _lib.TCOD_console_put_char_ex(con, x, y, ord(c), fore, back)
      else:
          _lib.TCOD_console_put_char_ex(con, x, y, c, fore, back)
  
  def console_set_char_background(con, x, y, col, flag=BKGND_SET):
      _lib.TCOD_console_set_char_background(con, x, y, col, flag)
  
  def console_set_char_foreground(con, x, y, col):
      _lib.TCOD_console_set_char_foreground(con, x, y, col)
  
  def console_set_char(con, x, y, c):
      if type(c) == str or type(c) == bytes:
          _lib.TCOD_console_set_char(con, x, y, ord(c))
      else:
          _lib.TCOD_console_set_char(con, x, y, c)
  
  def console_set_background_flag(con, flag):
      _lib.TCOD_console_set_background_flag(con, c_int(flag))
  
  def console_get_background_flag(con):
      return _lib.TCOD_console_get_background_flag(con)
  
  def console_set_alignment(con, alignment):
      _lib.TCOD_console_set_alignment(con, c_int(alignment))
  
  def console_get_alignment(con):
      return _lib.TCOD_console_get_alignment(con)
  
  def console_print(con, x, y, fmt):
      if type(fmt) == bytes:
          _lib.TCOD_console_print(c_void_p(con), x, y, c_char_p(fmt))
      else:
          _lib.TCOD_console_print_utf(c_void_p(con), x, y, fmt)
  
  def console_print_ex(con, x, y, flag, alignment, fmt):
      if type(fmt) == bytes:
          _lib.TCOD_console_print_ex(c_void_p(con), x, y, flag, alignment, c_char_p(fmt))
      else:
          _lib.TCOD_console_print_ex_utf(c_void_p(con), x, y, flag, alignment, fmt)
  
  def console_print_rect(con, x, y, w, h, fmt):
      if type(fmt) == bytes:
          return _lib.TCOD_console_print_rect(c_void_p(con), x, y, w, h, c_char_p(fmt))
      else:
          return _lib.TCOD_console_print_rect_utf(c_void_p(con), x, y, w, h, fmt)
  
  def console_print_rect_ex(con, x, y, w, h, flag, alignment, fmt):
      if type(fmt) == bytes:
          return _lib.TCOD_console_print_rect_ex(c_void_p(con), x, y, w, h, flag, alignment, c_char_p(fmt))
      else:
          return _lib.TCOD_console_print_rect_ex_utf(c_void_p(con), x, y, w, h, flag, alignment, fmt)
  
  def console_get_height_rect(con, x, y, w, h, fmt):
      if type(fmt) == bytes:
          return _lib.TCOD_console_get_height_rect(c_void_p(con), x, y, w, h, c_char_p(fmt))
      else:
          return _lib.TCOD_console_get_height_rect_utf(c_void_p(con), x, y, w, h, fmt)
  
  def console_rect(con, x, y, w, h, clr, flag=BKGND_DEFAULT):
      _lib.TCOD_console_rect(con, x, y, w, h, c_int(clr), flag)
  
  def console_hline(con, x, y, l, flag=BKGND_DEFAULT):
      _lib.TCOD_console_hline( con, x, y, l, flag)
  
  def console_vline(con, x, y, l, flag=BKGND_DEFAULT):
      _lib.TCOD_console_vline( con, x, y, l, flag)
  
  def console_print_frame(con, x, y, w, h, clear=True, flag=BKGND_DEFAULT, fmt=0):
      _lib.TCOD_console_print_frame(c_void_p(con), x, y, w, h, c_int(clear), flag, c_char_p(fmt))
  
  def console_set_color_control(con,fore,back) :
      _lib.TCOD_console_set_color_control(con,fore,back)
  
  def console_get_default_background(con):
      return _lib.TCOD_console_get_default_background(con)
  
  def console_get_default_foreground(con):
      return _lib.TCOD_console_get_default_foreground(con)
  
  def console_get_char_background(con, x, y):
      return _lib.TCOD_console_get_char_background(con, x, y)
  
  def console_get_char_foreground(con, x, y):
      return _lib.TCOD_console_get_char_foreground(con, x, y)
  
  def console_get_char(con, x, y):
      return _lib.TCOD_console_get_char(con, x, y)
  
  def console_set_fade(fade, fadingColor):
      _lib.TCOD_console_set_fade(fade, fadingColor)
      ##_lib.TCOD_console_set_fade_wrapper(fade, fadingColor)
  
  def console_get_fade():
      return _lib.TCOD_console_get_fade().value
  
  def console_get_fading_color():
      return _lib.TCOD_console_get_fading_color()
  
  # handling keyboard input
  def console_wait_for_keypress(flush):
      k=Key()
      _lib.TCOD_console_wait_for_keypress_wrapper(byref(k),c_bool(flush))
      return k
  
  def console_check_for_keypress(flags=KEY_RELEASED):
      k=Key()
      _lib.TCOD_console_check_for_keypress_wrapper(byref(k),c_int(flags))
      return k
  
  def console_is_key_pressed(key):
      return _lib.TCOD_console_is_key_pressed(key)
  
  def console_set_keyboard_repeat(initial_delay, interval):
      _lib.TCOD_console_set_keyboard_repeat(initial_delay, interval)
  
  def console_disable_keyboard_repeat():
      _lib.TCOD_console_disable_keyboard_repeat()
  
  # using offscreen consoles
  def console_new(w, h):
      return _lib.TCOD_console_new(w, h)
  def console_from_file(filename):
      return _lib.TCOD_console_from_file(filename)
  def console_get_width(con):
      return _lib.TCOD_console_get_width(con)
  
  def console_get_height(con):
      return _lib.TCOD_console_get_height(con)
  
  def console_blit(src, x, y, w, h, dst, xdst, ydst, ffade=1.0,bfade=1.0):
      _lib.TCOD_console_blit(src, x, y, w, h, dst, xdst, ydst, c_float(ffade), c_float(bfade))
  
  def console_set_key_color(con, col):
      _lib.TCOD_console_set_key_color(con, col)
  
  def console_delete(con):
      _lib.TCOD_console_delete(con)
  
  # fast color filling
  def console_fill_foreground(con,r,g,b) :
      if len(r) != len(g) or len(r) != len(b):
          raise TypeError('R, G and B must all have the same size.')
  
      if (numpy_available and isinstance(r, numpy.ndarray) and
          isinstance(g, numpy.ndarray) and isinstance(b, numpy.ndarray)):
          #numpy arrays, use numpy's ctypes functions
          r = numpy.ascontiguousarray(r, dtype=numpy.int32)
          g = numpy.ascontiguousarray(g, dtype=numpy.int32)
          b = numpy.ascontiguousarray(b, dtype=numpy.int32)
          cr = r.ctypes.data_as(POINTER(c_int))
          cg = g.ctypes.data_as(POINTER(c_int))
          cb = b.ctypes.data_as(POINTER(c_int))
      else:
          # otherwise convert using ctypes arrays
          cr = (c_int * len(r))(*r)
          cg = (c_int * len(g))(*g)
          cb = (c_int * len(b))(*b)
  
      _lib.TCOD_console_fill_foreground(con, cr, cg, cb)
  
  def console_fill_background(con,r,g,b) :
      if len(r) != len(g) or len(r) != len(b):
          raise TypeError('R, G and B must all have the same size.')
  
      if (numpy_available and isinstance(r, numpy.ndarray) and
          isinstance(g, numpy.ndarray) and isinstance(b, numpy.ndarray)):
          #numpy arrays, use numpy's ctypes functions
          r = numpy.ascontiguousarray(r, dtype=numpy.int32)
          g = numpy.ascontiguousarray(g, dtype=numpy.int32)
          b = numpy.ascontiguousarray(b, dtype=numpy.int32)
          cr = r.ctypes.data_as(POINTER(c_int))
          cg = g.ctypes.data_as(POINTER(c_int))
          cb = b.ctypes.data_as(POINTER(c_int))
      else:
          # otherwise convert using ctypes arrays
          cr = (c_int * len(r))(*r)
          cg = (c_int * len(g))(*g)
          cb = (c_int * len(b))(*b)
  
      _lib.TCOD_console_fill_background(con, cr, cg, cb)
  
  def console_fill_char(con,arr) :
      if (numpy_available and isinstance(arr, numpy.ndarray) ):
          #numpy arrays, use numpy's ctypes functions
          arr = numpy.ascontiguousarray(arr, dtype=numpy.int32)
          carr = arr.ctypes.data_as(POINTER(c_int))
      else:
          #otherwise convert using the struct module
          carr = struct.pack('%di' % len(arr), *arr)
  
      _lib.TCOD_console_fill_char(con, carr)
          
  def console_load_asc(con, filename) :
      _lib.TCOD_console_load_asc(con,filename)
  def console_save_asc(con, filename) :
      _lib.TCOD_console_save_asc(con,filename)
  def console_load_apf(con, filename) :
      _lib.TCOD_console_load_apf(con,filename)
  def console_save_apf(con, filename) :
      _lib.TCOD_console_save_apf(con,filename)
  
  ############################
  # sys module
  ############################
  _lib.TCOD_sys_get_last_frame_length.restype = c_float
  _lib.TCOD_sys_elapsed_seconds.restype = c_float
  
  # high precision time functions
  def sys_set_fps(fps):
      _lib.TCOD_sys_set_fps(fps)
  
  def sys_get_fps():
      return _lib.TCOD_sys_get_fps()
  
  def sys_get_last_frame_length():
      return _lib.TCOD_sys_get_last_frame_length()
  
  def sys_sleep_milli(val):
      _lib.TCOD_sys_sleep_milli(c_uint(val))
  
  def sys_elapsed_milli():
      return _lib.TCOD_sys_elapsed_milli()
  
  def sys_elapsed_seconds():
      return _lib.TCOD_sys_elapsed_seconds()
  
  def sys_set_renderer(renderer):
      _lib.TCOD_sys_set_renderer(renderer)
  
  def sys_get_renderer():
      return _lib.TCOD_sys_get_renderer()
  
  # easy screenshots
  def sys_save_screenshot(name=0):
      _lib.TCOD_sys_save_screenshot(c_char_p(name))
  
  # custom fullscreen resolution
  def sys_force_fullscreen_resolution(width, height):
      _lib.TCOD_sys_force_fullscreen_resolution(width, height)
  
  def sys_get_current_resolution():
      w = c_int()
      h = c_int()
      _lib.TCOD_sys_get_current_resolution(byref(w), byref(h))
      return w.value, h.value
  
  def sys_get_char_size():
      w = c_int()
      h = c_int()
      _lib.TCOD_sys_get_char_size(byref(w), byref(h))
      return w.value, h.value
  
  # update font bitmap
  def sys_update_char(asciiCode, fontx, fonty, img, x, y) :
      _lib.TCOD_sys_update_char(c_int(asciiCode),c_int(fontx),c_int(fonty),img,c_int(x),c_int(y))
  
  # custom SDL post renderer
  SDL_RENDERER_FUNC = CFUNCTYPE(None, c_void_p)
  def sys_register_SDL_renderer(callback):
      global sdl_renderer_func
      sdl_renderer_func = SDL_RENDERER_FUNC(callback)
      _lib.TCOD_sys_register_SDL_renderer(sdl_renderer_func)
  
  # events
  EVENT_NONE=0
  EVENT_KEY_PRESS=1
  EVENT_KEY_RELEASE=2
  EVENT_KEY=EVENT_KEY_PRESS|EVENT_KEY_RELEASE
  EVENT_MOUSE_MOVE=4
  EVENT_MOUSE_PRESS=8
  EVENT_MOUSE_RELEASE=16
  EVENT_MOUSE=EVENT_MOUSE_MOVE|EVENT_MOUSE_PRESS|EVENT_MOUSE_RELEASE
  EVENT_ANY=EVENT_KEY|EVENT_MOUSE
  def sys_check_for_event(mask,k,m) :
      return _lib.TCOD_sys_check_for_event(c_int(mask),byref(k),byref(m))
  
  def sys_wait_for_event(mask,k,m,flush) :
      return _lib.TCOD_sys_wait_for_event(c_int(mask),byref(k),byref(m),c_bool(flush))
  
  ############################
  # line module
  ############################
  _lib.TCOD_line_step.restype = c_bool
  _lib.TCOD_line.restype=c_bool
  _lib.TCOD_line_step_mt.restype = c_bool
  
  def line_init(xo, yo, xd, yd):
      _lib.TCOD_line_init(xo, yo, xd, yd)
  
  def line_step():
      x = c_int()
      y = c_int()
      ret = _lib.TCOD_line_step(byref(x), byref(y))
      if not ret:
          return x.value, y.value
      return None,None
  
  def line(xo,yo,xd,yd,py_callback) :
      LINE_CBK_FUNC=CFUNCTYPE(c_bool,c_int,c_int)
      c_callback=LINE_CBK_FUNC(py_callback)
      return _lib.TCOD_line(xo,yo,xd,yd,c_callback)
  
  def line_iter(xo, yo, xd, yd):
      data = (c_int * 9)()        # struct TCOD_bresenham_data_t
      _lib.TCOD_line_init_mt(xo, yo, xd, yd, data)
      x = c_int(xo)
      y = c_int(yo)
      done = False
      while not done:
          yield x.value, y.value
          done = _lib.TCOD_line_step_mt(byref(x), byref(y), data)
  
  ############################
  # image module
  ############################
  _lib.TCOD_image_is_pixel_transparent.restype = c_bool
  _lib.TCOD_image_get_pixel.restype = Color
  _lib.TCOD_image_get_mipmap_pixel.restype = Color
  
  def image_new(width, height):
      return _lib.TCOD_image_new(width, height)
  
  def image_clear(image,col) :
      _lib.TCOD_image_clear(image,col)
  
  def image_invert(image) :
      _lib.TCOD_image_invert(image)
  
  def image_hflip(image) :
      _lib.TCOD_image_hflip(image)
  
  def image_rotate90(image, num=1) :
      _lib.TCOD_image_rotate90(image,num)
  
  def image_vflip(image) :
      _lib.TCOD_image_vflip(image)
  
  def image_scale(image, neww, newh) :
      _lib.TCOD_image_scale(image,c_int(neww),c_int(newh))
  
  def image_set_key_color(image,col) :
      _lib.TCOD_image_set_key_color(image,col)
  
  def image_get_alpha(image,x,y) :
      return _lib.TCOD_image_get_alpha(image,c_int(x),c_int(y))
  
  def image_is_pixel_transparent(image,x,y) :
      return _lib.TCOD_image_is_pixel_transparent(image,c_int(x),c_int(y))
  
  def image_load(filename):
      return _lib.TCOD_image_load(c_char_p(filename))
  
  def image_from_console(console):
      return _lib.TCOD_image_from_console(console)
  
  def image_refresh_console(image, console):
      _lib.TCOD_image_refresh_console(image, console)
  
  def image_get_size(image):
      w=c_int()
      h=c_int()
      _lib.TCOD_image_get_size(image, byref(w), byref(h))
      return w.value, h.value
  
  def image_get_pixel(image, x, y):
      return _lib.TCOD_image_get_pixel(image, x, y)
  
  def image_get_mipmap_pixel(image, x0, y0, x1, y1):
      return _lib.TCOD_image_get_mipmap_pixel(image, c_float(x0), c_float(y0),
                                              c_float(x1), c_float(y1))
  def image_put_pixel(image, x, y, col):
      _lib.TCOD_image_put_pixel(image, x, y, col)
      ##_lib.TCOD_image_put_pixel_wrapper(image, x, y, col)
  
  def image_blit(image, console, x, y, bkgnd_flag, scalex, scaley, angle):
      _lib.TCOD_image_blit(image, console, c_float(x), c_float(y), bkgnd_flag,
                           c_float(scalex), c_float(scaley), c_float(angle))
  
  def image_blit_rect(image, console, x, y, w, h, bkgnd_flag):
      _lib.TCOD_image_blit_rect(image, console, x, y, w, h, bkgnd_flag)
  
  def image_blit_2x(image, console, dx, dy, sx=0, sy=0, w=-1, h=-1):
      _lib.TCOD_image_blit_2x(image, console, dx,dy,sx,sy,w,h)
  
  def image_save(image, filename):
      _lib.TCOD_image_save(image, c_char_p(filename))
  
  def image_delete(image):
      _lib.TCOD_image_delete(image)
  
  ############################
  # mouse module
  ############################
  class Mouse(Structure):
      _fields_=[('x', c_int),
                ('y', c_int),
                ('dx', c_int),
                ('dy', c_int),
                ('cx', c_int),
                ('cy', c_int),
                ('dcx', c_int),
                ('dcy', c_int),
                ('lbutton', c_bool),
                ('rbutton', c_bool),
                ('mbutton', c_bool),
                ('lbutton_pressed', c_bool),
                ('rbutton_pressed', c_bool),
                ('mbutton_pressed', c_bool),
                ('wheel_up', c_bool),
                ('wheel_down', c_bool),
                ]
  
  _lib.TCOD_mouse_is_cursor_visible.restype = c_bool
  
  def mouse_show_cursor(visible):
      _lib.TCOD_mouse_show_cursor(c_int(visible))
  
  def mouse_is_cursor_visible():
      return _lib.TCOD_mouse_is_cursor_visible()
  
  def mouse_move(x, y):
      _lib.TCOD_mouse_move(x, y)
  
  def mouse_get_status():
      mouse=Mouse()
      _lib.TCOD_mouse_get_status_wrapper(byref(mouse))
      return mouse
  
  ############################
  # parser module
  ############################
  _lib.TCOD_struct_get_name.restype = c_char_p
  _lib.TCOD_struct_is_mandatory.restype = c_bool
  _lib.TCOD_parser_has_property.restype = c_bool
  _lib.TCOD_parser_get_bool_property.restype = c_bool
  _lib.TCOD_parser_get_float_property.restype = c_float
  _lib.TCOD_parser_get_string_property.restype = c_char_p
  _lib.TCOD_parser_get_color_property.restype = Color
  
  class Dice(Structure):
      _fields_=[('nb_dices', c_int),
                ('nb_faces', c_int),
                ('multiplier', c_float),
                ('addsub', c_float),
                ]
  
      def __repr__(self):
          return "Dice(%d, %d, %s, %s)" % (self.nb_dices, self.nb_faces,
                                        self.multiplier, self.addsub)
  
  class _CValue(Union):
      _fields_=[('c',c_uint8),
                ('i',c_int),
                ('f',c_float),
                ('s',c_char_p),
                # JBR03192012 See http://bugs.python.org/issue14354 for why these are not defined as their actual types
                ('col',c_uint8 * 3),
                ('dice',c_int * 4),
                ('custom',c_void_p),
                ]
  
  _CFUNC_NEW_STRUCT = CFUNCTYPE(c_uint, c_void_p, c_char_p)
  _CFUNC_NEW_FLAG = CFUNCTYPE(c_uint, c_char_p)
  _CFUNC_NEW_PROPERTY = CFUNCTYPE(c_uint, c_char_p, c_int, _CValue)
  
  class _CParserListener(Structure):
      _fields_=[('new_struct', _CFUNC_NEW_STRUCT),
                ('new_flag',_CFUNC_NEW_FLAG),
                ('new_property',_CFUNC_NEW_PROPERTY),
                ('end_struct',_CFUNC_NEW_STRUCT),
                ('error',_CFUNC_NEW_FLAG),
                ]
  
  # property types
  TYPE_NONE = 0
  TYPE_BOOL = 1
  TYPE_CHAR = 2
  TYPE_INT = 3
  TYPE_FLOAT = 4
  TYPE_STRING = 5
  TYPE_COLOR = 6
  TYPE_DICE = 7
  TYPE_VALUELIST00 = 8
  TYPE_VALUELIST01 = 9
  TYPE_VALUELIST02 = 10
  TYPE_VALUELIST03 = 11
  TYPE_VALUELIST04 = 12
  TYPE_VALUELIST05 = 13
  TYPE_VALUELIST06 = 14
  TYPE_VALUELIST07 = 15
  TYPE_VALUELIST08 = 16
  TYPE_VALUELIST09 = 17
  TYPE_VALUELIST10 = 18
  TYPE_VALUELIST11 = 19
  TYPE_VALUELIST12 = 20
  TYPE_VALUELIST13 = 21
  TYPE_VALUELIST14 = 22
  TYPE_VALUELIST15 = 23
  TYPE_LIST = 1024
  
  def _convert_TCODList(clist, typ):
      res = list()
      for i in range(_lib.TCOD_list_size(clist)):
          elt = _lib.TCOD_list_get(clist, i)
          elt = cast(elt, c_void_p)
          if typ == TYPE_BOOL:
              elt = c_bool.from_buffer(elt).value
          elif typ == TYPE_CHAR:
              elt = c_char.from_buffer(elt).value
          elif typ == TYPE_INT:
              elt = c_int.from_buffer(elt).value
          elif typ == TYPE_FLOAT:
              elt = c_float.from_buffer(elt).value
          elif typ == TYPE_STRING or TYPE_VALUELIST15 >= typ >= TYPE_VALUELIST00:
              elt = cast(elt, c_char_p).value
          elif typ == TYPE_COLOR:
              elt = Color.from_buffer_copy(elt)
          elif typ == TYPE_DICE:
              # doesn't work
              elt = Dice.from_buffer_copy(elt)
          res.append(elt)
      return res
  
  def parser_new():
      return _lib.TCOD_parser_new()
  
  def parser_new_struct(parser, name):
      return _lib.TCOD_parser_new_struct(parser, name)
  
  def struct_add_flag(struct, name):
      _lib.TCOD_struct_add_flag(struct, name)
  
  def struct_add_property(struct, name, typ, mandatory):
      _lib.TCOD_struct_add_property(struct, name, typ, c_bool(mandatory))
  
  def struct_add_value_list(struct, name, value_list, mandatory):
      CARRAY = c_char_p * (len(value_list) + 1)
      cvalue_list = CARRAY()
      for i in range(len(value_list)):
          cvalue_list[i] = cast(value_list[i], c_char_p)
      cvalue_list[len(value_list)] = 0
      _lib.TCOD_struct_add_value_list(struct, name, cvalue_list, c_bool(mandatory))
  
  def struct_add_list_property(struct, name, typ, mandatory):
      _lib.TCOD_struct_add_list_property(struct, name, typ, c_bool(mandatory))
  
  def struct_add_structure(struct, sub_struct):
      _lib.TCOD_struct_add_structure(struct, sub_struct)
  
  def struct_get_name(struct):
      return _lib.TCOD_struct_get_name(struct)
  
  def struct_is_mandatory(struct, name):
      return _lib.TCOD_struct_is_mandatory(struct, name)
  
  def struct_get_type(struct, name):
      return _lib.TCOD_struct_get_type(struct, name)
  
  def parser_run(parser, filename, listener=0):
      if listener != 0:
          clistener=_CParserListener()
          def value_converter(name, typ, value):
              if typ == TYPE_BOOL:
                  return listener.new_property(name, typ, value.c == 1)
              elif typ == TYPE_CHAR:
                  return listener.new_property(name, typ, '%c' % (value.c & 0xFF))
              elif typ == TYPE_INT:
                  return listener.new_property(name, typ, value.i)
              elif typ == TYPE_FLOAT:
                  return listener.new_property(name, typ, value.f)
              elif typ == TYPE_STRING or \
                   TYPE_VALUELIST15 >= typ >= TYPE_VALUELIST00:
                   return listener.new_property(name, typ, value.s)
              elif typ == TYPE_COLOR:
                  col = cast(value.col, POINTER(Color)).contents
                  return listener.new_property(name, typ, col)
              elif typ == TYPE_DICE:
                  dice = cast(value.dice, POINTER(Dice)).contents
                  return listener.new_property(name, typ, dice)
              elif typ & TYPE_LIST:
                  return listener.new_property(name, typ,
                                          _convert_TCODList(value.custom, typ & 0xFF))
              return True
          clistener.new_struct = _CFUNC_NEW_STRUCT(listener.new_struct)
          clistener.new_flag = _CFUNC_NEW_FLAG(listener.new_flag)
          clistener.new_property = _CFUNC_NEW_PROPERTY(value_converter)
          clistener.end_struct = _CFUNC_NEW_STRUCT(listener.end_struct)
          clistener.error = _CFUNC_NEW_FLAG(listener.error)
          _lib.TCOD_parser_run(parser, c_char_p(filename), byref(clistener))
      else:
          _lib.TCOD_parser_run(parser, c_char_p(filename), 0)
  
  def parser_delete(parser):
      _lib.TCOD_parser_delete(parser)
  
  def parser_has_property(parser, name):
      return _lib.TCOD_parser_has_property(parser, c_char_p(name))
  
  def parser_get_bool_property(parser, name):
      return _lib.TCOD_parser_get_bool_property(parser, c_char_p(name))
  
  def parser_get_int_property(parser, name):
      return _lib.TCOD_parser_get_int_property(parser, c_char_p(name))
  
  def parser_get_char_property(parser, name):
      return '%c' % _lib.TCOD_parser_get_char_property(parser, c_char_p(name))
  
  def parser_get_float_property(parser, name):
      return _lib.TCOD_parser_get_float_property(parser, c_char_p(name))
  
  def parser_get_string_property(parser, name):
      return _lib.TCOD_parser_get_string_property(parser, c_char_p(name))
  
  def parser_get_color_property(parser, name):
      return _lib.TCOD_parser_get_color_property(parser, c_char_p(name))
  
  def parser_get_dice_property(parser, name):
      d = Dice()
      _lib.TCOD_parser_get_dice_property_py(c_void_p(parser), c_char_p(name), byref(d))
      return d
  
  def parser_get_list_property(parser, name, typ):
      clist = _lib.TCOD_parser_get_list_property(parser, c_char_p(name), c_int(typ))
      return _convert_TCODList(clist, typ)
  
  ############################
  # random module
  ############################
  _lib.TCOD_random_get_float.restype = c_float
  _lib.TCOD_random_get_double.restype = c_double
  
  RNG_MT = 0
  RNG_CMWC = 1
  
  DISTRIBUTION_LINEAR = 0
  DISTRIBUTION_GAUSSIAN = 1
  DISTRIBUTION_GAUSSIAN_RANGE = 2
  DISTRIBUTION_GAUSSIAN_INVERSE = 3
  DISTRIBUTION_GAUSSIAN_RANGE_INVERSE = 4
  
  def random_get_instance():
      return _lib.TCOD_random_get_instance()
  
  def random_new(algo=RNG_CMWC):
      return _lib.TCOD_random_new(algo)
  
  def random_new_from_seed(seed, algo=RNG_CMWC):
      return _lib.TCOD_random_new_from_seed(algo,c_uint(seed))
  
  def random_set_distribution(rnd, dist) :
  	_lib.TCOD_random_set_distribution(rnd, dist)
  
  def random_get_int(rnd, mi, ma):
      return _lib.TCOD_random_get_int(rnd, mi, ma)
  
  def random_get_float(rnd, mi, ma):
      return _lib.TCOD_random_get_float(rnd, c_float(mi), c_float(ma))
  
  def random_get_double(rnd, mi, ma):
      return _lib.TCOD_random_get_double(rnd, c_double(mi), c_double(ma))
  
  def random_get_int_mean(rnd, mi, ma, mean):
      return _lib.TCOD_random_get_int_mean(rnd, mi, ma, mean)
  
  def random_get_float_mean(rnd, mi, ma, mean):
      return _lib.TCOD_random_get_float_mean(rnd, c_float(mi), c_float(ma), c_float(mean))
  
  def random_get_double_mean(rnd, mi, ma, mean):
      return _lib.TCOD_random_get_double_mean(rnd, c_double(mi), c_double(ma), c_double(mean))
  
  def random_save(rnd):
      return _lib.TCOD_random_save(rnd)
  
  def random_restore(rnd, backup):
      _lib.TCOD_random_restore(rnd, backup)
  
  def random_delete(rnd):
      _lib.TCOD_random_delete(rnd)
  
  ############################
  # noise module
  ############################
  _lib.TCOD_noise_get.restype = c_float
  _lib.TCOD_noise_get_ex.restype = c_float
  _lib.TCOD_noise_get_fbm.restype = c_float
  _lib.TCOD_noise_get_fbm_ex.restype = c_float
  _lib.TCOD_noise_get_turbulence.restype = c_float
  _lib.TCOD_noise_get_turbulence_ex.restype = c_float
  
  NOISE_DEFAULT_HURST = 0.5
  NOISE_DEFAULT_LACUNARITY = 2.0
  
  NOISE_DEFAULT = 0
  NOISE_PERLIN = 1
  NOISE_SIMPLEX = 2
  NOISE_WAVELET = 4
  
  _NOISE_PACKER_FUNC = (None,
                        (c_float * 1),
                        (c_float * 2),
                        (c_float * 3),
                        (c_float * 4),
                        )
  
  def noise_new(dim, h=NOISE_DEFAULT_HURST, l=NOISE_DEFAULT_LACUNARITY, random=0):
      return _lib.TCOD_noise_new(dim, c_float(h), c_float(l), random)
  
  def noise_set_type(n, typ) :
      _lib.TCOD_noise_set_type(n,typ)
  
  def noise_get(n, f, typ=NOISE_DEFAULT):
      return _lib.TCOD_noise_get_ex(n, _NOISE_PACKER_FUNC[len(f)](*f), typ)
  
  def noise_get_fbm(n, f, oc, typ=NOISE_DEFAULT):
      return _lib.TCOD_noise_get_fbm_ex(n, _NOISE_PACKER_FUNC[len(f)](*f), c_float(oc), typ)
  
  def noise_get_turbulence(n, f, oc, typ=NOISE_DEFAULT):
      return _lib.TCOD_noise_get_turbulence_ex(n, _NOISE_PACKER_FUNC[len(f)](*f), c_float(oc), typ)
  
  def noise_delete(n):
      _lib.TCOD_noise_delete(n)
  
  ############################
  # fov module
  ############################
  _lib.TCOD_map_is_in_fov.restype = c_bool
  _lib.TCOD_map_is_transparent.restype = c_bool
  _lib.TCOD_map_is_walkable.restype = c_bool
  
  FOV_BASIC = 0
  FOV_DIAMOND = 1
  FOV_SHADOW = 2
  FOV_PERMISSIVE_0 = 3
  FOV_PERMISSIVE_1 = 4
  FOV_PERMISSIVE_2 = 5
  FOV_PERMISSIVE_3 = 6
  FOV_PERMISSIVE_4 = 7
  FOV_PERMISSIVE_5 = 8
  FOV_PERMISSIVE_6 = 9
  FOV_PERMISSIVE_7 = 10
  FOV_PERMISSIVE_8 = 11
  FOV_RESTRICTIVE = 12
  NB_FOV_ALGORITHMS = 13
  
  def FOV_PERMISSIVE(p) :
      return FOV_PERMISSIVE_0+p
  
  def map_new(w, h):
      return _lib.TCOD_map_new(w, h)
  
  def map_copy(source, dest):
      return _lib.TCOD_map_copy(source, dest)
  
  def map_set_properties(m, x, y, isTrans, isWalk):
      _lib.TCOD_map_set_properties(m, x, y, c_int(isTrans), c_int(isWalk))
  
  def map_clear(m,walkable=False,transparent=False):
      _lib.TCOD_map_clear(m,c_int(walkable),c_int(transparent))
  
  def map_compute_fov(m, x, y, radius=0, light_walls=True, algo=FOV_RESTRICTIVE ):
      _lib.TCOD_map_compute_fov(m, x, y, c_int(radius), c_bool(light_walls), c_int(algo))
  
  def map_is_in_fov(m, x, y):
      return _lib.TCOD_map_is_in_fov(m, x, y)
  
  def map_is_transparent(m, x, y):
      return _lib.TCOD_map_is_transparent(m, x, y)
  
  def map_is_walkable(m, x, y):
      return _lib.TCOD_map_is_walkable(m, x, y)
  
  def map_delete(m):
      return _lib.TCOD_map_delete(m)
  
  def map_get_width(map):
      return _lib.TCOD_map_get_width(map)
  
  def map_get_height(map):
      return _lib.TCOD_map_get_height(map)
  
  ############################
  # pathfinding module
  ############################
  _lib.TCOD_path_compute.restype = c_bool
  _lib.TCOD_path_is_empty.restype = c_bool
  _lib.TCOD_path_walk.restype = c_bool
  
  PATH_CBK_FUNC = CFUNCTYPE(c_float, c_int, c_int, c_int, c_int, py_object)
  
  def path_new_using_map(m, dcost=1.41):
      return (_lib.TCOD_path_new_using_map(c_void_p(m), c_float(dcost)), None)
  
  def path_new_using_function(w, h, func, userdata=0, dcost=1.41):
      cbk_func = PATH_CBK_FUNC(func)
      return (_lib.TCOD_path_new_using_function(w, h, cbk_func,
              py_object(userdata), c_float(dcost)), cbk_func)
  
  def path_compute(p, ox, oy, dx, dy):
      return _lib.TCOD_path_compute(p[0], ox, oy, dx, dy)
  
  def path_get_origin(p):
      x = c_int()
      y = c_int()
      _lib.TCOD_path_get_origin(p[0], byref(x), byref(y))
      return x.value, y.value
  
  def path_get_destination(p):
      x = c_int()
      y = c_int()
      _lib.TCOD_path_get_destination(p[0], byref(x), byref(y))
      return x.value, y.value
  
  def path_size(p):
      return _lib.TCOD_path_size(p[0])
  
  def path_reverse(p):
      _lib.TCOD_path_reverse(p[0])  
  
  def path_get(p, idx):
      x = c_int()
      y = c_int()
      _lib.TCOD_path_get(p[0], idx, byref(x), byref(y))
      return x.value, y.value
  
  def path_is_empty(p):
      return _lib.TCOD_path_is_empty(p[0])
  
  def path_walk(p, recompute):
      x = c_int()
      y = c_int()
      if _lib.TCOD_path_walk(p[0], byref(x), byref(y), c_int(recompute)):
          return x.value, y.value
      return None,None
  
  def path_delete(p):
      _lib.TCOD_path_delete(p[0])
  
  _lib.TCOD_dijkstra_path_set.restype = c_bool
  _lib.TCOD_dijkstra_is_empty.restype = c_bool
  _lib.TCOD_dijkstra_path_walk.restype = c_bool
  _lib.TCOD_dijkstra_get_distance.restype = c_float
  
  def dijkstra_new(m, dcost=1.41):
      return (_lib.TCOD_dijkstra_new(c_void_p(m), c_float(dcost)), None)
  
  def dijkstra_new_using_function(w, h, func, userdata=0, dcost=1.41):
      cbk_func = PATH_CBK_FUNC(func)
      return (_lib.TCOD_path_dijkstra_using_function(w, h, cbk_func,
              py_object(userdata), c_float(dcost)), cbk_func)
  
  def dijkstra_compute(p, ox, oy):
      _lib.TCOD_dijkstra_compute(p[0], c_int(ox), c_int(oy))
  
  def dijkstra_path_set(p, x, y):
      return _lib.TCOD_dijkstra_path_set(p[0], c_int(x), c_int(y))
  
  def dijkstra_get_distance(p, x, y):
      return _lib.TCOD_dijkstra_get_distance(p[0], c_int(x), c_int(y))
  
  def dijkstra_size(p):
      return _lib.TCOD_dijkstra_size(p[0])
  
  def dijkstra_reverse(p):
      _lib.TCOD_dijkstra_reverse(p[0])
  
  def dijkstra_get(p, idx):
      x = c_int()
      y = c_int()
      _lib.TCOD_dijkstra_get(p[0], c_int(idx), byref(x), byref(y))
      return x.value, y.value
  
  def dijkstra_is_empty(p):
      return _lib.TCOD_dijkstra_is_empty(p[0])
  
  def dijkstra_path_walk(p):
      x = c_int()
      y = c_int()
      if _lib.TCOD_dijkstra_path_walk(p[0], byref(x), byref(y)):
          return x.value, y.value
      return None,None
  
  def dijkstra_delete(p):
      _lib.TCOD_dijkstra_delete(p[0])
  
  ############################
  # bsp module
  ############################
  class _CBsp(Structure):
      _fields_ = [('next', c_void_p),
                  ('father', c_void_p),
                  ('son', c_void_p),
                  ('x', c_int),
                  ('y', c_int),
                  ('w', c_int),
                  ('h', c_int),
                  ('position', c_int),
                  ('level', c_uint8),
                  ('horizontal', c_bool),
                  ]
  
  _lib.TCOD_bsp_new_with_size.restype = POINTER(_CBsp)
  _lib.TCOD_bsp_left.restype = POINTER(_CBsp)
  _lib.TCOD_bsp_right.restype = POINTER(_CBsp)
  _lib.TCOD_bsp_father.restype = POINTER(_CBsp)
  _lib.TCOD_bsp_is_leaf.restype = c_bool
  _lib.TCOD_bsp_contains.restype = c_bool
  _lib.TCOD_bsp_find_node.restype = POINTER(_CBsp)
  
  BSP_CBK_FUNC = CFUNCTYPE(c_int, c_void_p, c_void_p)
  
  # python class encapsulating the _CBsp pointer
  class Bsp(object):
      def __init__(self, cnode):
          pcbsp = cast(cnode, POINTER(_CBsp))
          self.p = pcbsp
  
      def getx(self):
          return self.p.contents.x
      def setx(self, value):
          self.p.contents.x = value
      x = property(getx, setx)
  
      def gety(self):
          return self.p.contents.y
      def sety(self, value):
          self.p.contents.y = value
      y = property(gety, sety)
  
      def getw(self):
          return self.p.contents.w
      def setw(self, value):
          self.p.contents.w = value
      w = property(getw, setw)
  
      def geth(self):
          return self.p.contents.h
      def seth(self, value):
          self.p.contents.h = value
      h = property(geth, seth)
  
      def getpos(self):
          return self.p.contents.position
      def setpos(self, value):
          self.p.contents.position = value
      position = property(getpos, setpos)
  
      def gethor(self):
          return self.p.contents.horizontal
      def sethor(self,value):
          self.p.contents.horizontal = value
      horizontal = property(gethor, sethor)
  
      def getlev(self):
          return self.p.contents.level
      def setlev(self,value):
          self.p.contents.level = value
      level = property(getlev, setlev)
  
  
  def bsp_new_with_size(x, y, w, h):
      return Bsp(_lib.TCOD_bsp_new_with_size(x, y, w, h))
  
  def bsp_split_once(node, horizontal, position):
      _lib.TCOD_bsp_split_once(node.p, c_int(horizontal), position)
  
  def bsp_split_recursive(node, randomizer, nb, minHSize, minVSize, maxHRatio,
                          maxVRatio):
      _lib.TCOD_bsp_split_recursive(node.p, randomizer, nb, minHSize, minVSize,
                                    c_float(maxHRatio), c_float(maxVRatio))
  
  def bsp_resize(node, x, y, w, h):
      _lib.TCOD_bsp_resize(node.p, x, y, w, h)
  
  def bsp_left(node):
      return Bsp(_lib.TCOD_bsp_left(node.p))
  
  def bsp_right(node):
      return Bsp(_lib.TCOD_bsp_right(node.p))
  
  def bsp_father(node):
      return Bsp(_lib.TCOD_bsp_father(node.p))
  
  def bsp_is_leaf(node):
      return _lib.TCOD_bsp_is_leaf(node.p)
  
  def bsp_contains(node, cx, cy):
      return _lib.TCOD_bsp_contains(node.p, cx, cy)
  
  def bsp_find_node(node, cx, cy):
      return Bsp(_lib.TCOD_bsp_find_node(node.p, cx, cy))
  
  def _bsp_traverse(node, callback, userData, func):
      # convert the c node into a python node
      #before passing it to the actual callback
      def node_converter(cnode, data):
          node = Bsp(cnode)
          return callback(node, data)
      cbk_func = BSP_CBK_FUNC(node_converter)
      func(node.p, cbk_func, userData)
  
  def bsp_traverse_pre_order(node, callback, userData=0):
      _bsp_traverse(node, callback, userData, _lib.TCOD_bsp_traverse_pre_order)
  
  def bsp_traverse_in_order(node, callback, userData=0):
      _bsp_traverse(node, callback, userData, _lib.TCOD_bsp_traverse_in_order)
  
  def bsp_traverse_post_order(node, callback, userData=0):
      _bsp_traverse(node, callback, userData, _lib.TCOD_bsp_traverse_post_order)
  
  def bsp_traverse_level_order(node, callback, userData=0):
      _bsp_traverse(node, callback, userData, _lib.TCOD_bsp_traverse_level_order)
  
  def bsp_traverse_inverted_level_order(node, callback, userData=0):
      _bsp_traverse(node, callback, userData,
                    _lib.TCOD_bsp_traverse_inverted_level_order)
  
  def bsp_remove_sons(node):
      _lib.TCOD_bsp_remove_sons(node.p)
  
  def bsp_delete(node):
      _lib.TCOD_bsp_delete(node.p)
  
  ############################
  # heightmap module
  ############################
  class _CHeightMap(Structure):
      _fields_=[('w', c_int),
                ('h', c_int),
                ('values', POINTER(c_float)),
                ]
  
  _lib.TCOD_heightmap_new.restype = POINTER(_CHeightMap)
  _lib.TCOD_heightmap_get_value.restype = c_float
  _lib.TCOD_heightmap_has_land_on_border.restype = c_bool
  
  class HeightMap(object):
      def __init__(self, chm):
          pchm = cast(chm, POINTER(_CHeightMap))
          self.p = pchm
  
      def getw(self):
          return self.p.contents.w
      def setw(self, value):
          self.p.contents.w = value
      w = property(getw, setw)
  
      def geth(self):
          return self.p.contents.h
      def seth(self, value):
          self.p.contents.h = value
      h = property(geth, seth)
  
  def heightmap_new(w, h):
      phm = _lib.TCOD_heightmap_new(w, h)
      return HeightMap(phm)
  
  def heightmap_set_value(hm, x, y, value):
      _lib.TCOD_heightmap_set_value(hm.p, x, y, c_float(value))
  
  def heightmap_add(hm, value):
      _lib.TCOD_heightmap_add(hm.p, c_float(value))
  
  def heightmap_scale(hm, value):
      _lib.TCOD_heightmap_scale(hm.p, c_float(value))
  
  def heightmap_clear(hm):
      _lib.TCOD_heightmap_clear(hm.p)
  
  def heightmap_clamp(hm, mi, ma):
      _lib.TCOD_heightmap_clamp(hm.p, c_float(mi),c_float(ma))
  
  def heightmap_copy(hm1, hm2):
      _lib.TCOD_heightmap_copy(hm1.p, hm2.p)
  
  def heightmap_normalize(hm,  mi=0.0, ma=1.0):
      _lib.TCOD_heightmap_normalize(hm.p, c_float(mi), c_float(ma))
  
  def heightmap_lerp_hm(hm1, hm2, hm3, coef):
      _lib.TCOD_heightmap_lerp_hm(hm1.p, hm2.p, hm3.p, c_float(coef))
  
  def heightmap_add_hm(hm1, hm2, hm3):
      _lib.TCOD_heightmap_add_hm(hm1.p, hm2.p, hm3.p)
  
  def heightmap_multiply_hm(hm1, hm2, hm3):
      _lib.TCOD_heightmap_multiply_hm(hm1.p, hm2.p, hm3.p)
  
  def heightmap_add_hill(hm, x, y, radius, height):
      _lib.TCOD_heightmap_add_hill(hm.p, c_float( x), c_float( y),
                                   c_float( radius), c_float( height))
  
  def heightmap_dig_hill(hm, x, y, radius, height):
      _lib.TCOD_heightmap_dig_hill(hm.p, c_float( x), c_float( y),
                                   c_float( radius), c_float( height))
  
  def heightmap_mid_point_displacement(hm, rng, roughness):
      _lib.TCOD_heightmap_mid_point_displacement(hm.p, rng, c_float(roughness))
  
  def heightmap_rain_erosion(hm, nbDrops, erosionCoef, sedimentationCoef, rnd=0):
      _lib.TCOD_heightmap_rain_erosion(hm.p, nbDrops, c_float( erosionCoef),
                                       c_float( sedimentationCoef), rnd)
  
  def heightmap_kernel_transform(hm, kernelsize, dx, dy, weight, minLevel,
                                 maxLevel):
      FARRAY = c_float * kernelsize
      IARRAY = c_int * kernelsize
      cdx = IARRAY(*dx)
      cdy = IARRAY(*dy)
      cweight = FARRAY(*weight)
      _lib.TCOD_heightmap_kernel_transform(hm.p, kernelsize, cdx, cdy, cweight,
                                           c_float(minLevel), c_float(maxLevel))
  
  def heightmap_add_voronoi(hm, nbPoints, nbCoef, coef, rnd=0):
      FARRAY = c_float * nbCoef
      ccoef = FARRAY(*coef)
      _lib.TCOD_heightmap_add_voronoi(hm.p, nbPoints, nbCoef, ccoef, rnd)
  
  def heightmap_add_fbm(hm, noise, mulx, muly, addx, addy, octaves, delta, scale):
      _lib.TCOD_heightmap_add_fbm(hm.p, noise, c_float(mulx), c_float(muly),
                                  c_float(addx), c_float(addy),
                                  c_float(octaves), c_float(delta),
                                  c_float(scale))
  def heightmap_scale_fbm(hm, noise, mulx, muly, addx, addy, octaves, delta,
                          scale):
      _lib.TCOD_heightmap_scale_fbm(hm.p, noise, c_float(mulx), c_float(muly),
                                    c_float(addx), c_float(addy),
                                    c_float(octaves), c_float(delta),
                                    c_float(scale))
  def heightmap_dig_bezier(hm, px, py, startRadius, startDepth, endRadius,
                           endDepth):
      IARRAY = c_int * 4
      cpx = IARRAY(*px)
      cpy = IARRAY(*py)
      _lib.TCOD_heightmap_dig_bezier(hm.p, cpx, cpy, c_float(startRadius),
                                     c_float(startDepth), c_float(endRadius),
                                     c_float(endDepth))
  
  def heightmap_get_value(hm, x, y):
      return _lib.TCOD_heightmap_get_value(hm.p, x, y)
  
  def heightmap_get_interpolated_value(hm, x, y):
      return _lib.TCOD_heightmap_get_interpolated_value(hm.p, c_float(x),
                                                       c_float(y))
  
  def heightmap_get_slope(hm, x, y):
      return _lib.TCOD_heightmap_get_slope(hm.p, x, y)
  
  def heightmap_get_normal(hm, x, y, waterLevel):
      FARRAY = c_float * 3
      cn = FARRAY()
      _lib.TCOD_heightmap_get_normal(hm.p, c_float(x), c_float(y), cn,
                                     c_float(waterLevel))
      return cn[0], cn[1], cn[2]
  
  def heightmap_count_cells(hm, mi, ma):
      return _lib.TCOD_heightmap_count_cells(hm.p, c_float(mi), c_float(ma))
  
  def heightmap_has_land_on_border(hm, waterlevel):
      return _lib.TCOD_heightmap_has_land_on_border(hm.p, c_float(waterlevel))
  
  def heightmap_get_minmax(hm):
      mi = c_float()
      ma = c_float()
      _lib.TCOD_heightmap_get_minmax(hm.p, byref(mi), byref(ma))
      return mi.value, ma.value
  
  def heightmap_delete(hm):
      _lib.TCOD_heightmap_delete(hm.p)
  
  
  ############################
  # name generator module
  ############################
  _lib.TCOD_namegen_generate.restype = c_char_p
  _lib.TCOD_namegen_generate_custom.restype = c_char_p
  
  def namegen_parse(filename,random=0) :
      _lib.TCOD_namegen_parse(filename,random)
  
  def namegen_generate(name) :
      return _lib.TCOD_namegen_generate(name, 0)
  
  def namegen_generate_custom(name, rule) :
      return _lib.TCOD_namegen_generate(name, rule, 0)
  
  def namegen_get_sets():
      nb=_lib.TCOD_namegen_get_nb_sets_wrapper()
      SARRAY = c_char_p * nb;
      setsa = SARRAY()
      _lib.TCOD_namegen_get_sets_wrapper(setsa)
      return list(setsa)
  
  def namegen_destroy() :
      _lib.TCOD_namegen_destroy()
  
  
  