libtcod

Search:
Group by:

FOV_BASIC : http://roguebasin.roguelikedevelopment.org/index.php?title=Ray_casting

FOV_DIAMOND : http://www.geocities.com/temerra/los_rays.html

FOV_SHADOW : http://roguebasin.roguelikedevelopment.org/index.php?title=FOV_using_recursive_shadowcasting

FOV_PERMISSIVE : http://roguebasin.roguelikedevelopment.org/index.php?title=Precise_Permissive_Field_of_View

FOV_RESTRICTIVE : Mingos' Restrictive Precise Angle Shadowcasting (contribution by Mingos)

Types

TColor {...}{.bycopy.} = tuple[r, g, b: uint8]
TKeycode {...}{.size: 4.} = enum
  K_NONE, K_ESCAPE, K_BACKSPACE, K_TAB, K_ENTER, K_SHIFT, K_CONTROL, K_ALT, K_PAUSE,
  K_CAPSLOCK, K_PAGEUP, K_PAGEDOWN, K_END, K_HOME, K_UP, K_LEFT, K_RIGHT, K_DOWN,
  K_PRINTSCREEN, K_INSERT, K_DELETE, K_LWIN, K_RWIN, K_APPS, K_0, K_1, K_2, K_3, K_4, K_5,
  K_6, K_7, K_8, K_9, K_KP0, K_KP1, K_KP2, K_KP3, K_KP4, K_KP5, K_KP6, K_KP7, K_KP8, K_KP9,
  K_KPADD, K_KPSUB, K_KPDIV, K_KPMUL, K_KPDEC, K_KPENTER, K_F1, K_F2, K_F3, K_F4, K_F5,
  K_F6, K_F7, K_F8, K_F9, K_F10, K_F11, K_F12, K_NUMLOCK, K_SCROLLLOCK, K_SPACE, K_CHAR
TKey {...}{.bycopy.} = object
  vk*: TKeycode
  c*: char
  pressed*: bool
  lalt*: bool
  lctrl*: bool
  ralt*: bool
  rctrl*: bool
  shift*: bool
TColctrl {...}{.size: 4.} = enum
  COLCTRL_1 = 1, COLCTRL_2, COLCTRL_3, COLCTRL_4, COLCTRL_5, COLCTRL_FORE_RGB,
  COLCTRL_BACK_RGB, COLCTRL_STOP
TBkgndFlag = int
TRenderer {...}{.size: 4.} = enum
  RENDERER_GLSL, RENDERER_OPENGL, RENDERER_SDL, NB_RENDERERS
TAlignment {...}{.size: 4.} = enum
  LEFT, RIGHT, CENTER
PConsole = pointer
TMouse {...}{.bycopy.} = object
  x*, y*: cint                  ## absolute position
  dx*, dy*: cint                ## movement since last update in pixels
  cx*, cy*: cint                ## cell coordinates in the root console
  dcx*, dcy*: cint              ## movement since last update in console cells
  lbutton*: bool               ## left button status
  rbutton*: bool               ## right button status
  mbutton*: bool               ## middle button status
  lbutton_pressed*: bool
  rbutton_pressed*: bool
  mbutton_pressed*: bool
  wheel_up*: bool
  wheel_down*: bool
PImage = pointer
TEvent = cint
PThread = pointer
PSemaphore = pointer
PMutex = pointer
PCond = pointer
PCallback = proc (p: pointer): cint {...}{.cdecl.}
PLibrary = pointer
PSDLRenderer = proc (sdl_surface: pointer) {...}{.cdecl.}
TDice {...}{.bycopy.} = tuple[nb_rolls, nb_faces: cint, multiplier, addsub: cfloat]
TRandomAlgo {...}{.size: 4.} = enum
  RNG_MT, RNG_CMWC
TDistribution {...}{.size: 4.} = enum
  DISTRIBUTION_LINEAR, DISTRIBUTION_GAUSSIAN, DISTRIBUTION_GAUSSIAN_RANGE,
  DISTRIBUTION_GAUSSIAN_INVERSE, DISTRIBUTION_GAUSSIAN_RANGE_INVERSE
PRandom = pointer
PNoise = pointer
TNoiseType {...}{.size: 4.} = enum
  NOISE_DEFAULT = 0, NOISE_PERLIN = 1, NOISE_SIMPLEX = 2, NOISE_WAVELET = 4
PLineListener = proc (x, y: int): bool {...}{.cdecl.}
PBresenhamData = ptr TBresenhamData
TBresenhamData {...}{.bycopy.} = object
  stepx*: cint
  stepy*: cint
  e*: cint
  deltax*: cint
  deltay*: cint
  origx*: cint
  origy*: cint
  destx*: cint
  desty*: cint
PTree = ptr TTree
TTree {...}{.bycopy.} = object
  next*: PTree
  father*: PTree
  sons*: PTree
PBSP = ptr TBSP
TBSP {...}{.bycopy.} = object
  tree*: TTree
  x*, y*, w*, h*: cint
  position*: cint
  level*: uint8
  horizontal*: bool
PBSPCallback = proc (node: PBSP; userData: pointer): bool {...}{.cdecl.}
TFOVAlgorithm {...}{.size: 4.} = enum
  FOV_BASIC, FOV_DIAMOND, FOV_SHADOW, FOV_PERMISSIVE_0, FOV_PERMISSIVE_1,
  FOV_PERMISSIVE_2, FOV_PERMISSIVE_3, FOV_PERMISSIVE_4, FOV_PERMISSIVE_5,
  FOV_PERMISSIVE_6, FOV_PERMISSIVE_7, FOV_PERMISSIVE_8, FOV_RESTRICTIVE,
  NB_FOV_ALGORITHMS
PMap = pointer
PPathFunc = proc (xFrom, yFrom, xTo, yTo: int; user_data: pointer): cfloat {...}{.cdecl.}
PPath = pointer
PDijkstra = pointer
PHeightmap = ptr THeightmap
THeightmap {...}{.bycopy.} = object
  w, h: cint
  values: ptr cfloat
PLex = ptr TLex
TLex {...}{.bycopy.} = object
  file_line*, token_type*, token_int_val*, token_idx*: cint
  token_float_val*: cfloat
  tok*: cstring
  toklen*: cint
  lastStringDelim*: char
  pos*: cstring
  buf*: cstring
  filename*: cstring
  last_javadoc_comment*: cstring
  nb_symbols, nb_keywords, flags: cint
  symbols: array[0 .. 100 - 1, array[0 .. 5 - 1, char]]
  keywords: array[0 .. 100 - 1, array[0 .. 20 - 1, char]]
  simpleCmt: cstring
  cmtStart, cmtStop, javadocCmtStart: cstring
  stringDelim: cstring
  javadoc_read: bool
  allocBuf: bool
  savept: bool
TValueType = range[0 .. 32000]
TValue = object
  case kind*: TValueType
  of TYPE_BOOL:
    b*: bool
  of TYPE_CHAR:
    c*: char
  of TYPE_INT:
    i*: cint
  of TYPE_FLOAT:
    f*: cfloat
  of TYPE_STRING, TYPE_VALUELIST00 .. TYPE_VALUELIST15:
    s*: string
  of TYPE_COLOR:
    col*: TColor
  of TYPE_DICE:
    dice*: TDice
  of TYPE_CUSTOM00 .. TYPE_CUSTOM15:
    custom*: pointer
  of TYPE_LIST .. MAX_TYPE:
    list*: seq[TValue]
  else:
    nil
  
PParserListener = ref TParserListener
TParserListener = object
  new_struct*: proc (str: PParserStruct; name: string): bool {...}{.cdecl.}
  new_flag*: proc (name: string): bool {...}{.cdecl.}
  new_property*: proc (propname: string; value_type: TValueType; value: TValue): bool {...}{.
      cdecl.}
  end_struct*: proc (str: PParserStruct; name: string): bool {...}{.cdecl.}
  error*: proc (msg: string) {...}{.cdecl.}
PParserStruct = ref TParserStruct
TParserStruct = object
  name: string
  flags: seq[string]
  props: seq[TStructProp]
  lists: seq[seq[string]]
  structs: seq[PParserStruct]
PParser = ref TParser
TParser = object
  structs: seq[PParserStruct]
  customs: array[0 .. 15, PParserCustom]
  fatal: bool
  props: seq[TProp]
PParserCustom = proc (lex: PLex; listener: PParserListener; str: PParserStruct;
                   propname: string): TValue {...}{.cdecl.}
PZip = pointer
PText = pointer

Consts

NO_UNICODE = false
disable unicode support
NO_OPENGL = false
disable opengl support
LIB_NAME = "libtcod.so.1.5.1"
HEXVERSION = 0x00010501
STRVERSION = "1.5.1"
TECHVERSION = 0x01050103
WRAPPERVERSION = "0.98.1"
COLOR_RED = 0
COLOR_FLAME = 1
COLOR_ORANGE = 2
COLOR_AMBER = 3
COLOR_YELLOW = 4
COLOR_LIME = 5
COLOR_CHARTREUSE = 6
COLOR_GREEN = 7
COLOR_SEA = 8
COLOR_TURQUOISE = 9
COLOR_CYAN = 10
COLOR_SKY = 11
COLOR_AZURE = 12
COLOR_BLUE = 13
COLOR_HAN = 14
COLOR_VIOLET = 15
COLOR_PURPLE = 16
COLOR_FUCHSIA = 17
COLOR_MAGENTA = 18
COLOR_PINK = 19
COLOR_CRIMSON = 20
COLOR_NB = 21
COLOR_NB_HIGH = 20
COLOR_DESATURATED = 0
COLOR_LIGHTEST = 1
COLOR_LIGHTER = 2
COLOR_LIGHT = 3
COLOR_NORMAL = 4
COLOR_DARK = 5
COLOR_DARKER = 6
COLOR_DARKEST = 7
COLOR_LEVELS = 8
COLOR_LEVELS_HIGH = 7
BLACK = (0'u8, 0'u8, 0'u8)
DARKEST_GREY = (31'u8, 31'u8, 31'u8)
DARKER_GREY = (63'u8, 63'u8, 63'u8)
DARK_GREY = (95'u8, 95'u8, 95'u8)
GREY = (127'u8, 127'u8, 127'u8)
LIGHT_GREY = (159'u8, 159'u8, 159'u8)
LIGHTER_GREY = (191'u8, 191'u8, 191'u8)
LIGHTEST_GREY = (223'u8, 223'u8, 223'u8)
WHITE: TColor = (255'u8, 255'u8, 255'u8)
DARKEST_SEPIA = (31'u8, 24'u8, 15'u8)
DARKER_SEPIA = (63'u8, 50'u8, 31'u8)
DARK_SEPIA = (94'u8, 75'u8, 47'u8)
SEPIA = (127'u8, 101'u8, 63'u8)
LIGHT_SEPIA = (158'u8, 134'u8, 100'u8)
LIGHTER_SEPIA = (191'u8, 171'u8, 143'u8)
LIGHTEST_SEPIA = (222'u8, 211'u8, 195'u8)
DESATURATED_RED = (127'u8, 63'u8, 63'u8)
DESATURATED_FLAME = (127'u8, 79'u8, 63'u8)
DESATURATED_ORANGE = (127'u8, 95'u8, 63'u8)
DESATURATED_AMBER = (127'u8, 111'u8, 63'u8)
DESATURATED_YELLOW = (127'u8, 127'u8, 63'u8)
DESATURATED_LIME = (111'u8, 127'u8, 63'u8)
DESATURATED_CHARTREUSE = (95'u8, 127'u8, 63'u8)
DESATURATED_GREEN = (63'u8, 127'u8, 63'u8)
DESATURATED_SEA = (63'u8, 127'u8, 95'u8)
DESATURATED_TURQUOISE = (63'u8, 127'u8, 111'u8)
DESATURATED_CYAN = (63'u8, 127'u8, 127'u8)
DESATURATED_SKY = (63'u8, 111'u8, 127'u8)
DESATURATED_AZURE = (63'u8, 95'u8, 127'u8)
DESATURATED_BLUE = (63'u8, 63'u8, 127'u8)
DESATURATED_HAN = (79'u8, 63'u8, 127'u8)
DESATURATED_VIOLET = (95'u8, 63'u8, 127'u8)
DESATURATED_PURPLE = (111'u8, 63'u8, 127'u8)
DESATURATED_FUCHSIA = (127'u8, 63'u8, 127'u8)
DESATURATED_MAGENTA = (127'u8, 63'u8, 111'u8)
DESATURATED_PINK = (127'u8, 63'u8, 95'u8)
DESATURATED_CRIMSON = (127'u8, 63'u8, 79'u8)
LIGHTEST_RED = (255'u8, 191'u8, 191'u8)
LIGHTEST_FLAME = (255'u8, 207'u8, 191'u8)
LIGHTEST_ORANGE = (255'u8, 223'u8, 191'u8)
LIGHTEST_AMBER = (255'u8, 239'u8, 191'u8)
LIGHTEST_YELLOW = (255'u8, 255'u8, 191'u8)
LIGHTEST_LIME = (239'u8, 255'u8, 191'u8)
LIGHTEST_CHARTREUSE = (223'u8, 255'u8, 191'u8)
LIGHTEST_GREEN = (191'u8, 255'u8, 191'u8)
LIGHTEST_SEA = (191'u8, 255'u8, 223'u8)
LIGHTEST_TURQUOISE = (191'u8, 255'u8, 239'u8)
LIGHTEST_CYAN = (191'u8, 255'u8, 255'u8)
LIGHTEST_SKY = (191'u8, 239'u8, 255'u8)
LIGHTEST_AZURE = (191'u8, 223'u8, 255'u8)
LIGHTEST_BLUE = (191'u8, 191'u8, 255'u8)
LIGHTEST_HAN = (207'u8, 191'u8, 255'u8)
LIGHTEST_VIOLET = (223'u8, 191'u8, 255'u8)
LIGHTEST_PURPLE = (239'u8, 191'u8, 255'u8)
LIGHTEST_FUCHSIA = (255'u8, 191'u8, 255'u8)
LIGHTEST_MAGENTA = (255'u8, 191'u8, 239'u8)
LIGHTEST_PINK = (255'u8, 191'u8, 223'u8)
LIGHTEST_CRIMSON = (255'u8, 191'u8, 207'u8)
LIGHTER_RED = (255'u8, 127'u8, 127'u8)
LIGHTER_FLAME = (255'u8, 159'u8, 127'u8)
LIGHTER_ORANGE = (255'u8, 191'u8, 127'u8)
LIGHTER_AMBER = (255'u8, 223'u8, 127'u8)
LIGHTER_YELLOW = (255'u8, 255'u8, 127'u8)
LIGHTER_LIME = (223'u8, 255'u8, 127'u8)
LIGHTER_CHARTREUSE = (191'u8, 255'u8, 127'u8)
LIGHTER_GREEN = (127'u8, 255'u8, 127'u8)
LIGHTER_SEA = (127'u8, 255'u8, 191'u8)
LIGHTER_TURQUOISE = (127'u8, 255'u8, 223'u8)
LIGHTER_CYAN = (127'u8, 255'u8, 255'u8)
LIGHTER_SKY = (127'u8, 223'u8, 255'u8)
LIGHTER_AZURE = (127'u8, 191'u8, 255'u8)
LIGHTER_BLUE = (127'u8, 127'u8, 255'u8)
LIGHTER_HAN = (159'u8, 127'u8, 255'u8)
LIGHTER_VIOLET = (191'u8, 127'u8, 255'u8)
LIGHTER_PURPLE = (223'u8, 127'u8, 255'u8)
LIGHTER_FUCHSIA = (255'u8, 127'u8, 255'u8)
LIGHTER_MAGENTA = (255'u8, 127'u8, 223'u8)
LIGHTER_PINK = (255'u8, 127'u8, 191'u8)
LIGHTER_CRIMSON = (255'u8, 127'u8, 159'u8)
LIGHT_RED = (255'u8, 63'u8, 63'u8)
LIGHT_FLAME = (255'u8, 111'u8, 63'u8)
LIGHT_ORANGE = (255'u8, 159'u8, 63'u8)
LIGHT_AMBER = (255'u8, 207'u8, 63'u8)
LIGHT_YELLOW = (255'u8, 255'u8, 63'u8)
LIGHT_LIME = (207'u8, 255'u8, 63'u8)
LIGHT_CHARTREUSE = (159'u8, 255'u8, 63'u8)
LIGHT_GREEN = (63'u8, 255'u8, 63'u8)
LIGHT_SEA = (63'u8, 255'u8, 159'u8)
LIGHT_TURQUOISE = (63'u8, 255'u8, 207'u8)
LIGHT_CYAN = (63'u8, 255'u8, 255'u8)
LIGHT_SKY = (63'u8, 207'u8, 255'u8)
LIGHT_AZURE = (63'u8, 159'u8, 255'u8)
LIGHT_BLUE = (63'u8, 63'u8, 255'u8)
LIGHT_HAN = (111'u8, 63'u8, 255'u8)
LIGHT_VIOLET = (159'u8, 63'u8, 255'u8)
LIGHT_PURPLE = (207'u8, 63'u8, 255'u8)
LIGHT_FUCHSIA = (255'u8, 63'u8, 255'u8)
LIGHT_MAGENTA = (255'u8, 63'u8, 207'u8)
LIGHT_PINK = (255'u8, 63'u8, 159'u8)
LIGHT_CRIMSON = (255'u8, 63'u8, 111'u8)
RED = (255'u8, 0'u8, 0'u8)
FLAME = (255'u8, 63'u8, 0'u8)
ORANGE = (255'u8, 127'u8, 0'u8)
AMBER = (255'u8, 191'u8, 0'u8)
YELLOW = (255'u8, 255'u8, 0'u8)
LIME = (191'u8, 255'u8, 0'u8)
CHARTREUSE = (127'u8, 255'u8, 0'u8)
GREEN = (0'u8, 255'u8, 0'u8)
SEA = (0'u8, 255'u8, 127'u8)
TURQUOISE = (0'u8, 255'u8, 191'u8)
CYAN = (0'u8, 255'u8, 255'u8)
SKY = (0'u8, 191'u8, 255'u8)
AZURE = (0'u8, 127'u8, 255'u8)
BLUE = (0'u8, 0'u8, 255'u8)
HAN = (63'u8, 0'u8, 255'u8)
VIOLET = (127'u8, 0'u8, 255'u8)
PURPLE = (191'u8, 0'u8, 255'u8)
FUCHSIA = (255'u8, 0'u8, 255'u8)
MAGENTA = (255'u8, 0'u8, 191'u8)
PINK = (255'u8, 0'u8, 127'u8)
CRIMSON = (255'u8, 0'u8, 63'u8)
DARK_RED = (191'u8, 0'u8, 0'u8)
DARK_FLAME = (191'u8, 47'u8, 0'u8)
DARK_ORANGE = (191'u8, 95'u8, 0'u8)
DARK_AMBER = (191'u8, 143'u8, 0'u8)
DARK_YELLOW = (191'u8, 191'u8, 0'u8)
DARK_LIME = (143'u8, 191'u8, 0'u8)
DARK_CHARTREUSE = (95'u8, 191'u8, 0'u8)
DARK_GREEN = (0'u8, 191'u8, 0'u8)
DARK_SEA = (0'u8, 191'u8, 95'u8)
DARK_TURQUOISE = (0'u8, 191'u8, 143'u8)
DARK_CYAN = (0'u8, 191'u8, 191'u8)
DARK_SKY = (0'u8, 143'u8, 191'u8)
DARK_AZURE = (0'u8, 95'u8, 191'u8)
DARK_BLUE = (0'u8, 0'u8, 191'u8)
DARK_HAN = (47'u8, 0'u8, 191'u8)
DARK_VIOLET = (95'u8, 0'u8, 191'u8)
DARK_PURPLE = (143'u8, 0'u8, 191'u8)
DARK_FUCHSIA = (191'u8, 0'u8, 191'u8)
DARK_MAGENTA = (191'u8, 0'u8, 143'u8)
DARK_PINK = (191'u8, 0'u8, 95'u8)
DARK_CRIMSON = (191'u8, 0'u8, 47'u8)
DARKER_RED = (127'u8, 0'u8, 0'u8)
DARKER_FLAME = (127'u8, 31'u8, 0'u8)
DARKER_ORANGE = (127'u8, 63'u8, 0'u8)
DARKER_AMBER = (127'u8, 95'u8, 0'u8)
DARKER_YELLOW = (127'u8, 127'u8, 0'u8)
DARKER_LIME = (95'u8, 127'u8, 0'u8)
DARKER_CHARTREUSE = (63'u8, 127'u8, 0'u8)
DARKER_GREEN = (0'u8, 127'u8, 0'u8)
DARKER_SEA = (0'u8, 127'u8, 63'u8)
DARKER_TURQUOISE = (0'u8, 127'u8, 95'u8)
DARKER_CYAN = (0'u8, 127'u8, 127'u8)
DARKER_SKY = (0'u8, 95'u8, 127'u8)
DARKER_AZURE = (0'u8, 63'u8, 127'u8)
DARKER_BLUE = (0'u8, 0'u8, 127'u8)
DARKER_HAN = (31'u8, 0'u8, 127'u8)
DARKER_VIOLET = (63'u8, 0'u8, 127'u8)
DARKER_PURPLE = (95'u8, 0'u8, 127'u8)
DARKER_FUCHSIA = (127'u8, 0'u8, 127'u8)
DARKER_MAGENTA = (127'u8, 0'u8, 95'u8)
DARKER_PINK = (127'u8, 0'u8, 63'u8)
DARKER_CRIMSON = (127'u8, 0'u8, 31'u8)
DARKEST_RED = (63'u8, 0'u8, 0'u8)
DARKEST_FLAME = (63'u8, 15'u8, 0'u8)
DARKEST_ORANGE = (63'u8, 31'u8, 0'u8)
DARKEST_AMBER = (63'u8, 47'u8, 0'u8)
DARKEST_YELLOW = (63'u8, 63'u8, 0'u8)
DARKEST_LIME = (47'u8, 63'u8, 0'u8)
DARKEST_CHARTREUSE = (31'u8, 63'u8, 0'u8)
DARKEST_GREEN = (0'u8, 63'u8, 0'u8)
DARKEST_SEA = (0'u8, 63'u8, 31'u8)
DARKEST_TURQUOISE = (0'u8, 63'u8, 47'u8)
DARKEST_CYAN = (0'u8, 63'u8, 63'u8)
DARKEST_SKY = (0'u8, 47'u8, 63'u8)
DARKEST_AZURE = (0'u8, 31'u8, 63'u8)
DARKEST_BLUE = (0'u8, 0'u8, 63'u8)
DARKEST_HAN = (15'u8, 0'u8, 63'u8)
DARKEST_VIOLET = (31'u8, 0'u8, 63'u8)
DARKEST_PURPLE = (47'u8, 0'u8, 63'u8)
DARKEST_FUCHSIA = (63'u8, 0'u8, 63'u8)
DARKEST_MAGENTA = (63'u8, 0'u8, 47'u8)
DARKEST_PINK = (63'u8, 0'u8, 31'u8)
DARKEST_CRIMSON = (63'u8, 0'u8, 15'u8)
BRASS = (191'u8, 151'u8, 96'u8)
COPPER = (197'u8, 136'u8, 124'u8)
GOLD = (229'u8, 191'u8, 0'u8)
SILVER = (203'u8, 203'u8, 203'u8)
CELADON = (172'u8, 255'u8, 175'u8)
PEACH = (255'u8, 159'u8, 127'u8)
colors: array[0 .. COLOR_NB_HIGH, array[0 .. COLOR_LEVELS_HIGH, TColor]] = [[
    (127'u8, 63'u8, 63'u8), (255'u8, 191'u8, 191'u8), (255'u8, 127'u8, 127'u8),
    (255'u8, 63'u8, 63'u8), (255'u8, 0'u8, 0'u8), (191'u8, 0'u8, 0'u8),
    (127'u8, 0'u8, 0'u8), (63'u8, 0'u8, 0'u8)], [(127'u8, 79'u8, 63'u8),
    (255'u8, 207'u8, 191'u8), (255'u8, 159'u8, 127'u8), (255'u8, 111'u8, 63'u8),
    (255'u8, 63'u8, 0'u8), (191'u8, 47'u8, 0'u8), (127'u8, 31'u8, 0'u8),
    (63'u8, 15'u8, 0'u8)], [(127'u8, 95'u8, 63'u8), (255'u8, 223'u8, 191'u8),
                         (255'u8, 191'u8, 127'u8), (255'u8, 159'u8, 63'u8),
                         (255'u8, 127'u8, 0'u8), (191'u8, 95'u8, 0'u8),
                         (127'u8, 63'u8, 0'u8), (63'u8, 31'u8, 0'u8)], [
    (127'u8, 111'u8, 63'u8), (255'u8, 239'u8, 191'u8), (255'u8, 223'u8, 127'u8),
    (255'u8, 207'u8, 63'u8), (255'u8, 191'u8, 0'u8), (191'u8, 143'u8, 0'u8),
    (127'u8, 95'u8, 0'u8), (63'u8, 47'u8, 0'u8)], [(127'u8, 127'u8, 63'u8),
    (255'u8, 255'u8, 191'u8), (255'u8, 255'u8, 127'u8), (255'u8, 255'u8, 63'u8),
    (255'u8, 255'u8, 0'u8), (191'u8, 191'u8, 0'u8), (127'u8, 127'u8, 0'u8),
    (63'u8, 63'u8, 0'u8)], [(111'u8, 127'u8, 63'u8), (239'u8, 255'u8, 191'u8),
                         (223'u8, 255'u8, 127'u8), (207'u8, 255'u8, 63'u8),
                         (191'u8, 255'u8, 0'u8), (143'u8, 191'u8, 0'u8),
                         (95'u8, 127'u8, 0'u8), (47'u8, 63'u8, 0'u8)], [
    (95'u8, 127'u8, 63'u8), (223'u8, 255'u8, 191'u8), (191'u8, 255'u8, 127'u8),
    (159'u8, 255'u8, 63'u8), (127'u8, 255'u8, 0'u8), (95'u8, 191'u8, 0'u8),
    (63'u8, 127'u8, 0'u8), (31'u8, 63'u8, 0'u8)], [(63'u8, 127'u8, 63'u8),
    (191'u8, 255'u8, 191'u8), (127'u8, 255'u8, 127'u8), (63'u8, 255'u8, 63'u8),
    (0'u8, 255'u8, 0'u8), (0'u8, 191'u8, 0'u8), (0'u8, 127'u8, 0'u8),
    (0'u8, 63'u8, 0'u8)], [(63'u8, 127'u8, 95'u8), (191'u8, 255'u8, 223'u8),
                        (127'u8, 255'u8, 191'u8), (63'u8, 255'u8, 159'u8),
                        (0'u8, 255'u8, 127'u8), (0'u8, 191'u8, 95'u8),
                        (0'u8, 127'u8, 63'u8), (0'u8, 63'u8, 31'u8)], [
    (63'u8, 127'u8, 111'u8), (191'u8, 255'u8, 239'u8), (127'u8, 255'u8, 223'u8),
    (63'u8, 255'u8, 207'u8), (0'u8, 255'u8, 191'u8), (0'u8, 191'u8, 143'u8),
    (0'u8, 127'u8, 95'u8), (0'u8, 63'u8, 47'u8)], [(63'u8, 127'u8, 127'u8),
    (191'u8, 255'u8, 255'u8), (127'u8, 255'u8, 255'u8), (63'u8, 255'u8, 255'u8),
    (0'u8, 255'u8, 255'u8), (0'u8, 191'u8, 191'u8), (0'u8, 127'u8, 127'u8),
    (0'u8, 63'u8, 63'u8)], [(63'u8, 111'u8, 127'u8), (191'u8, 239'u8, 255'u8),
                         (127'u8, 223'u8, 255'u8), (63'u8, 207'u8, 255'u8),
                         (0'u8, 191'u8, 255'u8), (0'u8, 143'u8, 191'u8),
                         (0'u8, 95'u8, 127'u8), (0'u8, 47'u8, 63'u8)], [
    (63'u8, 95'u8, 127'u8), (191'u8, 223'u8, 255'u8), (127'u8, 191'u8, 255'u8),
    (63'u8, 159'u8, 255'u8), (0'u8, 127'u8, 255'u8), (0'u8, 95'u8, 191'u8),
    (0'u8, 63'u8, 127'u8), (0'u8, 31'u8, 63'u8)], [(63'u8, 63'u8, 127'u8),
    (191'u8, 191'u8, 255'u8), (127'u8, 127'u8, 255'u8), (63'u8, 63'u8, 255'u8),
    (0'u8, 0'u8, 255'u8), (0'u8, 0'u8, 191'u8), (0'u8, 0'u8, 127'u8),
    (0'u8, 0'u8, 63'u8)], [(79'u8, 63'u8, 127'u8), (207'u8, 191'u8, 255'u8),
                        (159'u8, 127'u8, 255'u8), (111'u8, 63'u8, 255'u8),
                        (63'u8, 0'u8, 255'u8), (47'u8, 0'u8, 191'u8),
                        (31'u8, 0'u8, 127'u8), (15'u8, 0'u8, 63'u8)], [
    (95'u8, 63'u8, 127'u8), (223'u8, 191'u8, 255'u8), (191'u8, 127'u8, 255'u8),
    (159'u8, 63'u8, 255'u8), (127'u8, 0'u8, 255'u8), (95'u8, 0'u8, 191'u8),
    (63'u8, 0'u8, 127'u8), (31'u8, 0'u8, 63'u8)], [(111'u8, 63'u8, 127'u8),
    (239'u8, 191'u8, 255'u8), (223'u8, 127'u8, 255'u8), (207'u8, 63'u8, 255'u8),
    (191'u8, 0'u8, 255'u8), (143'u8, 0'u8, 191'u8), (95'u8, 0'u8, 127'u8),
    (47'u8, 0'u8, 63'u8)], [(127'u8, 63'u8, 127'u8), (255'u8, 191'u8, 255'u8),
                         (255'u8, 127'u8, 255'u8), (255'u8, 63'u8, 255'u8),
                         (255'u8, 0'u8, 255'u8), (191'u8, 0'u8, 191'u8),
                         (127'u8, 0'u8, 127'u8), (63'u8, 0'u8, 63'u8)], [
    (127'u8, 63'u8, 111'u8), (255'u8, 191'u8, 239'u8), (255'u8, 127'u8, 223'u8),
    (255'u8, 63'u8, 207'u8), (255'u8, 0'u8, 191'u8), (191'u8, 0'u8, 143'u8),
    (127'u8, 0'u8, 95'u8), (63'u8, 0'u8, 47'u8)], [(127'u8, 63'u8, 95'u8),
    (255'u8, 191'u8, 223'u8), (255'u8, 127'u8, 191'u8), (255'u8, 63'u8, 159'u8),
    (255'u8, 0'u8, 127'u8), (191'u8, 0'u8, 95'u8), (127'u8, 0'u8, 63'u8),
    (63'u8, 0'u8, 31'u8)], [(127'u8, 63'u8, 79'u8), (255'u8, 191'u8, 207'u8),
                         (255'u8, 127'u8, 159'u8), (255'u8, 63'u8, 111'u8),
                         (255'u8, 0'u8, 63'u8), (191'u8, 0'u8, 47'u8),
                         (127'u8, 0'u8, 31'u8), (63'u8, 0'u8, 15'u8)]]
KEY_PRESSED = 1
KEY_RELEASED = 2
COLCTRL_NUMBER = COLCTRL_5
FONT_LAYOUT_ASCII_INCOL = 1
FONT_LAYOUT_ASCII_INROW = 2
FONT_TYPE_GRAYSCALE = 4
FONT_TYPE_GREYSCALE = 4
FONT_LAYOUT_TCOD = 8
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
CHAR_SMILIE = 1
CHAR_SMILIE_INV = 2
CHAR_HEART = 3
CHAR_DIAMOND = 4
CHAR_CLUB = 5
CHAR_SPADE = 6
CHAR_BULLET = 7
CHAR_BULLET_INV = 8
CHAR_RADIO_UNSET = 9
CHAR_RADIO_SET = 10
CHAR_MALE = 11
CHAR_FEMALE = 12
CHAR_NOTE = 13
CHAR_NOTE_DOUBLE = 14
CHAR_LIGHT = 15
CHAR_ARROW2_E = 16
CHAR_ARROW2_W = 17
CHAR_DARROW_V = 18
CHAR_EXCLAM_DOUBLE = 19
CHAR_PILCROW = 20
CHAR_SECTION = 21
CHAR_ARROW_N = 24
CHAR_ARROW_S = 25
CHAR_ARROW_E = 26
CHAR_ARROW_W = 27
CHAR_DARROW_H = 29
CHAR_ARROW2_N = 30
CHAR_ARROW2_S = 31
CHAR_POUND = 156
CHAR_MULTIPLICATION = 158
CHAR_FUNCTION = 159
CHAR_RESERVED = 169
CHAR_HALF = 171
CHAR_ONE_QUARTER = 172
CHAR_BLOCK1 = 176
CHAR_BLOCK2 = 177
CHAR_BLOCK3 = 178
CHAR_VLINE = 179
CHAR_TEEW = 180
CHAR_COPYRIGHT = 184
CHAR_DTEEW = 185
CHAR_DVLINE = 186
CHAR_DNE = 187
CHAR_DSE = 188
CHAR_CENT = 189
CHAR_YEN = 190
CHAR_NE = 191
CHAR_SW = 192
CHAR_TEEN = 193
CHAR_TEES = 194
CHAR_TEEE = 195
CHAR_HLINE = 196
CHAR_CROSS = 197
CHAR_DSW = 200
CHAR_DNW = 201
CHAR_DTEEN = 202
CHAR_DTEES = 203
CHAR_DTEEE = 204
CHAR_DHLINE = 205
CHAR_DCROSS = 206
CHAR_CURRENCY = 207
CHAR_SE = 217
CHAR_NW = 218
CHAR_CHECKBOX_UNSET = 224
CHAR_CHECKBOX_SET = 225
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
CHAR_THREE_QUARTERS = 243
CHAR_DIVISION = 246
CHAR_GRADE = 248
CHAR_UMLAUT = 249
CHAR_POW1 = 251
CHAR_POW3 = 252
CHAR_POW2 = 253
CHAR_BULLET_SQUARE = 254
EVENT_KEY_PRESS = 1
EVENT_KEY_RELEASE = 2
EVENT_KEY = 3
EVENT_MOUSE_MOVE = 4
EVENT_MOUSE_PRESS = 8
EVENT_MOUSE_RELEASE = 16
EVENT_MOUSE = 28
EVENT_ANY = 31
NOISE_MAX_OCTAVES = 128
NOISE_MAX_DIMENSIONS = 4
NOISE_DEFAULT_HURST = 0.5'f32
NOISE_DEFAULT_LACUNARITY = 2.0'f32
DEFAULT_DIAGONAL_COST = 1.41'f32
LEX_FLAG_NOCASE = 1
LEX_FLAG_NESTING_COMMENT = 2
LEX_FLAG_TOKENIZE_COMMENTS = 4
LEX_ERROR = -1
LEX_UNKNOWN = 0
LEX_SYMBOL = 1
LEX_KEYWORD = 2
LEX_IDEN = 3
LEX_STRING = 4
LEX_INTEGER = 5
LEX_FLOAT = 6
LEX_CHAR = 7
LEX_EOF = 8
LEX_COMMENT = 9
LEX_MAX_SYMBOLS = 100
LEX_SYMBOL_SIZE = 5
LEX_MAX_KEYWORDS = 100
LEX_KEYWORD_SIZE = 20
TYPE_NONE: TValueType = 0
TYPE_BOOL: TValueType = 1
TYPE_CHAR: TValueType = 2
TYPE_INT: TValueType = 3
TYPE_FLOAT: TValueType = 4
TYPE_STRING: TValueType = 5
TYPE_COLOR: TValueType = 6
TYPE_DICE: TValueType = 7
TYPE_VALUELIST00: TValueType = 8
TYPE_VALUELIST01: TValueType = 9
TYPE_VALUELIST02: TValueType = 10
TYPE_VALUELIST03: TValueType = 11
TYPE_VALUELIST04: TValueType = 12
TYPE_VALUELIST05: TValueType = 13
TYPE_VALUELIST06: TValueType = 14
TYPE_VALUELIST07: TValueType = 15
TYPE_VALUELIST08: TValueType = 16
TYPE_VALUELIST09: TValueType = 17
TYPE_VALUELIST10: TValueType = 18
TYPE_VALUELIST11: TValueType = 19
TYPE_VALUELIST12: TValueType = 20
TYPE_VALUELIST13: TValueType = 21
TYPE_VALUELIST14: TValueType = 22
TYPE_VALUELIST15: TValueType = 23
TYPE_CUSTOM00: TValueType = 24
TYPE_CUSTOM01: TValueType = 25
TYPE_CUSTOM02: TValueType = 26
TYPE_CUSTOM03: TValueType = 27
TYPE_CUSTOM04: TValueType = 28
TYPE_CUSTOM05: TValueType = 29
TYPE_CUSTOM06: TValueType = 30
TYPE_CUSTOM07: TValueType = 31
TYPE_CUSTOM08: TValueType = 32
TYPE_CUSTOM09: TValueType = 33
TYPE_CUSTOM10: TValueType = 34
TYPE_CUSTOM11: TValueType = 35
TYPE_CUSTOM12: TValueType = 36
TYPE_CUSTOM13: TValueType = 37
TYPE_CUSTOM14: TValueType = 38
TYPE_CUSTOM15: TValueType = 39
TYPE_LIST: TValueType = 1024

Procs

proc lerp[T](a, b, x: T): T
proc color_RGB(r, g, b: uint8): TColor {...}{.cdecl, importc: "TCOD_color_RGB",
                                   dynlib: LIB_NAME.}
proc color_HSV(h, s, v: cfloat): TColor {...}{.cdecl, importc: "TCOD_color_", dynlib: LIB_NAME.}
proc color_equals(c1, c2: TColor): bool {...}{.cdecl, importc: "TCOD_color_equals",
                                     dynlib: LIB_NAME.}
proc color_add(c1, c2: TColor): TColor {...}{.cdecl, importc: "TCOD_color_add",
                                    dynlib: LIB_NAME.}
proc color_subtract(c1, c2: TColor): TColor {...}{.cdecl, importc: "TCOD_color_subtract",
    dynlib: LIB_NAME.}
proc color_multiply(c1, c2: TColor): TColor {...}{.cdecl, importc: "TCOD_color_multiply",
    dynlib: LIB_NAME.}
proc color_multiply_scalar(c1: TColor; value: cfloat): TColor {...}{.cdecl,
    importc: "TCOD_color_multiply_scalar", dynlib: LIB_NAME.}
proc color_lerp(c1, c2: TColor; coef: cfloat): TColor {...}{.cdecl,
    importc: "TCOD_color_lerp", dynlib: LIB_NAME.}
proc color_set_HSV(c: ptr TColor; h, s, v: cfloat) {...}{.cdecl,
    importc: "TCOD_color_set_HSV", dynlib: LIB_NAME.}
proc color_get_HSV(c: TColor; h, s, v: ptr cfloat) {...}{.cdecl,
    importc: "TCOD_color_get_HSV", dynlib: LIB_NAME.}
proc color_get_hue(c: TColor): cfloat {...}{.cdecl, importc: "TCOD_color_get_hue",
                                    dynlib: LIB_NAME.}
proc color_set_hue(c: ptr TColor; h: cfloat) {...}{.cdecl, importc: "TCOD_color_set_hue",
    dynlib: LIB_NAME.}
proc color_get_saturation(c: TColor): cfloat {...}{.cdecl,
    importc: "TCOD_color_get_saturation", dynlib: LIB_NAME.}
proc color_set_saturation(c: ptr TColor; s: cfloat) {...}{.cdecl,
    importc: "TCOD_color_set_saturation", dynlib: LIB_NAME.}
proc color_get_value(c: TColor): cfloat {...}{.cdecl, importc: "TCOD_color_get_value",
                                      dynlib: LIB_NAME.}
proc color_set_value(c: ptr TColor; v: cfloat) {...}{.cdecl,
    importc: "TCOD_color_set_value", dynlib: LIB_NAME.}
proc color_shift_hue(c: ptr TColor; hshift: cfloat) {...}{.cdecl,
    importc: "TCOD_color_shift_hue", dynlib: LIB_NAME.}
proc color_scale_HSV(c: ptr TColor; scoef, vcoef: cfloat) {...}{.cdecl,
    importc: "TCOD_color_scale_HSV", dynlib: LIB_NAME.}
proc color_gen_map(map: ptr TColor; nb_key: int; key_color: ptr TColor;
                  key_index: ptr int) {...}{.cdecl, importc: "TCOD_color_gen_map",
                                     dynlib: LIB_NAME.}
proc bkgnd_alpha(alpha: cfloat): TBkgndFlag {...}{.inline, raises: [], tags: [].}
proc bkgnd_addalpha(alpha: cfloat): TBkgndFlag {...}{.inline, raises: [], tags: [].}
proc console_init_root(w, h: int; title: cstring; fullscreen = false;
                      renderer = RENDERER_SDL) {...}{.cdecl,
    importc: "TCOD_console_init_root", dynlib: LIB_NAME.}
proc console_set_window_title(title: cstring) {...}{.cdecl,
    importc: "TCOD_console_set_window_title", dynlib: LIB_NAME.}
proc console_set_fullscreen(fullscreen: bool) {...}{.cdecl,
    importc: "TCOD_console_set_fullscreen", dynlib: LIB_NAME.}
proc console_is_fullscreen(): bool {...}{.cdecl, importc: "TCOD_console_is_fullscreen",
                                  dynlib: LIB_NAME.}
proc console_is_window_closed(): bool {...}{.cdecl,
                                     importc: "TCOD_console_is_window_closed",
                                     dynlib: LIB_NAME.}
proc console_set_custom_font(fontFile: cstring;
                            flags: int = FONT_LAYOUT_ASCII_INCOL; nb_char_horiz = 0;
                            nb_char_vertic = 0) {...}{.cdecl,
    importc: "TCOD_console_set_custom_font", dynlib: LIB_NAME.}
proc console_map_ascii_code_to_font(asciiCode, fontCharX, fontCharY: int) {...}{.cdecl,
    importc: "TCOD_console_map_ascii_code_to_int", dynlib: LIB_NAME.}
proc console_map_ascii_codes_to_font(asciiCode, nbCodes, fontCharX, fontCharY: int) {...}{.
    cdecl, importc: "TCOD_console_map_ascii_codes_to_font", dynlib: LIB_NAME.}
proc console_map_string_to_font(s: cstring; fontCharX, fontCharY: int) {...}{.cdecl,
    importc: "TCOD_console_map_string_to_font", dynlib: LIB_NAME.}
proc console_set_dirty(x, y, w, h: int) {...}{.cdecl, importc: "TCOD_console_set_dirty",
                                    dynlib: LIB_NAME.}
proc console_set_default_background(con: PConsole; col: TColor) {...}{.cdecl,
    importc: "TCOD_console_set_default_background", dynlib: LIB_NAME.}
proc console_set_default_foreground(con: PConsole; col: TColor) {...}{.cdecl,
    importc: "TCOD_console_set_default_foreground", dynlib: LIB_NAME.}
proc console_clear(con: PConsole) {...}{.cdecl, importc: "TCOD_console_clear",
                                 dynlib: LIB_NAME.}
proc console_set_char_background(con: PConsole; x, y: int; col: TColor;
                                flag: TBkgndFlag = BKGND_SET) {...}{.cdecl,
    importc: "TCOD_console_set_char_background", dynlib: LIB_NAME.}
proc console_set_char_foreground(con: PConsole; x, y: int; col: TColor) {...}{.cdecl,
    importc: "TCOD_console_set_char_foreground", dynlib: LIB_NAME.}
proc console_set_char(con: PConsole; x, y, c: int) {...}{.cdecl,
    importc: "TCOD_console_set_char", dynlib: LIB_NAME.}
proc console_put_char(con: PConsole; x, y, c: int; flag = BKGND_DEFAULT) {...}{.cdecl,
    importc: "TCOD_console_put_char", dynlib: LIB_NAME.}
proc console_put_char(con: PConsole; x, y: int; c: char; flag = BKGND_DEFAULT) {...}{.inline,
    raises: [], tags: [].}
proc console_put_char_ex(con: PConsole; x, y, c: int; fore, back: TColor) {...}{.cdecl,
    importc: "TCOD_console_put_char_ex", dynlib: LIB_NAME.}
proc console_putc_har_ex(con: PConsole; x, y: int; c: char; fore, back: TColor) {...}{.inline,
    raises: [], tags: [].}
proc console_set_background_flag(con: PConsole; flag: TBkgndFlag = BKGND_DEFAULT) {...}{.
    cdecl, importc: "TCOD_console_set_background_flag", dynlib: LIB_NAME.}
proc console_get_background_flag(con: PConsole): TBkgndFlag {...}{.cdecl,
    importc: "TCOD_console_get_background_flag", dynlib: LIB_NAME.}
proc console_set_alignment(con: PConsole; alignment: TAlignment) {...}{.cdecl,
    importc: "TCOD_console_set_alignment", dynlib: LIB_NAME.}
proc console_get_alginment(con: PConsole): TAlignment {...}{.cdecl,
    importc: "TCOD_console_get_alignment", dynlib: LIB_NAME.}
proc console_print(con: PConsole; x, y: int; fmt: cstring) {...}{.cdecl,
    importc: "TCOD_console_print", varargs, dynlib: LIB_NAME.}
proc console_print_ex(con: PConsole; x, y: int; flag: TBkgndFlag; alignment: TAlignment;
                     fmt: cstring) {...}{.cdecl, importc: "TCOD_console_print_ex",
                                   varargs, dynlib: LIB_NAME.}
proc console_print_rect(con: PConsole; x, y, w, h: int; fmt: cstring): cint {...}{.cdecl,
    importc: "TCOD_console_print_rect", varargs, dynlib: LIB_NAME.}
proc console_print_rect_ex(con: PConsole; x, y, w, h: int; flag: TBkgndFlag;
                          alignment: TAlignment; fmt: cstring): cint {...}{.cdecl,
    importc: "TCOD_console_print_rect_ex", varargs, dynlib: LIB_NAME.}
proc console_get_height_rect(con: PConsole; x, y, w, h: int; fmt: cstring): cint {...}{.cdecl,
    importc: "TCOD_console_get_height_rect", varargs, dynlib: LIB_NAME.}
proc console_rect(con: PConsole; x, y, w, h: int; clear: bool; flag = BKGND_DEFAULT) {...}{.cdecl,
    importc: "TCOD_console_rect", dynlib: LIB_NAME.}
proc console_hline(con: PConsole; x, y, line: int; flag = BKGND_DEFAULT) {...}{.cdecl,
    importc: "TCOD_console_hline", dynlib: LIB_NAME.}
proc console_vline(con: PConsole; x, y, line: int; flag = BKGND_DEFAULT) {...}{.cdecl,
    importc: "TCOD_console_vline", dynlib: LIB_NAME.}
proc console_print_frame(con: PConsole; x, y, w, h: int; empty: bool;
                        flag = BKGND_DEFAULT; fmt: cstring = nil) {...}{.cdecl,
    importc: "TCOD_console_print_frame", varargs, dynlib: LIB_NAME.}
proc console_map_string_to_font_utf(s: string; fontCharX, fontCharY: int) {...}{.
    raises: [], tags: [].}
proc console_print_utf(con: PConsole; x, y: int; fmt: string) {...}{.raises: [], tags: [].}
proc console_print_ex_utf(con: PConsole; x, y: int; flag: TBkgndFlag;
                         alignment: TAlignment; fmt: string) {...}{.raises: [], tags: [].}
proc console_print_rect_utf(con: PConsole; x, y, w, h: int; fmt: string): cint {...}{.
    raises: [], tags: [].}
proc console_print_rect_ex_utf(con: PConsole; x, y, w, h: int; flag: TBkgndFlag;
                              alignment: TAlignment; fmt: string): cint {...}{.raises: [],
    tags: [].}
proc console_get_height_rect_utf(con: PConsole; x, y, w, h: int; fmt: string): cint {...}{.
    raises: [], tags: [].}
proc console_get_default_background(con: PConsole): TColor {...}{.cdecl,
    importc: "TCOD_console_get_default_background", dynlib: LIB_NAME.}
proc console_get_default_foreground(con: PConsole): TColor {...}{.cdecl,
    importc: "TCOD_console_get_default_foreground", dynlib: LIB_NAME.}
proc console_get_char_background(con: PConsole; x, y: int): TColor {...}{.cdecl,
    importc: "TCOD_console_get_char_background", dynlib: LIB_NAME.}
proc console_get_char_foreground(con: PConsole; x, y: int): TColor {...}{.cdecl,
    importc: "TCOD_console_get_char_foreground", dynlib: LIB_NAME.}
proc console_get_char(con: PConsole; x, y: int): cint {...}{.cdecl,
    importc: "TCOD_console_get_char", dynlib: LIB_NAME.}
proc console_set_fade(val: uint8; fade: TColor) {...}{.cdecl,
    importc: "TCOD_console_set_fade", dynlib: LIB_NAME.}
proc console_get_fade(): uint8 {...}{.cdecl, importc: "TCOD_console_get_fade",
                              dynlib: LIB_NAME.}
proc console_get_fading_color(): TColor {...}{.cdecl, importc: "TCOD_console_get_fading_color",
                                       dynlib: LIB_NAME.}
proc console_flush() {...}{.cdecl, importc: "TCOD_console_flush", dynlib: LIB_NAME.}
proc console_set_color_control(con: TColctrl; fore, back: TColor) {...}{.cdecl,
    importc: "TCOD_console_set_color_control", dynlib: LIB_NAME.}
proc console_check_for_keypress(flags: int = KEY_RELEASED): TKey {...}{.cdecl,
    importc: "TCOD_console_check_for_keypress", dynlib: LIB_NAME.}
proc console_wait_for_keypress(flush: bool): TKey {...}{.cdecl,
    importc: "TCOD_console_wait_for_keypress", dynlib: LIB_NAME.}
proc console_set_keyboard_repeat(initial_delay, interval: int) {...}{.cdecl,
    importc: "TCOD_console_set_keyboard_repeat", dynlib: LIB_NAME.}
proc console_disable_keyboard_repeat() {...}{.cdecl, importc: "TCOD_console_disable_keyboard_repeat",
                                       dynlib: LIB_NAME.}
proc console_is_key_pressed(key: TKeycode): bool {...}{.cdecl,
    importc: "TCOD_console_is_key_pressed", dynlib: LIB_NAME.}
proc console_from_file(filename: cstring): PConsole {...}{.cdecl,
    importc: "TCOD_console_from_file", dynlib: LIB_NAME.}
proc console_load_asc(con: PConsole; filename: cstring): bool {...}{.cdecl,
    importc: "TCOD_console_load_asc", dynlib: LIB_NAME.}
proc console_load_apf(con: PConsole; filename: cstring): bool {...}{.cdecl,
    importc: "TCOD_console_load_apf", dynlib: LIB_NAME.}
proc console_save_asc(con: PConsole; filename: cstring): bool {...}{.cdecl,
    importc: "TCOD_console_save_asc", dynlib: LIB_NAME.}
proc console_save_apf(con: PConsole; filename: cstring): bool {...}{.cdecl,
    importc: "TCOD_console_save_apf", dynlib: LIB_NAME.}
proc console_new(w, h: int): PConsole {...}{.cdecl, importc: "TCOD_console_new",
                                   dynlib: LIB_NAME.}
proc console_get_width(con: PConsole): cint {...}{.cdecl,
    importc: "TCOD_console_get_width", dynlib: LIB_NAME.}
proc console_get_height(con: PConsole): cint {...}{.cdecl,
    importc: "TCOD_console_get_height", dynlib: LIB_NAME.}
proc console_set_key_color(con: PConsole; col: TColor) {...}{.cdecl,
    importc: "TCOD_console_set_key_color", dynlib: LIB_NAME.}
proc console_blit(src: PConsole; xSrc, ySrc, wSrc, hSrc: int; dst: PConsole;
                 xDst, yDst: int; foreground_alpha = 1.0'f32;
                 background_alpha = 1.0'f32) {...}{.cdecl, importc: "TCOD_console_blit",
    dynlib: LIB_NAME.}
proc console_delete(con: var PConsole) {...}{.raises: [], tags: [].}
proc console_credits() {...}{.cdecl, importc: "TCOD_console_credits", dynlib: LIB_NAME.}
proc console_credits_reset() {...}{.cdecl, importc: "TCOD_console_credits_reset",
                             dynlib: LIB_NAME.}
proc console_credits_render(x, y: int; alpha: bool): bool {...}{.cdecl,
    importc: "TCOD_console_credits_render", dynlib: LIB_NAME.}
proc mouse_show_cursor(visible: bool) {...}{.cdecl, importc: "TCOD_mouse_show_cursor",
                                     dynlib: LIB_NAME.}
proc mouse_get_status(): TMouse {...}{.cdecl, importc: "TCOD_mouse_get_status",
                               dynlib: LIB_NAME.}
proc mouse_is_cursor_visible(): bool {...}{.cdecl,
                                    importc: "TCOD_mouse_is_cursor_visible",
                                    dynlib: LIB_NAME.}
proc mouse_move(x, y: int) {...}{.cdecl, importc: "TCOD_mouse_move", dynlib: LIB_NAME.}
proc mouse_includes_touch(enable: bool) {...}{.cdecl,
                                       importc: "TCOD_mouse_includes_touch",
                                       dynlib: LIB_NAME.}
proc image_new(width, height: int): PImage {...}{.cdecl, importc: "TCOD_image_new",
                                        dynlib: LIB_NAME.}
proc image_from_console(console: PConsole): PImage {...}{.cdecl,
    importc: "TCOD_image_from_console", dynlib: LIB_NAME.}
proc image_refresh_console(image: PImage; console: PConsole) {...}{.cdecl,
    importc: "TCOD_image_refresh_console", dynlib: LIB_NAME.}
proc image_load(filename: cstring): PImage {...}{.cdecl, importc: "TCOD_image_load",
    dynlib: LIB_NAME.}
proc image_clear(image: PImage; color: TColor) {...}{.cdecl, importc: "TCOD_image_clear",
    dynlib: LIB_NAME.}
proc image_invert(image: PImage) {...}{.cdecl, importc: "TCOD_image_invert",
                                dynlib: LIB_NAME.}
proc image_hflip(image: PImage) {...}{.cdecl, importc: "TCOD_image_hflip", dynlib: LIB_NAME.}
proc image_rotate90(image: PImage; numRotations = 1) {...}{.cdecl,
    importc: "TCOD_image_rotate90", dynlib: LIB_NAME.}
proc image_vflip(image: PImage) {...}{.cdecl, importc: "TCOD_image_vflip", dynlib: LIB_NAME.}
proc image_scale(image: PImage; neww, newh: int) {...}{.cdecl, importc: "TCOD_image_scale",
    dynlib: LIB_NAME.}
proc image_save(image: PImage; filename: cstring) {...}{.cdecl, importc: "TCOD_image_save",
    dynlib: LIB_NAME.}
proc image_get_size(image: PImage; w, h: ptr int) {...}{.cdecl,
    importc: "TCOD_image_get_size", dynlib: LIB_NAME.}
proc image_get_pixel(image: PImage; x, y: int): TColor {...}{.cdecl,
    importc: "TCOD_image_get_pixel", dynlib: LIB_NAME.}
proc image_get_alpha(image: PImage; x, y: int): cint {...}{.cdecl,
    importc: "TCOD_image_get_alpha", dynlib: LIB_NAME.}
proc image_get_mipmap_pixel(image: PImage; x0, y0, x1, y1: cfloat): TColor {...}{.cdecl,
    importc: "TCOD_image_get_mipmap_pixel", dynlib: LIB_NAME.}
proc image_put_pixel(image: PImage; x, y: int; col: TColor) {...}{.cdecl,
    importc: "TCOD_image_put_pixel", dynlib: LIB_NAME.}
proc image_blit(image: PImage; console: PConsole; x, y: cfloat; bkgnd_flag: TBkgndFlag;
               scalex, scaley, angle: cfloat) {...}{.cdecl, importc: "TCOD_image_blit",
    dynlib: LIB_NAME.}
proc image_blit_rect(image: PImage; console: PConsole; x, y, w, h: int;
                    bkgnd_flag: TBkgndFlag) {...}{.cdecl,
    importc: "TCOD_image_blit_rect", dynlib: LIB_NAME.}
proc image_blit_2x(image: PImage; dest: PConsole; dx, dy: int; sx = 0; sy = 0; w = (-1);
                  h = (-1)) {...}{.cdecl, importc: "TCOD_image_blit_2x", dynlib: LIB_NAME.}
proc image_delete(image: var PImage) {...}{.raises: [], tags: [].}
proc image_set_key_color(image: PImage; key_color: TColor) {...}{.cdecl,
    importc: "TCOD_image_set_key_color", dynlib: LIB_NAME.}
proc image_is_pixel_transparent(image: PImage; x, y: int): bool {...}{.cdecl,
    importc: "TCOD_image_is_pixel_transparent", dynlib: LIB_NAME.}
proc sys_elapsed_milli(): cuint {...}{.cdecl, importc: "TCOD_sys_elapsed_milli",
                               dynlib: LIB_NAME.}
proc sys_elapsed_seconds(): cfloat {...}{.cdecl, importc: "TCOD_sys_elapsed_seconds",
                                  dynlib: LIB_NAME.}
proc sys_sleep_milli(val: cuint) {...}{.cdecl, importc: "TCOD_sys_sleep_milli",
                                dynlib: LIB_NAME.}
proc sys_save_screenshot(filename: cstring) {...}{.cdecl,
    importc: "TCOD_sys_save_screenshot", dynlib: LIB_NAME.}
proc sys_force_fullscreen_resolution(width, height: int) {...}{.cdecl,
    importc: "TCOD_sys_force_fullscreen_resolution", dynlib: LIB_NAME.}
proc sys_set_renderer(renderer: TRenderer) {...}{.cdecl,
    importc: "TCOD_sys_set_renderer", dynlib: LIB_NAME.}
proc sys_get_renderer(): TRenderer {...}{.cdecl, importc: "TCOD_sys_get_renderer",
                                  dynlib: LIB_NAME.}
proc sys_set_fps(val: int) {...}{.cdecl, importc: "TCOD_sys_set_fps", dynlib: LIB_NAME.}
proc sys_get_fps(): cint {...}{.cdecl, importc: "TCOD_sys_get_fps", dynlib: LIB_NAME.}
proc sys_get_last_frame_length(): cfloat {...}{.cdecl, importc: "TCOD_sys_get_last_frame_length",
                                        dynlib: LIB_NAME.}
proc sys_get_current_resolution(w, h: ptr int) {...}{.cdecl,
    importc: "TCOD_sys_get_current_resolution", dynlib: LIB_NAME.}
proc sys_get_fullscreen_offsets(offx, offy: ptr int) {...}{.cdecl,
    importc: "TCOD_sys_get_fullscreen_offsets", dynlib: LIB_NAME.}
proc sys_update_char(asciiCode, fontx, fonty: int; img: PImage; x, y: int) {...}{.cdecl,
    importc: "TCOD_sys_update_char", dynlib: LIB_NAME.}
proc sys_get_char_size(w, h: ptr int) {...}{.cdecl, importc: "TCOD_sys_get_char_size",
                                   dynlib: LIB_NAME.}
proc sys_get_sdl_window(): pointer {...}{.cdecl, importc: "TCOD_sys_get_sdl_window",
                                  dynlib: LIB_NAME.}
proc sys_wait_for_event(eventMask: int; key: ptr TKey; mouse: ptr TMouse; flush: bool): TEvent {...}{.
    cdecl, importc: "TCOD_sys_wait_for_event", dynlib: LIB_NAME.}
proc sys_check_for_event(eventMask: int; key: ptr TKey; mouse: ptr TMouse): TEvent {...}{.
    cdecl, importc: "TCOD_sys_check_for_event", dynlib: LIB_NAME.}
proc sys_create_directory(path: cstring): bool {...}{.cdecl,
    importc: "TCOD_sys_create_directory", dynlib: LIB_NAME.}
proc sys_delete_file(path: cstring): bool {...}{.cdecl, importc: "TCOD_sys_delete_file",
                                        dynlib: LIB_NAME.}
proc sys_delete_directory(path: cstring): bool {...}{.cdecl,
    importc: "TCOD_sys_delete_directory", dynlib: LIB_NAME.}
proc sys_is_directory(path: cstring): bool {...}{.cdecl, importc: "TCOD_sys_is_directory",
    dynlib: LIB_NAME.}
proc sys_get_directory_content(path, pattern: string): seq[string] {...}{.raises: [],
    tags: [ReadDirEffect].}
proc sys_file_exists(filename: cstring): bool {...}{.cdecl,
    importc: "TCOD_sys_file_exists", varargs, dynlib: LIB_NAME.}
proc sys_read_file(filename: cstring; buf: pointer; size: ptr cuint): bool {...}{.cdecl,
    importc: "TCOD_sys_read_file", dynlib: LIB_NAME.}
proc sys_write_file(filename: cstring; buf: pointer; size: cuint): bool {...}{.cdecl,
    importc: "TCOD_sys_write_file", dynlib: LIB_NAME.}
proc sys_clipboard_set(value: cstring) {...}{.cdecl, importc: "TCOD_sys_clipboard_set",
                                      dynlib: LIB_NAME.}
proc sys_clipboard_get(): cstring {...}{.cdecl, importc: "TCOD_sys_clipboard_get",
                                 dynlib: LIB_NAME.}
proc thread_new(cb: PCallback; data: pointer): PThread {...}{.cdecl,
    importc: "TCOD_thread_new", dynlib: LIB_NAME.}
proc thread_delete(th: var PThread) {...}{.raises: [], tags: [].}
proc sys_get_num_cores(): cint {...}{.cdecl, importc: "TCOD_sys_get_num_cores",
                              dynlib: LIB_NAME.}
proc thread_wait(th: PThread) {...}{.cdecl, importc: "TCOD_thread_wait", dynlib: LIB_NAME.}
proc mutex_new(): PMutex {...}{.cdecl, importc: "TCOD_mutex_new", dynlib: LIB_NAME.}
proc mutex_in(mut: PMutex) {...}{.cdecl, importc: "TCOD_mutex_in", dynlib: LIB_NAME.}
proc mutex_out(mut: PMutex) {...}{.cdecl, importc: "TCOD_mutex_out", dynlib: LIB_NAME.}
proc mutex_delete(mut: var PMutex) {...}{.raises: [], tags: [].}
proc semaphore_new(initVal: int): PSemaphore {...}{.cdecl, importc: "TCOD_semaphore_new",
    dynlib: LIB_NAME.}
proc semaphore_lock(sem: PSemaphore) {...}{.cdecl, importc: "TCOD_semaphore_lock",
                                    dynlib: LIB_NAME.}
proc semaphore_unlock(sem: PSemaphore) {...}{.cdecl, importc: "TCOD_semaphore_unlock",
                                      dynlib: LIB_NAME.}
proc semaphore_delete(sem: var PSemaphore) {...}{.raises: [], tags: [].}
proc condition_new(): PCond {...}{.cdecl, importc: "TCOD_condition_new", dynlib: LIB_NAME.}
proc condition_signal(sem: PCond) {...}{.cdecl, importc: "TCOD_condition_signal",
                                 dynlib: LIB_NAME.}
proc condition_broadcast(sem: PCond) {...}{.cdecl, importc: "TCOD_condition_broadcast",
                                    dynlib: LIB_NAME.}
proc condition_wait(sem: PCond; mut: PMutex) {...}{.cdecl, importc: "TCOD_condition_wait",
    dynlib: LIB_NAME.}
proc condition_delete(sem: var PCond) {...}{.raises: [], tags: [].}
proc load_library(path: cstring): PLibrary {...}{.cdecl, importc: "TCOD_load_library",
    dynlib: LIB_NAME.}
proc get_function_address(library: PLibrary; function_name: cstring): pointer {...}{.cdecl,
    importc: "TCOD_get_function_address", dynlib: LIB_NAME.}
proc close_library(library: var PLibrary) {...}{.raises: [], tags: [].}
proc sys_register_SDL_renderer(renderer: PSDLRenderer) {...}{.cdecl,
    importc: "TCOD_sys_register_SDL_renderer", dynlib: LIB_NAME.}
proc repr(dice: TDice): string {...}{.raises: [], tags: [].}
proc random_get_instance(): PRandom {...}{.cdecl, importc: "TCOD_random_get_instance",
                                   dynlib: LIB_NAME.}
proc random_new(algo: TRandomAlgo = RNG_CMWC): PRandom {...}{.cdecl,
    importc: "TCOD_random_new", dynlib: LIB_NAME.}
proc random_save(mersenne: PRandom): PRandom {...}{.cdecl, importc: "TCOD_random_save",
    dynlib: LIB_NAME.}
proc random_restore(mersenne, backup: PRandom) {...}{.cdecl,
    importc: "TCOD_random_restore", dynlib: LIB_NAME.}
proc random_new_from_seed(algo: TRandomAlgo = RNG_CMWC; seed: cuint): PRandom {...}{.cdecl,
    importc: "TCOD_random_new_from_seed", dynlib: LIB_NAME.}
proc random_delete(mersenne: var PRandom) {...}{.raises: [], tags: [].}
proc random_set_distribution(mersenne: PRandom; distribution: TDistribution) {...}{.cdecl,
    importc: "TCOD_random_set_distribution", dynlib: LIB_NAME.}
proc random_get_int(mersenne: PRandom; min, max: int): cint {...}{.cdecl,
    importc: "TCOD_random_get_int", dynlib: LIB_NAME.}
proc random_get_float(mersenne: PRandom; min, max: cfloat): cfloat {...}{.cdecl,
    importc: "TCOD_random_get_float", dynlib: LIB_NAME.}
proc random_get_double(mersenne: PRandom; min, max: cdouble): cdouble {...}{.cdecl,
    importc: "TCOD_random_get_double", dynlib: LIB_NAME.}
proc random_get_int_mean(mersenne: PRandom; min, max, mean: int): cint {...}{.cdecl,
    importc: "TCOD_random_get_int_mean", dynlib: LIB_NAME.}
proc random_get_float_mean(mersenne: PRandom; min, max, mean: cfloat): cfloat {...}{.cdecl,
    importc: "TCOD_random_get_float_mean", dynlib: LIB_NAME.}
proc random_get_double_mean(mersenne: PRandom; min, max, mean: cdouble): cdouble {...}{.
    cdecl, importc: "TCOD_random_get_double_mean", dynlib: LIB_NAME.}
proc random_dice_new(s: cstring): TDice {...}{.cdecl, importc: "TCOD_random_dice_new",
                                      dynlib: LIB_NAME.}
proc random_dice_roll(mersenne: PRandom; dice: TDice): cint {...}{.cdecl,
    importc: "TCOD_random_dice_roll", dynlib: LIB_NAME.}
proc random_dice_roll_s(mersenne: PRandom; s: cstring): cint {...}{.cdecl,
    importc: "TCOD_random_dice_roll_s", dynlib: LIB_NAME.}
proc noise_new(dimensions: int; hurst = NOISE_DEFAULT_HURST;
              lacunarity = NOISE_DEFAULT_LACUNARITY; random: PRandom = nil): PNoise {...}{.
    cdecl, importc: "TCOD_noise_new", dynlib: LIB_NAME.}
proc noise_set_type(noise: PNoise; noise_type = NOISE_DEFAULT) {...}{.cdecl,
    importc: "TCOD_noise_set_type", dynlib: LIB_NAME.}
proc noise_get_ex(noise: PNoise; f: ptr cfloat; noise_type = NOISE_DEFAULT): cfloat {...}{.
    cdecl, importc: "TCOD_noise_get_ex", dynlib: LIB_NAME.}
proc noise_get_fbm_ex(noise: PNoise; f: ptr cfloat; octaves: cfloat;
                     noise_type = NOISE_DEFAULT): cfloat {...}{.cdecl,
    importc: "TCOD_noise_get_fbm_ex", dynlib: LIB_NAME.}
proc noise_get_turbulence_ex(noise: PNoise; f: ptr cfloat; octaves: cfloat;
                            noise_type = NOISE_DEFAULT): cfloat {...}{.cdecl,
    importc: "TCOD_noise_get_turbulence_ex", dynlib: LIB_NAME.}
proc noise_get(noise: PNoise; f: ptr cfloat): cfloat {...}{.cdecl, importc: "TCOD_noise_get",
    dynlib: LIB_NAME.}
proc noise_get_fbm(noise: PNoise; f: ptr cfloat; octaves: cfloat): cfloat {...}{.cdecl,
    importc: "TCOD_noise_get_fbm", dynlib: LIB_NAME.}
proc noise_get_turbulence(noise: PNoise; f: ptr cfloat; octaves: cfloat): cfloat {...}{.cdecl,
    importc: "TCOD_noise_get_turbulence", dynlib: LIB_NAME.}
proc noise_delete(noise: var PNoise) {...}{.raises: [], tags: [].}
proc line_init(xFrom, yFrom, xTo, yTo: int) {...}{.cdecl, importc: "TCOD_line_init",
                                        dynlib: LIB_NAME.}
proc line_step(xCur, yCur: ptr int): bool {...}{.cdecl, importc: "TCOD_line_step",
                                      dynlib: LIB_NAME.}
proc line(xFrom, yFrom, xTo, yTo: int; listener: PLineListener): bool {...}{.cdecl,
    importc: "TCOD_line", dynlib: LIB_NAME.}
proc line_init_mt(xFrom, yFrom, xTo, yTo, data: PBresenhamData) {...}{.cdecl,
    importc: "TCOD_line_init_mt", dynlib: LIB_NAME.}
proc line_step_mt(xCur, yCur: ptr int; data: PBresenhamData): bool {...}{.cdecl,
    importc: "TCOD_line_step_mt", dynlib: LIB_NAME.}
proc line_mt(xFrom, yFrom, xTo, yTo: int; listener: PLineListener; data: PBresenhamData): bool {...}{.
    cdecl, importc: "TCOD_line_mt", dynlib: LIB_NAME.}
proc tree_new(): PTree {...}{.cdecl, importc: "TCOD_tree_new", dynlib: LIB_NAME.}
proc tree_add_son(node, son: PTree) {...}{.cdecl, importc: "TCOD_tree_add_son",
                                  dynlib: LIB_NAME.}
proc bsp_new(): PBSP {...}{.cdecl, importc: "TCOD_bsp_new", dynlib: LIB_NAME.}
proc bsp_new_with_size(x, y, w, h: int): PBSP {...}{.cdecl,
    importc: "TCOD_bsp_new_with_size", dynlib: LIB_NAME.}
proc bsp_delete(node: PBSP) {...}{.cdecl, importc: "TCOD_bsp_delete", dynlib: LIB_NAME.}
proc bsp_left(node: PBSP): PBSP {...}{.cdecl, importc: "TCOD_bsp_left", dynlib: LIB_NAME.}
proc bsp_right(node: PBSP): PBSP {...}{.cdecl, importc: "TCOD_bsp_right", dynlib: LIB_NAME.}
proc bsp_father(node: PBSP): PBSP {...}{.cdecl, importc: "TCOD_bsp_father", dynlib: LIB_NAME.}
proc bsp_is_leaf(node: PBSP): bool {...}{.cdecl, importc: "TCOD_bsp_is_leaf",
                                 dynlib: LIB_NAME.}
proc bsp_traverse_pre_order(node: PBSP; listener: PBSPCallback;
                           userData: pointer = nil): bool {...}{.cdecl,
    importc: "TCOD_bsp_traverse_pre_order", dynlib: LIB_NAME.}
proc bsp_traverse_in_order(node: PBSP; listener: PBSPCallback;
                          userData: pointer = nil): bool {...}{.cdecl,
    importc: "TCOD_bsp_traverse_in_order", dynlib: LIB_NAME.}
proc bsp_traverse_post_order(node: PBSP; listener: PBSPCallback;
                            userData: pointer = nil): bool {...}{.cdecl,
    importc: "TCOD_bsp_traverse_post_order", dynlib: LIB_NAME.}
proc bsp_traverse_level_order(node: PBSP; listener: PBSPCallback;
                             userData: pointer = nil): bool {...}{.cdecl,
    importc: "TCOD_bsp_traverse_level_order", dynlib: LIB_NAME.}
proc bsp_traverse_inverted_level_order(node: PBSP; listener: PBSPCallback;
                                      userData: pointer = nil): bool {...}{.cdecl,
    importc: "TCOD_bsp_traverse_inverted_level_order", dynlib: LIB_NAME.}
proc bsp_contains(node: PBSP; x, y: int): bool {...}{.cdecl, importc: "TCOD_bsp_contains",
    dynlib: LIB_NAME.}
proc bsp_find_node(node: PBSP; x, y: int): PBSP {...}{.cdecl, importc: "TCOD_bsp_find_node",
    dynlib: LIB_NAME.}
proc bsp_resize(node: PBSP; x, y, w, h: int) {...}{.cdecl, importc: "TCOD_bsp_resize",
                                       dynlib: LIB_NAME.}
proc bsp_split_once(node: PBSP; horizontal: bool; position: int) {...}{.cdecl,
    importc: "TCOD_bsp_split_once", dynlib: LIB_NAME.}
proc bsp_split_recursive(node: PBSP; randomizer: PRandom;
                        nb, minHSize, minVSize: int; maxHRatio, maxVRatio: cfloat) {...}{.
    cdecl, importc: "TCOD_bsp_split_recursive", dynlib: LIB_NAME.}
proc bsp_remove_sons(node: PBSP) {...}{.cdecl, importc: "TCOD_bsp_remove_sons",
                                dynlib: LIB_NAME.}
proc map_new(width, height: int): PMap {...}{.cdecl, importc: "TCOD_map_new",
                                    dynlib: LIB_NAME.}
proc map_clear(map: PMap; transparent, walkable: bool) {...}{.cdecl,
    importc: "TCOD_map_clear", dynlib: LIB_NAME.}
proc map_copy(source, dest: PMap) {...}{.cdecl, importc: "TCOD_map_copy", dynlib: LIB_NAME.}
proc map_set_properties(map: PMap; x, y: int; is_transparent, is_walkable: bool) {...}{.cdecl,
    importc: "TCOD_map_set_properties", dynlib: LIB_NAME.}
proc map_delete(map: var PMap) {...}{.raises: [], tags: [].}
proc map_compute_fov(map: PMap; player_x, player_y: int; max_radius = 0;
                    light_walls = true; algo: TFOVAlgorithm = FOV_BASIC) {...}{.cdecl,
    importc: "TCOD_map_compute_fov", dynlib: LIB_NAME.}
proc map_is_in_fov(map: PMap; x, y: int): bool {...}{.cdecl, importc: "TCOD_map_is_in_fov",
    dynlib: LIB_NAME.}
proc map_set_in_fov(map: PMap; x, y: int; fov: bool) {...}{.cdecl,
    importc: "TCOD_map_set_in_fov", dynlib: LIB_NAME.}
proc map_is_transparent(map: PMap; x, y: int): bool {...}{.cdecl,
    importc: "TCOD_map_is_transparent", dynlib: LIB_NAME.}
proc map_is_walkable(map: PMap; x, y: int): bool {...}{.cdecl,
    importc: "TCOD_map_is_walkable", dynlib: LIB_NAME.}
proc map_get_width(map: PMap): cint {...}{.cdecl, importc: "TCOD_map_get_width",
                                  dynlib: LIB_NAME.}
proc map_get_height(map: PMap): cint {...}{.cdecl, importc: "TCOD_map_get_height",
                                   dynlib: LIB_NAME.}
proc map_get_nb_cells(map: PMap): cint {...}{.cdecl, importc: "TCOD_map_get_nb_cells",
                                     dynlib: LIB_NAME.}
proc path_new_using_map(map: PMap; diagonalCost = DEFAULT_DIAGONAL_COST): PPath {...}{.
    cdecl, importc: "TCOD_path_new_using_map", dynlib: LIB_NAME.}
proc path_new_using_function(map_width, map_height: int; pathfunc: PPathFunc;
                            user_data: pointer = nil;
                            diagonalCost = DEFAULT_DIAGONAL_COST): PPath {...}{.cdecl,
    importc: "TCOD_path_new_using_function", dynlib: LIB_NAME.}
proc path_compute(path: PPath; ox, oy, dx, dy: int): bool {...}{.cdecl,
    importc: "TCOD_path_compute", dynlib: LIB_NAME.}
proc path_walk(path: PPath; x, y: ptr int; recalculate_when_needed: bool): bool {...}{.cdecl,
    importc: "TCOD_path_walk", dynlib: LIB_NAME.}
proc path_is_empty(path: PPath): bool {...}{.cdecl, importc: "TCOD_path_is_empty",
                                    dynlib: LIB_NAME.}
proc path_size(path: PPath): cint {...}{.cdecl, importc: "TCOD_path_size", dynlib: LIB_NAME.}
proc path_reverse(path: PPath) {...}{.cdecl, importc: "TCOD_path_reverse", dynlib: LIB_NAME.}
proc path_get(path: PPath; index: int; x, y: ptr int) {...}{.cdecl, importc: "TCOD_path_get",
    dynlib: LIB_NAME.}
proc path_get_origin(path: PPath; x, y: ptr int) {...}{.cdecl,
    importc: "TCOD_path_get_origin", dynlib: LIB_NAME.}
proc path_get_destination(path: PPath; x, y: ptr int) {...}{.cdecl,
    importc: "TCOD_path_get_destination", dynlib: LIB_NAME.}
proc path_delete(path: var PPath) {...}{.raises: [], tags: [].}
proc dijkstra_new(map: PMap; diagonalCost = DEFAULT_DIAGONAL_COST): PDijkstra {...}{.cdecl,
    importc: "TCOD_dijkstra_new", dynlib: LIB_NAME.}
proc dijkstra_new_using_function(map_width, map_height: int; pathfunc: PPathFunc;
                                user_data: pointer = nil;
                                diagonalCost = DEFAULT_DIAGONAL_COST): PDijkstra {...}{.
    cdecl, importc: "TCOD_dijkstra_new_using_function", dynlib: LIB_NAME.}
proc dijkstra_compute(dijkstra: PDijkstra; root_x, root_y: int) {...}{.cdecl,
    importc: "TCOD_dijkstra_compute", dynlib: LIB_NAME.}
proc dijkstra_get_distance(dijkstra: PDijkstra; x, y: int): cfloat {...}{.cdecl,
    importc: "TCOD_dijkstra_get_distance", dynlib: LIB_NAME.}
proc dijkstra_path_set(dijkstra: PDijkstra; x, y: int): bool {...}{.cdecl,
    importc: "TCOD_dijkstra_path_set", dynlib: LIB_NAME.}
proc dijkstra_is_empty(path: PDijkstra): bool {...}{.cdecl,
    importc: "TCOD_dijkstra_is_empty", dynlib: LIB_NAME.}
proc dijkstra_size(path: PDijkstra): cint {...}{.cdecl, importc: "TCOD_dijkstra_size",
                                        dynlib: LIB_NAME.}
proc dijkstra_reverse(path: PDijkstra) {...}{.cdecl, importc: "TCOD_dijkstra_reverse",
                                      dynlib: LIB_NAME.}
proc dijkstra_get(path: PDijkstra; index: int; x, y: ptr int) {...}{.cdecl,
    importc: "TCOD_dijkstra_get", dynlib: LIB_NAME.}
proc dijkstra_path_walk(dijkstra: PDijkstra; x, y: ptr int): bool {...}{.cdecl,
    importc: "TCOD_dijkstra_path_walk", dynlib: LIB_NAME.}
proc dijkstra_delete(dijkstra: var PDijkstra) {...}{.raises: [], tags: [].}
proc heightmap_new(w, h: int): PHeightmap {...}{.cdecl, importc: "TCOD_heightmap_new",
                                       dynlib: LIB_NAME.}
proc heightmap_delete(hm: PHeightmap) {...}{.cdecl, importc: "TCOD_heightmap_delete",
                                     dynlib: LIB_NAME.}
proc heightmap_get_value(hm: PHeightmap; x, y: int): cfloat {...}{.cdecl,
    importc: "TCOD_heightmap_get_value", dynlib: LIB_NAME.}
proc heightmap_get_interpolated_value(hm: PHeightmap; x, y: cfloat): cfloat {...}{.cdecl,
    importc: "TCOD_heightmap_get_interpolated_value", dynlib: LIB_NAME.}
proc heightmap_set_value(hm: PHeightmap; x, y: int; value: cfloat) {...}{.cdecl,
    importc: "TCOD_heightmap_set_value", dynlib: LIB_NAME.}
proc heightmap_get_slope(hm: PHeightmap; x, y: int): cfloat {...}{.cdecl,
    importc: "TCOD_heightmap_get_slope", dynlib: LIB_NAME.}
proc heightmap_get_normal(hm: PHeightmap; x, y: cfloat; n: ptr array[0 .. 2, cfloat];
                         waterLevel: cfloat) {...}{.cdecl,
    importc: "TCOD_heightmap_get_normal", dynlib: LIB_NAME.}
proc heightmap_count_cells(hm: PHeightmap; min, max: cfloat): cint {...}{.cdecl,
    importc: "TCOD_heightmap_count_cells", dynlib: LIB_NAME.}
proc heightmap_has_land_on_border(hm: PHeightmap; waterLevel: cfloat): bool {...}{.cdecl,
    importc: "TCOD_heightmap_has_land_on_border", dynlib: LIB_NAME.}
proc heightmap_get_minmax(hm: PHeightmap; min, max: ptr cfloat) {...}{.cdecl,
    importc: "TCOD_heightmap_get_minmax", dynlib: LIB_NAME.}
proc heightmap_copy(hm_source, hm_dest: PHeightmap) {...}{.cdecl,
    importc: "TCOD_heightmap_copy", dynlib: LIB_NAME.}
proc heightmap_add(hm: PHeightmap; value: cfloat) {...}{.cdecl,
    importc: "TCOD_heightmap_add", dynlib: LIB_NAME.}
proc heightmap_scale(hm: PHeightmap; value: cfloat) {...}{.cdecl,
    importc: "TCOD_heightmap_scale", dynlib: LIB_NAME.}
proc heightmap_clamp(hm: PHeightmap; min, max: cfloat) {...}{.cdecl,
    importc: "TCOD_heightmap_clamp", dynlib: LIB_NAME.}
proc heightmap_normalize(hm: PHeightmap; min = 0.0'f32; max = 1.0'f32) {...}{.cdecl,
    importc: "TCOD_heightmap_normalize", dynlib: LIB_NAME.}
proc heightmap_clear(hm: PHeightmap) {...}{.cdecl, importc: "TCOD_heightmap_clear",
                                    dynlib: LIB_NAME.}
proc heightmap_lerp_hm(hm1, hm2, hmres: PHeightmap; coef: cfloat) {...}{.cdecl,
    importc: "TCOD_heightmap_lerp_hm", dynlib: LIB_NAME.}
proc heightmap_add_hm(hm1, hm2, hmres: PHeightmap) {...}{.cdecl,
    importc: "TCOD_heightmap_add_hm", dynlib: LIB_NAME.}
proc heightmap_multiply_hm(hm1, hm2, hmres: PHeightmap) {...}{.cdecl,
    importc: "TCOD_heightmap_multiply_hm", dynlib: LIB_NAME.}
proc heightmap_add_hill(hm: PHeightmap; hx, hy, hradius, hheight: cfloat) {...}{.cdecl,
    importc: "TCOD_heightmap_add_hill", dynlib: LIB_NAME.}
proc heightmap_dig_hill(hm: PHeightmap; hx, hy, hradius, hheight: cfloat) {...}{.cdecl,
    importc: "TCOD_heightmap_dig_hill", dynlib: LIB_NAME.}
proc heightmap_dig_bezier(hm: PHeightmap; px, py: array[0 .. 3, int];
                         startRadius, startDepth, endRadius, endDepth: cfloat) {...}{.
    cdecl, importc: "TCOD_heightmap_dig_bezier", dynlib: LIB_NAME.}
proc heightmap_rain_erosion(hm: PHeightmap; nbDrops: int;
                           erosionCoef, sedimentationCoef: cfloat;
                           rnd: PRandom = nil) {...}{.cdecl,
    importc: "TCOD_heightmap_rain_erosion", dynlib: LIB_NAME.}
proc heightmap_kernel_transform(hm: PHeightmap; kernelsize: int; dx, dy: ptr int;
                               weight: ptr cfloat; minLevel, maxLevel: cfloat) {...}{.
    cdecl, importc: "TCOD_heightmap_kernel_transform", dynlib: LIB_NAME.}
proc heightmap_add_voronoi(hm: PHeightmap; nbPoints, nbCoef: int; coef: ptr cfloat;
                          rnd: PRandom = nil) {...}{.cdecl,
    importc: "TCOD_heightmap_add_voronoi", dynlib: LIB_NAME.}
proc heightmap_add_fbm(hm: PHeightmap; noise: PNoise;
                      mulx, muly, addx, addy, octaves, delta, scale: cfloat) {...}{.cdecl,
    importc: "TCOD_heightmap_add_fbm", dynlib: LIB_NAME.}
proc heightmap_scale_fbm(hm: PHeightmap; noise: PNoise;
                        mulx, muly, addx, addy, octaves, delta, scale: cfloat) {...}{.cdecl,
    importc: "TCOD_heightmap_scale_fbm", dynlib: LIB_NAME.}
proc heightmap_islandify(hm: PHeightmap; seaLevel: cfloat; rnd: PRandom = nil) {...}{.cdecl,
    importc: "TCOD_heightmap_islandify", dynlib: LIB_NAME.}
proc lex_new_intern(): PLex {...}{.cdecl, importc: "TCOD_lex_new_intern", dynlib: LIB_NAME.}
proc lex_new(symbols, keywords: cstringArray; simpleComment, commentStart,
    commentStop, javadocCommentStart, stringDelim: cstring; flags: cint): PLex {...}{.cdecl,
    importc: "TCOD_lex_new", dynlib: LIB_NAME.}
proc lex_delete(lex: PLex) {...}{.cdecl, importc: "TCOD_lex_delete", dynlib: LIB_NAME.}
proc lex_set_data_buffer(lex: PLex; dat: cstring) {...}{.cdecl,
    importc: "TCOD_lex_set_data_buffer", dynlib: LIB_NAME.}
proc lex_set_data_file(lex: PLex; filename: cstring): bool {...}{.cdecl,
    importc: "TCOD_lex_set_data_file", dynlib: LIB_NAME.}
proc lex_parse(lex: PLex): cint {...}{.cdecl, importc: "TCOD_lex_parse", dynlib: LIB_NAME.}
proc lex_parse_until_token_type(lex: PLex; token_type: cint): cint {...}{.cdecl,
    importc: "TCOD_lex_parse_until_token_type", dynlib: LIB_NAME.}
proc lex_parse_until_token_value(lex: PLex; token_value: cstring): cint {...}{.cdecl,
    importc: "TCOD_lex_parse_until_token_value", dynlib: LIB_NAME.}
proc lex_expect_token_type(lex: PLex; token_type: cint): bool {...}{.cdecl,
    importc: "TCOD_lex_expect_token_type", dynlib: LIB_NAME.}
proc lex_expect_token_value(lex: PLex; token_type: cint; token_value: cstring): bool {...}{.
    cdecl, importc: "TCOD_lex_expect_token_value", dynlib: LIB_NAME.}
proc lex_savepoint(lex, savept: PLex) {...}{.cdecl, importc: "TCOD_lex_savepoint",
                                    dynlib: LIB_NAME.}
proc lex_restore(lex, savept: PLex) {...}{.cdecl, importc: "TCOD_lex_restore",
                                  dynlib: LIB_NAME.}
proc lex_get_last_javadoc(lex: PLex): cstring {...}{.cdecl,
    importc: "TCOD_lex_get_last_javadoc", dynlib: LIB_NAME.}
proc lex_get_token_name(token_type: cint): cstring {...}{.cdecl,
    importc: "TCOD_lex_get_token_name", dynlib: LIB_NAME.}
proc lex_get_last_error(): cstring {...}{.cdecl, importc: "TCOD_lex_get_last_error",
                                  dynlib: LIB_NAME.}
proc lex_hextoint(c: char): cint {...}{.cdecl, importc: "TCOD_lex_hextoint",
                               dynlib: LIB_NAME.}
proc parser_error(msg: string; args: varargs[string, `$`]) {...}{.
    raises: [ValueError, Exception], tags: [RootEffect].}
proc struct_get_name(def: PParserStruct): string {...}{.inline, raises: [], tags: [].}
proc struct_add_property(def: PParserStruct; name: string; value_type: TValueType;
                        mandatory: bool) {...}{.inline, raises: [], tags: [].}
add a property to an entity definition
proc struct_add_list_property(def: PParserStruct; name: string;
                             value_type: TValueType; mandatory: bool) {...}{.inline,
    raises: [], tags: [].}
add a list property to an entity definition
proc struct_add_value_list(def: PParserStruct; name: string; value_list: seq[string];
                          mandatory: bool) {...}{.raises: [], tags: [].}
add a value-list property to an entity definition
proc struct_add_value_list_sized(def: PParserStruct; name: string;
                                value_list: seq[string]; size: int; mandatory: bool) {...}{.
    inline, raises: [], tags: [].}
do not use, use struct_add_value_list instead
proc struct_add_flag(def: PParserStruct; propname: string) {...}{.inline, raises: [],
    tags: [].}

add a flag (simplified bool value) to an entity definition

a flag cannot be mandatory. if present => true, if omitted => false

proc struct_add_structure(def: PParserStruct; sub_structure: PParserStruct) {...}{.inline,
    raises: [], tags: [].}
add a sub-entity to an entity definition
proc struct_is_mandatory(def: PParserStruct; propname: string): bool {...}{.raises: [],
    tags: [].}
proc struct_get_type(def: PParserStruct; propname: string): TValueType {...}{.raises: [],
    tags: [].}

returns the type of given property

TYPE_NONE if the property does not exist

proc parse_bool_value(): TValue {...}{.raises: [ValueError, Exception], tags: [RootEffect].}
proc parse_char_value(): TValue {...}{.raises: [ValueError, Exception], tags: [RootEffect].}
proc parse_integer_value(): TValue {...}{.raises: [ValueError, Exception],
                                  tags: [RootEffect].}
proc parse_float_value(): TValue {...}{.raises: [ValueError, Exception], tags: [RootEffect].}
proc parse_string_value(): TValue {...}{.raises: [ValueError, Exception],
                                 tags: [RootEffect].}
proc parse_color_value(): TValue {...}{.raises: [ValueError, Exception], tags: [RootEffect].}
proc parse_dice_value(): TValue {...}{.raises: [ValueError, Exception], tags: [RootEffect].}
dice format : [<m>(x|*)]<n>(D|d)<f>[(+|-)<a>]
proc parse_value_list_value(def: PParserStruct; listnum: int): TValue {...}{.
    raises: [ValueError, Exception], tags: [RootEffect].}
proc parse_property_value(parser: PParser; def: PParserStruct; propname: string;
                         list: bool): TValue {...}{.raises: [ValueError, Exception],
    tags: [RootEffect].}
proc parser_new_struct(parser: PParser; name: string): PParserStruct {...}{.raises: [],
    tags: [].}
proc parser_parse_entity(parser: PParser; def: PParserStruct): bool {...}{.
    raises: [ValueError, Exception], tags: [RootEffect].}
proc parser_new(): PParser {...}{.raises: [], tags: [].}
proc parser_new_custom_type(parser: PParser; custom_type_parser: PParserCustom): TValueType {...}{.
    raises: [], tags: [].}
proc parser_delete(parser: PParser) {...}{.inline, raises: [], tags: [].}
proc parser_run(parser: PParser; filename: string; plistener: PParserListener = nil) {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
triggers callbacks in the listener for each event during parsing
proc parser_get_bool_property(parser: PParser; name: string): bool {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_char_property(parser: PParser; name: string): char {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_int_property(parser: PParser; name: string): cint {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_float_property(parser: PParser; name: string): cfloat {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_string_property(parser: PParser; name: string): string {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_color_property(parser: PParser; name: string): TColor {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_dice_property(parser: PParser; name: string): TDice {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_dice_property_py(parser: PParser; name: string; dice: var TDice) {...}{.
    inline, raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_custom_property(parser: PParser; name: string): pointer {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_list_property(parser: PParser; name: string; value_type: TValueType): seq[
    TValue] {...}{.raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_list_bool_property(parser: PParser; name: string): seq[bool] {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_list_char_property(parser: PParser; name: string): seq[char] {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_list_int_property(parser: PParser; name: string): seq[int] {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_list_float_property(parser: PParser; name: string): seq[float] {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_list_string_property(parser: PParser; name: string): seq[string] {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_list_color_property(parser: PParser; name: string): seq[TColor] {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc parser_get_list_dice_property(parser: PParser; name: string): seq[TDice] {...}{.
    raises: [Exception, ValueError], tags: [RootEffect].}
proc zip_new(): PZip {...}{.cdecl, importc: "TCOD_zip_new", dynlib: LIB_NAME.}
proc zip_delete(zip: var PZip) {...}{.raises: [], tags: [].}
proc zip_put_char(zip: PZip; val: char) {...}{.cdecl, importc: "TCOD_zip_put_char",
                                     dynlib: LIB_NAME.}
proc zip_put_int(zip: PZip; val: int) {...}{.cdecl, importc: "TCOD_zip_put_int",
                                   dynlib: LIB_NAME.}
proc zip_put_float(zip: PZip; val: cfloat) {...}{.cdecl, importc: "TCOD_zip_put_float",
                                        dynlib: LIB_NAME.}
proc zip_put_string(zip: PZip; val: cstring) {...}{.cdecl, importc: "TCOD_zip_put_string",
    dynlib: LIB_NAME.}
proc zip_put_color(zip: PZip; val: TColor) {...}{.cdecl, importc: "TCOD_zip_put_color",
                                        dynlib: LIB_NAME.}
proc zip_put_image(zip: PZip; val: PImage) {...}{.cdecl, importc: "TCOD_zip_put_image",
                                        dynlib: LIB_NAME.}
proc zip_put_console(zip: PZip; val: PConsole) {...}{.cdecl,
    importc: "TCOD_zip_put_console", dynlib: LIB_NAME.}
proc zip_put_data(zip: PZip; nbBytes: int; data: pointer) {...}{.cdecl,
    importc: "TCOD_zip_put_data", dynlib: LIB_NAME.}
proc zip_get_current_bytes(zip: PZip): cuint {...}{.cdecl,
    importc: "TCOD_zip_get_current_bytes", dynlib: LIB_NAME.}
proc zip_save_to_file(zip: PZip; filename: cstring): cint {...}{.cdecl,
    importc: "TCOD_zip_save_to_file", dynlib: LIB_NAME.}
proc zip_load_from_file(zip: PZip; filename: cstring): cint {...}{.cdecl,
    importc: "TCOD_zip_load_from_file", dynlib: LIB_NAME.}
proc zip_get_char(zip: PZip): char {...}{.cdecl, importc: "TCOD_zip_get_char",
                                 dynlib: LIB_NAME.}
proc zip_get_int(zip: PZip): cint {...}{.cdecl, importc: "TCOD_zip_get_int",
                                dynlib: LIB_NAME.}
proc zip_get_float(zip: PZip): cfloat {...}{.cdecl, importc: "TCOD_zip_get_float",
                                    dynlib: LIB_NAME.}
proc zip_get_string(zip: PZip): cstring {...}{.cdecl, importc: "TCOD_zip_get_string",
                                      dynlib: LIB_NAME.}
proc zip_get_color(zip: PZip): TColor {...}{.cdecl, importc: "TCOD_zip_get_color",
                                    dynlib: LIB_NAME.}
proc zip_get_image(zip: PZip): PImage {...}{.cdecl, importc: "TCOD_zip_get_image",
                                    dynlib: LIB_NAME.}
proc zip_get_console(zip: PZip): PConsole {...}{.cdecl, importc: "TCOD_zip_get_console",
                                        dynlib: LIB_NAME.}
proc zip_get_data(zip: PZip; nbBytes: int; data: pointer): cint {...}{.cdecl,
    importc: "TCOD_zip_get_data", dynlib: LIB_NAME.}
proc zip_get_remaining_bytes(zip: PZip): cuint {...}{.cdecl,
    importc: "TCOD_zip_get_remaining_bytes", dynlib: LIB_NAME.}
proc zip_skip_bytes(zip: PZip; nbBytes: cuint) {...}{.cdecl,
    importc: "TCOD_zip_skip_bytes", dynlib: LIB_NAME.}
proc namegen_parse(filename: cstring; random: PRandom = nil) {...}{.cdecl,
    importc: "TCOD_namegen_parse", dynlib: LIB_NAME.}
proc namegen_generate(name: cstring; allocate = false): cstring {...}{.cdecl,
    importc: "TCOD_namegen_generate", dynlib: LIB_NAME.}
proc namegen_generate_custom(name, rule: cstring; allocate = false): cstring {...}{.cdecl,
    importc: "TCOD_namegen_generate_custom", dynlib: LIB_NAME.}
proc namegen_get_sets(): seq[string] {...}{.inline, raises: [], tags: [].}
proc namegen_destroy() {...}{.cdecl, importc: "TCOD_namegen_destroy", dynlib: LIB_NAME.}
proc text_init(x, y, w, h, max_chars: int): PText {...}{.cdecl, importc: "TCOD_text_init",
    dynlib: LIB_NAME.}
proc text_set_properties(txt: PText; cursor_char, blink_interval: int;
                        prompt: cstring; tab_size: int) {...}{.cdecl,
    importc: "TCOD_text_set_properties", dynlib: LIB_NAME.}
proc text_set_colors(txt: PText; fore, back: TColor; back_transparency: cfloat) {...}{.cdecl,
    importc: "TCOD_text_set_colors", dynlib: LIB_NAME.}
proc text_update(txt: PText; key: TKey): bool {...}{.cdecl, importc: "TCOD_text_update",
    dynlib: LIB_NAME.}
proc text_render(txt: PText; con: PConsole) {...}{.cdecl, importc: "TCOD_text_render",
    dynlib: LIB_NAME.}
proc text_get(txt: PText): cstring {...}{.cdecl, importc: "TCOD_text_get", dynlib: LIB_NAME.}
proc text_reset(txt: PText) {...}{.cdecl, importc: "TCOD_text_reset", dynlib: LIB_NAME.}
proc text_delete(txt: var PText) {...}{.raises: [], tags: [].}

Templates

template color_RGB(r, g, b: int): TColor
template floatArrayToPtr(f: var openArray[cfloat]): ptr cfloat
template FOV_Permissive(x: untyped): typed