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

Color {...}{.bycopy.} = tuple[r, g, b: uint8]

An RGB color tuple.

Keycode {...}{.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, K_TEXT

Key {...}{.bycopy.} = object vk*: Keycode ## key code c*: char ## character if vk == K_CHAR else 0 text*: array[KEY_TEXT_SIZE, char] ## \ ## text if vk == K_TEXT else text[0] == '\0' pressed*: bool ## does this correspond to a key press or key release event ? lalt*, lctrl*, lmeta*, ralt*, rctrl*, rmeta*, shift*: bool

Key data : special code or character or text.

Colctrl {...}{.size: 4.} = enum COLCTRL_1 = 1, COLCTRL_2, COLCTRL_3, COLCTRL_4, COLCTRL_5, COLCTRL_FORE_RGB, COLCTRL_BACK_RGB, COLCTRL_STOP

BkgndFlag {...}{.size: 4.} = enum BKGND_NONE, BKGND_SET, BKGND_MULTIPLY, BKGND_LIGHTEN, BKGND_DARKEN, BKGND_SCREEN, BKGND_COLOR_DODGE, BKGND_COLOR_BURN, BKGND_ADD, BKGND_ADDA, BKGND_BURN, BKGND_OVERLAY, BKGND_ALPH, BKGND_DEFAULT

Renderer {...}{.size: 4.} = enum RENDERER_GLSL, ## An OpenGL implementation using a shader. RENDERER_OPENGL, ## \ ## An OpenGL implementation without a shader. ## ## Performs worse than `RENDERER_GLSL` without many benefits. ## RENDERER_SDL, ## \ ## A software based renderer. ## ## The font file is loaded into RAM ## instead of VRAM in this implementation. ## NB_RENDERERS

The available renderers.

Alignment {...}{.size: 4.} = enum LEFT, RIGHT, CENTER

Print justification options.

Map = pointer

FovAlgorithm {...}{.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

Image = pointer

List = pointer

Lex = ptr LexObj

LexObj {...}{.bycopy.} = object fileLine*: cint tokenType*: cint tokenIntVal*: cint tokenIdx*: cint tokenFloatVal*: cfloat tok*: cstring toklen*: cint lastStringDelim*: char pos*: cstring buf*: cstring filename*: cstring lastJavadocComment*: cstring nbSymbols*: cint ## private stuff from here nbKeywords*: cint flags*: cint symbols*: array[LEX_MAX_SYMBOLS, array[LEX_SYMBOL_SIZE, char]] keywords*: array[LEX_MAX_KEYWORDS, array[LEX_KEYWORD_SIZE, char]] simpleCmt*: cstring cmtStart*: cstring cmtStop*: cstring javadocCmtStart*: cstring stringDelim*: cstring javadocRead*: bool allocBuf*: bool savept*: bool ## is this object a savepoint (no free in destructor)

Random = pointer

Dice {...}{.bycopy.} = object nbRolls*: cint nbFaces*: cint multiplier*: cfloat addsub*: cfloat

Dice roll.

RandomAlgo {...}{.size: 4.} = enum RNG_MT, RNG_CMWC

Distribution {...}{.size: 4.} = enum DISTRIBUTION_LINEAR, DISTRIBUTION_GAUSSIAN, DISTRIBUTION_GAUSSIAN_RANGE, DISTRIBUTION_GAUSSIAN_INVERSE, DISTRIBUTION_GAUSSIAN_RANGE_INVERSE

Mouse {...}{.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 lbuttonPressed*: bool ## left button pressed event rbuttonPressed*: bool ## right button pressed event mbuttonPressed*: bool ## middle button pressed event wheelUp*: bool ## wheel up event wheelDown*: bool ## wheel down event

Mouse data.

Noise = pointer

NoiseKind {...}{.size: 4.} = enum NOISE_DEFAULT = 0, NOISE_PERLIN = 1, NOISE_SIMPLEX = 2, NOISE_WAVELET = 4

Tree = ptr TreeObj

TreeObj {...}{.bycopy.} = object next*: Tree father*: Tree sons*: Tree

LineListener = proc (x, y: cint): bool {...}{.cdecl.}

A callback to be passed to line

The points given to the callback include both the starting and ending positions.

As long as this callback returns true it will be called with the next x,y point on the line.

BresenhamData {...}{.bycopy.} = object stepx*, stepy*: cint e*: cint deltax*, deltay*: cint origx*, origy*: cint destx*, desty*: cint

A struct used for computing a bresenham line.

Bsp = ptr BspObj

BspObj {...}{.bycopy.} = object tree*: TreeObj ## pseudo oop : bsp inherit tree x*, y*, w*, h*: cint ## node position & size position*: cint ## position of splitting level*: uint8 ## level in the tree horizontal*: bool ## horizontal splitting ?

BspCallback = proc (node: Bsp; userData: pointer): bool {...}{.cdecl.}

Heightmap = ptr HeightmapObj

HeightmapObj {...}{.bycopy.} = object w*, h*: cint values*: ptr cfloat

Namegen = pointer

The generator type.

ValueKind {...}{.size: 4.} = enum KIND_NONE, KIND_BOOL, KIND_CHAR, KIND_INT, KIND_FLOAT, KIND_STRING, KIND_COLOR, KIND_DICE, KIND_VALUELIST00, KIND_VALUELIST01, KIND_VALUELIST02, KIND_VALUELIST03, KIND_VALUELIST04, KIND_VALUELIST05, KIND_VALUELIST06, KIND_VALUELIST07, KIND_VALUELIST08, KIND_VALUELIST09, KIND_VALUELIST10, KIND_VALUELIST11, KIND_VALUELIST12, KIND_VALUELIST13, KIND_VALUELIST14, KIND_VALUELIST15, KIND_CUSTOM00, KIND_CUSTOM01, KIND_CUSTOM02, KIND_CUSTOM03, KIND_CUSTOM04, KIND_CUSTOM05, KIND_CUSTOM06, KIND_CUSTOM07, KIND_CUSTOM08, KIND_CUSTOM09, KIND_CUSTOM10, KIND_CUSTOM11, KIND_CUSTOM12, KIND_CUSTOM13, KIND_CUSTOM14, KIND_CUSTOM15, KIND_LIST = 1024

Generic kind.

Value {...}{.bycopy, union.} = object b*: bool c*: char i*: int32 f*: cfloat s*: cstring col*: Color dice*: Dice list*: List custom*: pointer

Generic value.

ParserStruct = pointer

Parser structures.

ParserListener = ptr ParserListenerObj

ParserListenerObj {...}{.bycopy.} = object newStruct*: proc (str: ParserStruct; name: cstring): bool {...}{.cdecl.} newFlag*: proc (name: cstring): bool {...}{.cdecl.} newProperty*: proc (propname: cstring; kind: ValueKind; value: Value): bool {...}{.cdecl.} endStruct*: proc (str: ParserStruct; name: cstring): bool {...}{.cdecl.} error*: proc (msg: cstring) {...}{.cdecl.}

Parser listener.

ParserCustom = proc (lex: ptr Lex; listener: ParserListener; str: ParserStruct; propname: cstring): Value {...}{.cdecl.}

A custom type parser.

Parser = pointer

The parser.

StructInt {...}{.bycopy.} = object name*: cstring ## entity type name flags*: List ## list of flags props*: List ## list of properties (name, type, mandatory) lists*: List ## list of value lists structs*: List ## list of sub-structures

Parser structures.

ParserInt {...}{.bycopy.} = object structs*: List ## list of structures customs*: array[16, ParserCustom] ## list of custom type parsers fatal*: bool ## fatal error occurred props*: List ## list of properties if default listener is used

The parser.

PathProc = proc (xFrom, yFrom, xTo, yTo: cint; userData: pointer): cfloat {...}{.cdecl.}

Path = pointer

Dijkstra = pointer

Event {...}{.size: 4.} = enum EVENT_NONE = 0, EVENT_KEY_PRESS = 1, EVENT_KEY_RELEASE = 2, EVENT_KEY = 1 or 2, EVENT_MOUSE_MOVE = 4, EVENT_MOUSE_PRESS = 8, EVENT_MOUSE_RELEASE = 16, EVENT_MOUSE = 12 or 16, EVENT_FINGER_MOVE = 32, EVENT_FINGER_PRESS = 64, EVENT_FINGER_RELEASE = 128, EVENT_FINGER = 96 or 128, EVENT_ANY = 31 or 224

Thread = pointer

Semaphore = pointer

Mutex = pointer

Cond = pointer

Library = pointer

dynamic library

SDL_Renderer = proc (sdlRenderer: pointer) {...}{.cdecl.}

SDL renderer callback

Text = pointer

Zip = pointer

Vars

COLORS: array[COLOR_NB, array[COLOR_LEVELS, Color]]: Color array
BLACK: Color
DARKEST_GREY: Color
DARKER_GREY: Color
DARK_GREY: Color
GREY: Color
LIGHT_GREY: Color
LIGHTER_GREY: Color
LIGHTEST_GREY: Color
DARKEST_GRAY: Color
DARKER_GRAY: Color
DARK_GRAY: Color
GRAY: Color
LIGHT_GRAY: Color
LIGHTER_GRAY: Color
LIGHTEST_GRAY: Color
WHITE: Color
DARKEST_SEPIA: Color
DARKER_SEPIA: Color
DARK_SEPIA: Color
SEPIA: Color
LIGHT_SEPIA: Color
LIGHTER_SEPIA: Color
LIGHTEST_SEPIA: Color
RED: Color
FLAME: Color
ORANGE: Color
AMBER: Color
YELLOW: Color
LIME: Color
CHARTREUSE: Color
GREEN: Color
SEA: Color
TURQUOISE: Color
CYAN: Color
SKY: Color
AZURE: Color
BLUE: Color
HAN: Color
VIOLET: Color
PURPLE: Color
FUCHSIA: Color
MAGENTA: Color
PINK: Color
CRIMSON: Color
DARK_RED: Color
DARK_FLAME: Color
DARK_ORANGE: Color
DARK_AMBER: Color
DARK_YELLOW: Color
DARK_LIME: Color
DARK_CHARTREUSE: Color
DARK_GREEN: Color
DARK_SEA: Color
DARK_TURQUOISE: Color
DARK_CYAN: Color
DARK_SKY: Color
DARK_AZURE: Color
DARK_BLUE: Color
DARK_HAN: Color
DARK_VIOLET: Color
DARK_PURPLE: Color
DARK_FUCHSIA: Color
DARK_MAGENTA: Color
DARK_PINK: Color
DARK_CRIMSON: Color
DARKER_RED: Color
DARKER_FLAME: Color
DARKER_ORANGE: Color
DARKER_AMBER: Color
DARKER_YELLOW: Color
DARKER_LIME: Color
DARKER_CHARTREUSE: Color
DARKER_GREEN: Color
DARKER_SEA: Color
DARKER_TURQUOISE: Color
DARKER_CYAN: Color
DARKER_SKY: Color
DARKER_AZURE: Color
DARKER_BLUE: Color
DARKER_HAN: Color
DARKER_VIOLET: Color
DARKER_PURPLE: Color
DARKER_FUCHSIA: Color
DARKER_MAGENTA: Color
DARKER_PINK: Color
DARKER_CRIMSON: Color
DARKEST_RED: Color
DARKEST_FLAME: Color
DARKEST_ORANGE: Color
DARKEST_AMBER: Color
DARKEST_YELLOW: Color
DARKEST_LIME: Color
DARKEST_CHARTREUSE: Color
DARKEST_GREEN: Color
DARKEST_SEA: Color
DARKEST_TURQUOISE: Color
DARKEST_CYAN: Color
DARKEST_SKY: Color
DARKEST_AZURE: Color
DARKEST_BLUE: Color
DARKEST_HAN: Color
DARKEST_VIOLET: Color
DARKEST_PURPLE: Color
DARKEST_FUCHSIA: Color
DARKEST_MAGENTA: Color
DARKEST_PINK: Color
DARKEST_CRIMSON: Color
LIGHT_RED: Color
LIGHT_FLAME: Color
LIGHT_ORANGE: Color
LIGHT_AMBER: Color
LIGHT_YELLOW: Color
LIGHT_LIME: Color
LIGHT_CHARTREUSE: Color
LIGHT_GREEN: Color
LIGHT_SEA: Color
LIGHT_TURQUOISE: Color
LIGHT_CYAN: Color
LIGHT_SKY: Color
LIGHT_AZURE: Color
LIGHT_BLUE: Color
LIGHT_HAN: Color
LIGHT_VIOLET: Color
LIGHT_PURPLE: Color
LIGHT_FUCHSIA: Color
LIGHT_MAGENTA: Color
LIGHT_PINK: Color
LIGHT_CRIMSON: Color
LIGHTER_RED: Color
LIGHTER_FLAME: Color
LIGHTER_ORANGE: Color
LIGHTER_AMBER: Color
LIGHTER_YELLOW: Color
LIGHTER_LIME: Color
LIGHTER_CHARTREUSE: Color
LIGHTER_GREEN: Color
LIGHTER_SEA: Color
LIGHTER_TURQUOISE: Color
LIGHTER_CYAN: Color
LIGHTER_SKY: Color
LIGHTER_AZURE: Color
LIGHTER_BLUE: Color
LIGHTER_HAN: Color
LIGHTER_VIOLET: Color
LIGHTER_PURPLE: Color
LIGHTER_FUCHSIA: Color
LIGHTER_MAGENTA: Color
LIGHTER_PINK: Color
LIGHTER_CRIMSON: Color
LIGHTEST_RED: Color
LIGHTEST_FLAME: Color
LIGHTEST_ORANGE: Color
LIGHTEST_AMBER: Color
LIGHTEST_YELLOW: Color
LIGHTEST_LIME: Color
LIGHTEST_CHARTREUSE: Color
LIGHTEST_GREEN: Color
LIGHTEST_SEA: Color
LIGHTEST_TURQUOISE: Color
LIGHTEST_CYAN: Color
LIGHTEST_SKY: Color
LIGHTEST_AZURE: Color
LIGHTEST_BLUE: Color
LIGHTEST_HAN: Color
LIGHTEST_VIOLET: Color
LIGHTEST_PURPLE: Color
LIGHTEST_FUCHSIA: Color
LIGHTEST_MAGENTA: Color
LIGHTEST_PINK: Color
LIGHTEST_CRIMSON: Color
DESATURATED_RED: Color
DESATURATED_FLAME: Color
DESATURATED_ORANGE: Color
DESATURATED_AMBER: Color
DESATURATED_YELLOW: Color
DESATURATED_LIME: Color
DESATURATED_CHARTREUSE: Color
DESATURATED_GREEN: Color
DESATURATED_SEA: Color
DESATURATED_TURQUOISE: Color
DESATURATED_CYAN: Color
DESATURATED_SKY: Color
DESATURATED_AZURE: Color
DESATURATED_BLUE: Color
DESATURATED_HAN: Color
DESATURATED_VIOLET: Color
DESATURATED_PURPLE: Color
DESATURATED_FUCHSIA: Color
DESATURATED_MAGENTA: Color
DESATURATED_PINK: Color
DESATURATED_CRIMSON: Color
BRASS: Color
COPPER: Color
GOLD: Color
SILVER: Color
CELADON: Color
PEACH: Color

Consts

NO_UNICODE = false

Disable Unicode support

NO_OPENGL = false

Disable OpenGL support

LIB_NAME = "libtcod.so(|.0.0.0)"

HEXVERSION = 0x00010700

STRVERSION = "1.7.0"

TECHVERSION = 0x01070000

STRVERSIONNAME = "libtcod 1.7.0"

WRAPPERVERSION = "0.99"

COLOR_RED: cint = 0

COLOR_FLAME: cint = 1

COLOR_ORANGE: cint = 2

COLOR_AMBER: cint = 3

COLOR_YELLOW: cint = 4

COLOR_LIME: cint = 5

COLOR_CHARTREUSE: cint = 6

COLOR_GREEN: cint = 7

COLOR_SEA: cint = 8

COLOR_TURQUOISE: cint = 9

COLOR_CYAN: cint = 10

COLOR_SKY: cint = 11

COLOR_AZURE: cint = 12

COLOR_BLUE: cint = 13

COLOR_HAN: cint = 14

COLOR_VIOLET: cint = 15

COLOR_PURPLE: cint = 16

COLOR_FUCHSIA: cint = 17

COLOR_MAGENTA: cint = 18

COLOR_PINK: cint = 19

COLOR_CRIMSON: cint = 20

COLOR_NB: cint = 21

COLOR_DESATURATED: cint = 0

COLOR_LIGHTEST: cint = 1

COLOR_LIGHTER: cint = 2

COLOR_LIGHT: cint = 3

COLOR_NORMAL: cint = 4

COLOR_DARK: cint = 5

COLOR_DARKER: cint = 6

COLOR_DARKEST: cint = 7

COLOR_LEVELS: cint = 8

KEY_TEXT_SIZE: cint = 32

CHAR_HLINE: cint = 196

CHAR_VLINE: cint = 179

CHAR_NE: cint = 191

CHAR_NW: cint = 218

CHAR_SE: cint = 217

CHAR_SW: cint = 192

CHAR_TEEW: cint = 180

CHAR_TEEE: cint = 195

CHAR_TEEN: cint = 193

CHAR_TEES: cint = 194

CHAR_CROSS: cint = 197

CHAR_DHLINE: cint = 205

CHAR_DVLINE: cint = 186

CHAR_DNE: cint = 187

CHAR_DNW: cint = 201

CHAR_DSE: cint = 188

CHAR_DSW: cint = 200

CHAR_DTEEW: cint = 185

CHAR_DTEEE: cint = 204

CHAR_DTEEN: cint = 202

CHAR_DTEES: cint = 203

CHAR_DCROSS: cint = 206

CHAR_BLOCK1: cint = 176

CHAR_BLOCK2: cint = 177

CHAR_BLOCK3: cint = 178

CHAR_ARROW_N: cint = 24

CHAR_ARROW_S: cint = 25

CHAR_ARROW_E: cint = 26

CHAR_ARROW_W: cint = 27

CHAR_ARROW2_N: cint = 30

CHAR_ARROW2_S: cint = 31

CHAR_ARROW2_E: cint = 16

CHAR_ARROW2_W: cint = 17

CHAR_DARROW_H: cint = 29

CHAR_DARROW_V: cint = 18

CHAR_CHECKBOX_UNSET: cint = 224

CHAR_CHECKBOX_SET: cint = 225

CHAR_RADIO_UNSET: cint = 9

CHAR_RADIO_SET: cint = 10

CHAR_SUBP_NW: cint = 226

CHAR_SUBP_NE: cint = 227

CHAR_SUBP_N: cint = 228

CHAR_SUBP_SE: cint = 229

CHAR_SUBP_DIAG: cint = 230

CHAR_SUBP_E: cint = 231

CHAR_SUBP_SW: cint = 232

CHAR_SMILIE: cint = 1

CHAR_SMILIE_INV: cint = 2

CHAR_HEART: cint = 3

CHAR_DIAMOND: cint = 4

CHAR_CLUB: cint = 5

CHAR_SPADE: cint = 6

CHAR_BULLET: cint = 7

CHAR_BULLET_INV: cint = 8

CHAR_MALE: cint = 11

CHAR_FEMALE: cint = 12

CHAR_NOTE: cint = 13

CHAR_NOTE_DOUBLE: cint = 14

CHAR_LIGHT: cint = 15

CHAR_EXCLAM_DOUBLE: cint = 19

CHAR_PILCROW: cint = 20

CHAR_SECTION: cint = 21

CHAR_POUND: cint = 156

CHAR_MULTIPLICATION: cint = 158

CHAR_FUNCTION: cint = 159

CHAR_RESERVED: cint = 169

CHAR_HALF: cint = 171

CHAR_ONE_QUARTER: cint = 172

CHAR_COPYRIGHT: cint = 184

CHAR_CENT: cint = 189

CHAR_YEN: cint = 190

CHAR_CURRENCY: cint = 207

CHAR_THREE_QUARTERS: cint = 243

CHAR_DIVISION: cint = 246

CHAR_GRADE: cint = 248

CHAR_UMLAUT: cint = 249

CHAR_POW1: cint = 251

CHAR_POW3: cint = 252

CHAR_POW2: cint = 253

CHAR_BULLET_SQUARE: cint = 254

COLCTRL_NUMBER = COLCTRL_5

KEY_PRESSED: cint = 1

KEY_RELEASED: cint = 2

FONT_LAYOUT_ASCII_INCOL: cint = 1

These font flags can be OR'd together into a bit-field and passed to console_set_custom_font

Tiles are arranged in column-major order.

0 3 6
1 4 7
2 5 8

FONT_LAYOUT_ASCII_INROW: cint = 2

Tiles are arranged in row-major order.

0 1 2
3 4 5
6 7 8

FONT_TYPE_GREYSCALE: cint = 4

Converts all tiles into a monochrome gradient.

FONT_TYPE_GRAYSCALE: cint = 4

FONT_LAYOUT_TCOD: cint = 8

A unique layout used by some of libtcod's fonts.

LEX_FLAG_NOCASE: cint = 1

LEX_FLAG_NESTING_COMMENT: cint = 2

LEX_FLAG_TOKENIZE_COMMENTS: cint = 4

LEX_ERROR: cint = -1

LEX_UNKNOWN: cint = 0

LEX_SYMBOL: cint = 1

LEX_KEYWORD: cint = 2

LEX_IDEN: cint = 3

LEX_STRING: cint = 4

LEX_INTEGER: cint = 5

LEX_FLOAT: cint = 6

LEX_CHAR: cint = 7

LEX_EOF: cint = 8

LEX_COMMENT: cint = 9

LEX_MAX_SYMBOLS: cint = 100

LEX_SYMBOL_SIZE: cint = 5

LEX_MAX_KEYWORDS: cint = 100

LEX_KEYWORD_SIZE: cint = 20

NOISE_MAX_OCTAVES: cint = 128

NOISE_MAX_DIMENSIONS: cint = 4

NOISE_DEFAULT_HURST: cfloat = 0.5

NOISE_DEFAULT_LACUNARITY: cfloat = 2.0

DEFAULT_DIAGONAL_COST: cfloat = 1.41

Procs

proc lerp[T](a, b, x: T): T

proc colorRGB(r, g, b: uint8): Color {...}{.cdecl, importc: "TCOD_color_RGB", dynlib: LIB_NAME.}

proc colorHSV(hue, saturation, value: cfloat): Color {...}{.cdecl, importc: "TCOD_color_HSV", dynlib: LIB_NAME.}

proc colorEquals(c1, c2: Color): bool {...}{.cdecl, importc: "TCOD_color_equals", dynlib: LIB_NAME.}

proc colorAdd(c1, c2: Color): Color {...}{.cdecl, importc: "TCOD_color_add", dynlib: LIB_NAME.}

proc colorSubtract(c1, c2: Color): Color {...}{.cdecl, importc: "TCOD_color_subtract", dynlib: LIB_NAME.}

proc colorMultiply(c1, c2: Color): Color {...}{.cdecl, importc: "TCOD_color_multiply", dynlib: LIB_NAME.}

proc colorMultiplyScalar(c1: Color; value: cfloat): Color {...}{.cdecl, importc: "TCOD_color_multiply_scalar", dynlib: LIB_NAME.}

proc colorLerp(c1, c2: Color; coef: cfloat): Color {...}{.cdecl, importc: "TCOD_color_lerp", dynlib: LIB_NAME.}

proc colorSetHSV(color: ptr Color; hue, saturation, value: cfloat) {...}{.cdecl, importc: "TCOD_color_set_HSV", dynlib: LIB_NAME.}

proc colorGetHSV(color: Color; hue, saturation, value: ptr cfloat) {...}{.cdecl, importc: "TCOD_color_get_HSV", dynlib: LIB_NAME.}

proc colorGetHue(color: Color): cfloat {...}{.cdecl, importc: "TCOD_color_get_hue", dynlib: LIB_NAME.}

proc colorSetHue(color: ptr Color; hue: cfloat) {...}{.cdecl, importc: "TCOD_color_set_hue", dynlib: LIB_NAME.}

proc colorGetSaturation(color: Color): cfloat {...}{.cdecl, importc: "TCOD_color_get_saturation", dynlib: LIB_NAME.}

proc colorSetSaturation(color: ptr Color; saturation: cfloat) {...}{.cdecl, importc: "TCOD_color_set_saturation", dynlib: LIB_NAME.}

proc colorGetValue(color: Color): cfloat {...}{.cdecl, importc: "TCOD_color_get_value", dynlib: LIB_NAME.}

proc colorSetValue(color: ptr Color; value: cfloat) {...}{.cdecl, importc: "TCOD_color_set_value", dynlib: LIB_NAME.}

proc colorShiftHue(color: ptr Color; hshift: cfloat) {...}{.cdecl, importc: "TCOD_color_shift_hue", dynlib: LIB_NAME.}

proc colorScaleHSV(color: ptr Color; saturationCoef, valueCoef: cfloat) {...}{.cdecl, importc: "TCOD_color_scale_HSV", dynlib: LIB_NAME.}

proc colorGenMap(map: ptr Color; nbKey: cint; keyColor: ptr Color; keyIndex: ptr cint) {...}{. cdecl, importc: "TCOD_color_gen_map", dynlib: LIB_NAME.}

Color map.

proc imageNew(width, height: cint): Image {...}{.cdecl, importc: "TCOD_image_new", dynlib: LIB_NAME.}

proc imageFromConsole(console: Console): Image {...}{.cdecl, importc: "TCOD_image_from_console", dynlib: LIB_NAME.}

proc imageRefreshConsole(image: Image; console: Console) {...}{.cdecl, importc: "TCOD_image_refresh_console", dynlib: LIB_NAME.}

proc imageLoad(filename: cstring): Image {...}{.cdecl, importc: "TCOD_image_load", dynlib: LIB_NAME.}

proc imageClear(image: Image; color: Color) {...}{.cdecl, importc: "TCOD_image_clear", dynlib: LIB_NAME.}

proc imageInvert(image: Image) {...}{.cdecl, importc: "TCOD_image_invert", dynlib: LIB_NAME.}

proc imageHflip(image: Image) {...}{.cdecl, importc: "TCOD_image_hflip", dynlib: LIB_NAME.}

proc imageRotate90(image: Image; numRotations: cint = 1) {...}{.cdecl, importc: "TCOD_image_rotate90", dynlib: LIB_NAME.}

proc imageVflip(image: Image) {...}{.cdecl, importc: "TCOD_image_vflip", dynlib: LIB_NAME.}

proc imageScale(image: Image; neww, newh: cint) {...}{.cdecl, importc: "TCOD_image_scale", dynlib: LIB_NAME.}

proc imageSave(image: Image; filename: cstring) {...}{.cdecl, importc: "TCOD_image_save", dynlib: LIB_NAME.}

proc imageGetSize(image: Image; w, h: ptr cint) {...}{.cdecl, importc: "TCOD_image_get_size", dynlib: LIB_NAME.}

proc imageGetPixel(image: Image; x, y: cint): Color {...}{.cdecl, importc: "TCOD_image_get_pixel", dynlib: LIB_NAME.}

proc imageGetAlpha(image: Image; x, y: cint): cint {...}{.cdecl, importc: "TCOD_image_get_alpha", dynlib: LIB_NAME.}

proc imageGetMipmapPixel(image: Image; x0, y0, x1, y1: cfloat): Color {...}{.cdecl, importc: "TCOD_image_get_mipmap_pixel", dynlib: LIB_NAME.}

proc imagePutPixel(image: Image; x, y: cint; col: Color) {...}{.cdecl, importc: "TCOD_image_put_pixel", dynlib: LIB_NAME.}

proc imageBlit(image: Image; console: Console; x, y: cfloat; bkgndFlag: BkgndFlag = BKGND_SET; scalex: cfloat = 1.0; scaley: cfloat = 1.0; angle: cfloat = 0.0) {...}{.cdecl, importc: "TCOD_image_blit", dynlib: LIB_NAME.}

proc imageBlitRect(image: Image; console: Console; x, y: cint; w: cint = -1; h: cint = -1; bkgndFlag: BkgndFlag = BKGND_SET) {...}{.cdecl, importc: "TCOD_image_blit_rect", dynlib: LIB_NAME.}

proc imageBlit2x(image: Image; dest: Console; dx, dy: cint; sx: cint = 0; sy: cint = 0; w: cint = -1; h: cint = -1) {...}{.cdecl, importc: "TCOD_image_blit_2x", dynlib: LIB_NAME.}

proc imageDelete(image: var Image) {...}{.raises: [], tags: [].}

proc imageSetKeyColor(image: Image; keyColor: Color) {...}{.cdecl, importc: "TCOD_image_set_key_color", dynlib: LIB_NAME.}

proc imageIsPixelTransparent(image: Image; x, y: cint): bool {...}{.cdecl, importc: "TCOD_image_is_pixel_transparent", dynlib: LIB_NAME.}

proc listNew(): List {...}{.cdecl, importc: "TCOD_list_new", dynlib: LIB_NAME.}

proc listAllocate(nbElements: cint): List {...}{.cdecl, importc: "TCOD_list_allocate", dynlib: LIB_NAME.}

proc listDuplicate(l: List): List {...}{.cdecl, importc: "TCOD_list_duplicate", dynlib: LIB_NAME.}

proc listDelete(l: var List) {...}{.raises: [], tags: [].}

proc listPush(l: List; elt: pointer) {...}{.cdecl, importc: "TCOD_list_push", dynlib: LIB_NAME.}

proc listPop(l: List): pointer {...}{.cdecl, importc: "TCOD_list_pop", dynlib: LIB_NAME.}

proc listPeek(l: List): pointer {...}{.cdecl, importc: "TCOD_list_peek", dynlib: LIB_NAME.}

proc listAddAll(l, l2: List) {...}{.cdecl, importc: "TCOD_list_add_all", dynlib: LIB_NAME.}

proc listGet(l: List; idx: cint): pointer {...}{.cdecl, importc: "TCOD_list_get", dynlib: LIB_NAME.}

proc listSet(l: List; elt: pointer; idx: cint) {...}{.cdecl, importc: "TCOD_list_set", dynlib: LIB_NAME.}

proc listBegin(l: List): ptr pointer {...}{.cdecl, importc: "TCOD_list_begin", dynlib: LIB_NAME.}

proc listEnd(l: List): ptr pointer {...}{.cdecl, importc: "TCOD_list_end", dynlib: LIB_NAME.}

proc listReverse(l: List) {...}{.cdecl, importc: "TCOD_list_reverse", dynlib: LIB_NAME.}

proc listRemoveIterator(l: List; elt: ptr pointer): ptr pointer {...}{.cdecl, importc: "TCOD_list_remove_iterator", dynlib: LIB_NAME.}

proc listRemove(l: List; elt: pointer) {...}{.cdecl, importc: "TCOD_list_remove", dynlib: LIB_NAME.}

proc listRemoveIteratorFast(l: List; elt: ptr pointer): ptr pointer {...}{.cdecl, importc: "TCOD_list_remove_iterator_fast", dynlib: LIB_NAME.}

proc listRemoveFast(l: List; elt: pointer) {...}{.cdecl, importc: "TCOD_list_remove_fast", dynlib: LIB_NAME.}

proc listContains(l: List; elt: pointer): bool {...}{.cdecl, importc: "TCOD_list_contains", dynlib: LIB_NAME.}

proc listClear(l: List) {...}{.cdecl, importc: "TCOD_list_clear", dynlib: LIB_NAME.}

proc listClearAndDelete(l: var List) {...}{.raises: [], tags: [].}

proc listSize(l: List): cint {...}{.cdecl, importc: "TCOD_list_size", dynlib: LIB_NAME.}

proc listInsertBefore(l: List; elt: pointer; before: cint): ptr pointer {...}{.cdecl, importc: "TCOD_list_insert_before", dynlib: LIB_NAME.}

proc listIsEmpty(l: List): bool {...}{.cdecl, importc: "TCOD_list_is_empty", dynlib: LIB_NAME.}

proc lexNewIntern(): Lex {...}{.cdecl, importc: "TCOD_lex_new_intern", dynlib: LIB_NAME.}

proc lexNew(symbols, keywords: cstringArray; simpleComment, commentStart, commentStop: cstring; javadocCommentStart, stringDelim: cstring; flags: cint): Lex {...}{.cdecl, importc: "TCOD_lex_new", dynlib: LIB_NAME.}

proc lexDelete(lex: var Lex) {...}{.raises: [], tags: [].}

proc lexSetDataBuffer(lex: Lex; dat: cstring) {...}{.cdecl, importc: "TCOD_lex_set_data_buffer", dynlib: LIB_NAME.}

proc lexSetDataFile(lex: Lex; filename: cstring): bool {...}{.cdecl, importc: "TCOD_lex_set_data_file", dynlib: LIB_NAME.}

proc lexParse(lex: Lex): cint {...}{.cdecl, importc: "TCOD_lex_parse", dynlib: LIB_NAME.}

proc lexParseUntilTokenType(lex: Lex; tokenType: cint): cint {...}{.cdecl, importc: "TCOD_lex_parse_until_token_type", dynlib: LIB_NAME.}

proc lexParseUntilTokenValue(lex: Lex; tokenValue: cstring): cint {...}{.cdecl, importc: "TCOD_lex_parse_until_token_value", dynlib: LIB_NAME.}

proc lexExpectTokenType(lex: Lex; tokenType: cint): bool {...}{.cdecl, importc: "TCOD_lex_expect_token_type", dynlib: LIB_NAME.}

proc lexExpectTokenValue(lex: Lex; tokenType: cint; tokenValue: cstring): bool {...}{.cdecl, importc: "TCOD_lex_expect_token_value", dynlib: LIB_NAME.}

proc lexSavepoint(lex, savept: Lex) {...}{.cdecl, importc: "TCOD_lex_savepoint", dynlib: LIB_NAME.}

proc lexRestore(lex: Lex; savept: Lex) {...}{.cdecl, importc: "TCOD_lex_restore", dynlib: LIB_NAME.}

proc lexGetLastJavadoc(lex: Lex): cstring {...}{.cdecl, importc: "TCOD_lex_get_last_javadoc", dynlib: LIB_NAME.}

proc lexGetTokenName(tokenType: cint): cstring {...}{.cdecl, importc: "TCOD_lex_get_token_name", dynlib: LIB_NAME.}

proc lexGetLastError(): cstring {...}{.cdecl, importc: "TCOD_lex_get_last_error", dynlib: LIB_NAME.}

proc lexHextoint(c: char): cint {...}{.cdecl, importc: "TCOD_lex_hextoint", dynlib: LIB_NAME.}

proc repr(dice: Dice): string {...}{.raises: [], tags: [].}

proc noiseNew(dimensions: cint; hurst, lacunarity: cfloat; random: Random = nil): Noise {...}{. cdecl, importc: "TCOD_noise_new", dynlib: LIB_NAME.}

Create a new noise object.

proc noiseSetKind(noise: Noise; kind: NoiseKind) {...}{.cdecl, importc: "TCOD_noise_set_type", dynlib: LIB_NAME.}

proc noiseGetEx(noise: Noise; f: ptr cfloat; kind: NoiseKind = NOISE_DEFAULT): cfloat {...}{. cdecl, importc: "TCOD_noise_get_ex", dynlib: LIB_NAME.}

proc noiseGetFbmEx(noise: Noise; f: ptr cfloat; octaves: cfloat; kind: NoiseKind = NOISE_DEFAULT): cfloat {...}{.cdecl, importc: "TCOD_noise_get_fbm_ex", dynlib: LIB_NAME.}

proc noiseGetTurbulenceEx(noise: Noise; f: ptr cfloat; octaves: cfloat; kind: NoiseKind = NOISE_DEFAULT): cfloat {...}{.cdecl, importc: "TCOD_noise_get_turbulence_ex", dynlib: LIB_NAME.}

proc noiseGet(noise: Noise; f: ptr cfloat): cfloat {...}{.cdecl, importc: "TCOD_noise_get", dynlib: LIB_NAME.}

proc noiseGetFbm(noise: Noise; f: ptr cfloat; octaves: cfloat): cfloat {...}{.cdecl, importc: "TCOD_noise_get_fbm", dynlib: LIB_NAME.}

proc noiseGetTurbulence(noise: Noise; f: ptr cfloat; octaves: cfloat): cfloat {...}{.cdecl, importc: "TCOD_noise_get_turbulence", dynlib: LIB_NAME.}

proc noiseDelete(noise: var Noise) {...}{.raises: [], tags: [].}

Delete the noise object.

proc treeNew(): Tree {...}{.cdecl, importc: "TCOD_tree_new", dynlib: LIB_NAME.}

proc treeAddSon(node, son: Tree) {...}{.cdecl, importc: "TCOD_tree_add_son", dynlib: LIB_NAME.}

proc lineInit(xFrom, yFrom, xTo, yTo: cint) {...}{.cdecl, importc: "TCOD_line_init", dynlib: LIB_NAME, deprecated.}

proc lineStep(xCur, yCur: ptr cint): bool {...}{.cdecl, importc: "TCOD_line_step", dynlib: LIB_NAME, deprecated.}

Advance one step.

Returns true if we reach destination.

proc line(xFrom, yFrom, xTo, yTo: cint; listener: LineListener): bool {...}{.cdecl, importc: "TCOD_line", dynlib: LIB_NAME.}

Atomic callback procedure. Stops when the callback returns false.

proc lineInitMt(xFrom, yFrom, xTo, yTo: cint; data: ptr BresenhamData) {...}{.cdecl, importc: "TCOD_line_init_mt", dynlib: LIB_NAME.}

proc lineStepMt(xCur, yCur: ptr cint; data: ptr BresenhamData): bool {...}{.cdecl, importc: "TCOD_line_step_mt", dynlib: LIB_NAME.}

proc lineMt(xFrom, yFrom, xTo, yTo: cint; listener: LineListener; data: ptr BresenhamData): bool {...}{.cdecl, importc: "TCOD_line_mt", dynlib: LIB_NAME, deprecated.}

proc bspNew(): Bsp {...}{.cdecl, importc: "TCOD_bsp_new", dynlib: LIB_NAME.}

proc bspNewWithSize(x, y, w, h: cint): Bsp {...}{.cdecl, importc: "TCOD_bsp_new_with_size", dynlib: LIB_NAME.}

proc bspDelete(node: var Bsp) {...}{.raises: [], tags: [].}

proc bspLeft(node: Bsp): Bsp {...}{.cdecl, importc: "TCOD_bsp_left", dynlib: LIB_NAME.}

proc bspRight(node: Bsp): Bsp {...}{.cdecl, importc: "TCOD_bsp_right", dynlib: LIB_NAME.}

proc bspFather(node: Bsp): Bsp {...}{.cdecl, importc: "TCOD_bsp_father", dynlib: LIB_NAME.}

proc bspIsLeaf(node: Bsp): bool {...}{.cdecl, importc: "TCOD_bsp_is_leaf", dynlib: LIB_NAME.}

proc bspTraversePreOrder(node: Bsp; listener: BspCallback; userData: pointer = nil): bool {...}{. cdecl, importc: "TCOD_bsp_traverse_pre_order", dynlib: LIB_NAME.}

proc bspTraverseInOrder(node: Bsp; listener: BspCallback; userData: pointer = nil): bool {...}{. cdecl, importc: "TCOD_bsp_traverse_in_order", dynlib: LIB_NAME.}

proc bspTraversePostOrder(node: Bsp; listener: BspCallback; userData: pointer = nil): bool {...}{. cdecl, importc: "TCOD_bsp_traverse_post_order", dynlib: LIB_NAME.}

proc bspTraverseLevelOrder(node: Bsp; listener: BspCallback; userData: pointer = nil): bool {...}{. cdecl, importc: "TCOD_bsp_traverse_level_order", dynlib: LIB_NAME.}

proc bspTraverseInvertedLevelOrder(node: Bsp; listener: BspCallback; userData: pointer = nil): bool {...}{.cdecl, importc: "TCOD_bsp_traverse_inverted_level_order", dynlib: LIB_NAME.}

proc bspContains(node: Bsp; x, y: cint): bool {...}{.cdecl, importc: "TCOD_bsp_contains", dynlib: LIB_NAME.}

proc bspFindNode(node: Bsp; x, y: cint): Bsp {...}{.cdecl, importc: "TCOD_bsp_find_node", dynlib: LIB_NAME.}

proc bspResize(node: Bsp; x, y, w, h: cint) {...}{.cdecl, importc: "TCOD_bsp_resize", dynlib: LIB_NAME.}

proc bspSplitOnce(node: Bsp; horizontal: bool; position: cint) {...}{.cdecl, importc: "TCOD_bsp_split_once", dynlib: LIB_NAME.}

proc bspSplitRecursive(node: Bsp; randomizer: Random; nb, minHSize, minVSize: cint; maxHRatio, maxVRatio: cfloat) {...}{.cdecl, importc: "TCOD_bsp_split_recursive", dynlib: LIB_NAME.}

proc bspRemoveSons(node: Bsp) {...}{.cdecl, importc: "TCOD_bsp_remove_sons", dynlib: LIB_NAME.}

proc consoleInitRoot(w, h: cint; title: cstring; fullscreen: bool = false; renderer: Renderer = RENDERER_SDL) {...}{.cdecl, importc: "TCOD_console_init_root", dynlib: LIB_NAME.}

proc consoleSetWindowTitle(title: cstring) {...}{.cdecl, importc: "TCOD_console_set_window_title", dynlib: LIB_NAME.}

proc consoleSetFullscreen(fullscreen: bool) {...}{.cdecl, importc: "TCOD_console_set_fullscreen", dynlib: LIB_NAME.}

proc consoleIsFullscreen(): bool {...}{.cdecl, importc: "TCOD_console_is_fullscreen", dynlib: LIB_NAME.}

proc consoleIsWindowClosed(): bool {...}{.cdecl, importc: "TCOD_console_is_window_closed", dynlib: LIB_NAME.}

proc consoleHasMouseFocus(): bool {...}{.cdecl, importc: "TCOD_console_has_mouse_focus", dynlib: LIB_NAME.}

proc consoleIsActive(): bool {...}{.cdecl, importc: "TCOD_console_is_active", dynlib: LIB_NAME.}

proc consoleSetCustomFont(fontFile: cstring; flags: cint = FONT_LAYOUT_ASCII_INCOL; nbCharHoriz: cint = 0; nbCharVertic: cint = 0) {...}{.cdecl, importc: "TCOD_console_set_custom_font", dynlib: LIB_NAME.}

proc consoleMapAsciiCodeToFont(asciiCode, fontCharX, fontCharY: cint) {...}{.cdecl, importc: "TCOD_console_map_ascii_code_to_font", dynlib: LIB_NAME.}

proc consoleMapAsciiCodesToFont(asciiCode, nbCodes, fontCharX, fontCharY: cint) {...}{. cdecl, importc: "TCOD_console_map_ascii_codes_to_font", dynlib: LIB_NAME.}

proc consoleMapStringToFont(s: cstring; fontCharX, fontCharY: cint) {...}{.cdecl, importc: "TCOD_console_map_string_to_font", dynlib: LIB_NAME.}

proc consoleSetDirty(x, y, w, h: cint) {...}{.cdecl, importc: "TCOD_console_set_dirty", dynlib: LIB_NAME.}

proc consoleSetDefaultBackground(con: Console; col: Color) {...}{.cdecl, importc: "TCOD_console_set_default_background", dynlib: LIB_NAME.}

proc consoleSetDefaultForeground(con: Console; col: Color) {...}{.cdecl, importc: "TCOD_console_set_default_foreground", dynlib: LIB_NAME.}

proc consoleClear(con: Console) {...}{.cdecl, importc: "TCOD_console_clear", dynlib: LIB_NAME.}

proc consoleSetCharBackground(con: Console; x, y: cint; col: Color; flag: BkgndFlag = BKGND_SET) {...}{.cdecl, importc: "TCOD_console_set_char_background", dynlib: LIB_NAME.}

proc consoleSetCharForeground(con: Console; x, y: cint; col: Color) {...}{.cdecl, importc: "TCOD_console_set_char_foreground", dynlib: LIB_NAME.}

proc consoleSetChar(con: Console; x, y, c: cint) {...}{.cdecl, importc: "TCOD_console_set_char", dynlib: LIB_NAME.}

proc consolePutChar(con: Console; x, y, c: cint; flag: BkgndFlag = BKGND_DEFAULT) {...}{.cdecl, importc: "TCOD_console_put_char", dynlib: LIB_NAME.}

proc consolePutCharEx(con: Console; x, y, c: cint; fore, back: Color) {...}{.cdecl, importc: "TCOD_console_put_char_ex", dynlib: LIB_NAME.}

proc consoleSetBackgroundFlag(con: Console; flag: BkgndFlag) {...}{.cdecl, importc: "TCOD_console_set_background_flag", dynlib: LIB_NAME.}

proc consoleGetBackgroundFlag(con: Console): BkgndFlag {...}{.cdecl, importc: "TCOD_console_get_background_flag", dynlib: LIB_NAME.}

proc consoleSetAlignment(con: Console; alignment: Alignment) {...}{.cdecl, importc: "TCOD_console_set_alignment", dynlib: LIB_NAME.}

proc consoleGetAlignment(con: Console): Alignment {...}{.cdecl, importc: "TCOD_console_get_alignment", dynlib: LIB_NAME.}

proc consolePrint(con: Console; x, y: cint; fmt: cstring) {...}{.varargs, cdecl, importc: "TCOD_console_print", dynlib: LIB_NAME.}

proc consolePrintEx(con: Console; x, y: cint; flag: BkgndFlag; alignment: Alignment; fmt: cstring) {...}{.varargs, cdecl, importc: "TCOD_console_print_ex", dynlib: LIB_NAME.}

proc consolePrintRect(con: Console; x, y, w, h: cint; fmt: cstring): cint {...}{.varargs, cdecl, importc: "TCOD_console_print_rect", dynlib: LIB_NAME.}

proc consolePrintRectEx(con: Console; x, y, w, h: cint; flag: BkgndFlag; alignment: Alignment; fmt: cstring): cint {...}{.varargs, cdecl, importc: "TCOD_console_print_rect_ex", dynlib: LIB_NAME.}

proc consoleGetHeightRect(con: Console; x, y, w, h: cint; fmt: cstring): cint {...}{.varargs, cdecl, importc: "TCOD_console_get_height_rect", dynlib: LIB_NAME.}

proc consoleRect(con: Console; x, y, w, h: cint; clear: bool; flag: BkgndFlag = BKGND_DEFAULT) {...}{.cdecl, importc: "TCOD_console_rect", dynlib: LIB_NAME.}

proc consoleHline(con: Console; x, y, l: cint; flag: BkgndFlag = BKGND_DEFAULT) {...}{.cdecl, importc: "TCOD_console_hline", dynlib: LIB_NAME.}

proc consoleVline(con: Console; x, y, l: cint; flag: BkgndFlag = BKGND_DEFAULT) {...}{.cdecl, importc: "TCOD_console_vline", dynlib: LIB_NAME.}

proc consolePrintFrame(con: Console; x, y, w, h: cint; empty: bool = true; flag: BkgndFlag = BKGND_DEFAULT; fmt: cstring = nil) {...}{.varargs, cdecl, importc: "TCOD_console_print_frame", dynlib: LIB_NAME.}

proc consoleMapStringToFontUtf(s: WideCString; fontCharX, fontCharY: cint) {...}{.cdecl, importc: "TCOD_console_map_string_to_font_utf", dynlib: LIB_NAME.}

proc consoleMapStringToFontUtf(s: string; fontCharX, fontCharY: cint) {...}{.raises: [], tags: [].}

proc consolePrintUtf(con: Console; x, y: cint; fmt: WideCString) {...}{.varargs, cdecl, importc: "TCOD_console_print_utf", dynlib: LIB_NAME.}

proc consolePrintUtf(con: Console; x, y: cint; fmt: string) {...}{.raises: [], tags: [].}

proc consolePrintExUtf(con: Console; x, y: cint; flag: BkgndFlag; alignment: Alignment; fmt: WideCString) {...}{.varargs, cdecl, importc: "TCOD_console_print_ex_utf", dynlib: LIB_NAME.}

proc consolePrintExUtf(con: Console; x, y: cint; flag: BkgndFlag; alignment: Alignment; fmt: string) {...}{.raises: [], tags: [].}

proc consolePrintRectUtf(con: Console; x, y, w, h: cint; fmt: WideCString): cint {...}{.varargs, cdecl, importc: "TCOD_console_print_rect_utf", dynlib: LIB_NAME.}

proc consolePrintRectUtf(con: Console; x, y, w, h: cint; fmt: string): cint {...}{.raises: [], tags: [].}

proc consolePrintRectExUtf(con: Console; x, y, w, h: cint; flag: BkgndFlag; alignment: Alignment; fmt: WideCString): cint {...}{.varargs, cdecl, importc: "TCOD_console_print_rect_ex_utf", dynlib: LIB_NAME.}

proc consolePrintRectExUtf(con: Console; x, y, w, h: cint; flag: BkgndFlag; alignment: Alignment; fmt: string): cint {...}{.raises: [], tags: [].}

proc consoleGetHeightRectUtf(con: Console; x, y, w, h: cint; fmt: WideCString): cint {...}{. varargs, cdecl, importc: "TCOD_console_get_height_rect_utf", dynlib: LIB_NAME.}

proc consoleGetHeightRectUtf(con: Console; x, y, w, h: cint; fmt: string): cint {...}{. raises: [], tags: [].}

proc consoleGetDefaultBackground(con: Console): Color {...}{.cdecl, importc: "TCOD_console_get_default_background", dynlib: LIB_NAME.}

proc consoleGetDefaultForeground(con: Console): Color {...}{.cdecl, importc: "TCOD_console_get_default_foreground", dynlib: LIB_NAME.}

proc consoleGetCharBackground(con: Console; x, y: cint): Color {...}{.cdecl, importc: "TCOD_console_get_char_background", dynlib: LIB_NAME.}

proc consoleGetCharForeground(con: Console; x, y: cint): Color {...}{.cdecl, importc: "TCOD_console_get_char_foreground", dynlib: LIB_NAME.}

proc consoleGetChar(con: Console; x, y: cint): cint {...}{.cdecl, importc: "TCOD_console_get_char", dynlib: LIB_NAME.}

proc consoleGetBackgroundColorImage(con: Console): Image {...}{.cdecl, importc: "TCOD_console_get_background_color_image", dynlib: LIB_NAME.}

proc consoleGetForegroundColorImage(con: Console): Image {...}{.cdecl, importc: "TCOD_console_get_foreground_color_image", dynlib: LIB_NAME.}

proc consoleSetFade(val: uint8; fade: Color) {...}{.cdecl, importc: "TCOD_console_set_fade", dynlib: LIB_NAME.}

proc consoleGetFade(): uint8 {...}{.cdecl, importc: "TCOD_console_get_fade", dynlib: LIB_NAME.}

proc consoleGetFadingColor(): Color {...}{.cdecl, importc: "TCOD_console_get_fading_color", dynlib: LIB_NAME.}

proc consoleFlush() {...}{.cdecl, importc: "TCOD_console_flush", dynlib: LIB_NAME.}

proc consoleSetColorControl(con: Colctrl; fore, back: Color) {...}{.cdecl, importc: "TCOD_console_set_color_control", dynlib: LIB_NAME.}

proc consoleCheckForKeypress(flags: cint): Key {...}{.cdecl, importc: "TCOD_console_check_for_keypress", dynlib: LIB_NAME.}

proc consoleWaitForKeypress(flush: bool): Key {...}{.cdecl, importc: "TCOD_console_wait_for_keypress", dynlib: LIB_NAME.}

proc consoleIsKeyPressed(key: Keycode): bool {...}{.cdecl, importc: "TCOD_console_is_key_pressed", dynlib: LIB_NAME.}

proc consoleFromFile(filename: cstring): Console {...}{.cdecl, importc: "TCOD_console_from_file", dynlib: LIB_NAME.}

ASCII paint file support

proc consoleLoadAsc(con: Console; filename: cstring): bool {...}{.cdecl, importc: "TCOD_console_load_asc", dynlib: LIB_NAME.}

proc consoleLoadApf(con: Console; filename: cstring): bool {...}{.cdecl, importc: "TCOD_console_load_apf", dynlib: LIB_NAME.}

proc consoleSaveAsc(con: Console; filename: cstring): bool {...}{.cdecl, importc: "TCOD_console_save_asc", dynlib: LIB_NAME.}

proc consoleSaveApf(con: Console; filename: cstring): bool {...}{.cdecl, importc: "TCOD_console_save_apf", dynlib: LIB_NAME.}

proc consoleNew(w, h: cint): Console {...}{.cdecl, importc: "TCOD_console_new", dynlib: LIB_NAME.}

proc consoleGetWidth(con: Console): cint {...}{.cdecl, importc: "TCOD_console_get_width", dynlib: LIB_NAME.}

proc consoleGetHeight(con: Console): cint {...}{.cdecl, importc: "TCOD_console_get_height", dynlib: LIB_NAME.}

proc consoleSetKeyColor(con: Console; col: Color) {...}{.cdecl, importc: "TCOD_console_set_key_color", dynlib: LIB_NAME.}

proc consoleBlit(src: Console; xSrc, ySrc, wSrc, hSrc: cint; dst: Console; xDst, yDst: cint; foregroundAlpha: cfloat = 1.0; backgroundAlpha: cfloat = 1.0) {...}{.cdecl, importc: "TCOD_console_blit", dynlib: LIB_NAME.}

proc consoleDelete(con: var Console) {...}{.raises: [], tags: [].}

proc consoleCredits() {...}{.cdecl, importc: "TCOD_console_credits", dynlib: LIB_NAME.}

proc consoleCreditsReset() {...}{.cdecl, importc: "TCOD_console_credits_reset", dynlib: LIB_NAME.}

proc consoleCreditsRender(x, y: cint; alpha: bool): bool {...}{.cdecl, importc: "TCOD_console_credits_render", dynlib: LIB_NAME.}

proc consoleFromXp(filename: cstring): Console {...}{.cdecl, importc: "TCOD_console_from_xp", dynlib: LIB_NAME.}

proc consoleLoadXp(con: Console; filename: cstring): bool {...}{.cdecl, importc: "TCOD_console_load_xp", dynlib: LIB_NAME.}

proc consoleSaveXp(con: Console; filename: cstring; compressLevel: cint): bool {...}{.cdecl, importc: "TCOD_console_save_xp", dynlib: LIB_NAME.}

proc consoleListFromXp(filename: cstring): List {...}{.cdecl, importc: "TCOD_console_list_from_xp", dynlib: LIB_NAME.}

proc consoleListSaveXp(consoleList: List; filename: cstring; compressLevel: cint): bool {...}{. cdecl, importc: "TCOD_console_list_save_xp", dynlib: LIB_NAME.}

proc mapNew(width, height: cint): Map {...}{.cdecl, importc: "TCOD_map_new", dynlib: LIB_NAME.}

Allocate a new map.

proc mapClear(map: Map; transparent: bool = false; walkable: bool = false) {...}{.cdecl, importc: "TCOD_map_clear", dynlib: LIB_NAME.}

Set all cells as solid rock (cannot see through nor walk).

proc mapCopy(source, dest: Map) {...}{.cdecl, importc: "TCOD_map_copy", dynlib: LIB_NAME.}

Copy a map to another, reallocating it when needed.

proc mapSetProperties(map: Map; x, y: cint; isTransparent, isWalkable: bool) {...}{.cdecl, importc: "TCOD_map_set_properties", dynlib: LIB_NAME.}

Change a cell properties.

proc mapDelete(map: var Map) {...}{.raises: [], tags: [].}

Destroy a map.

proc mapComputeFov(map: Map; playerX, playerY: cint; maxRadius: cint = 0; lightWalls: bool = true; algo: FovAlgorithm = FOV_BASIC) {...}{.cdecl, importc: "TCOD_map_compute_fov", dynlib: LIB_NAME.}

Calculate the field of view (potentially visible cells from player_x, player_y).

proc mapIsInFov(map: Map; x, y: cint): bool {...}{.cdecl, importc: "TCOD_map_is_in_fov", dynlib: LIB_NAME.}

Check if a cell is in the last computed field of view.

proc mapSetInFov(map: Map; x, y: cint; fov: bool) {...}{.cdecl, importc: "TCOD_map_set_in_fov", dynlib: LIB_NAME.}

proc mapIsTransparent(map: Map; x, y: cint): bool {...}{.cdecl, importc: "TCOD_map_is_transparent", dynlib: LIB_NAME.}

Retrieve properties from the map.

proc mapIsWalkable(map: Map; x, y: cint): bool {...}{.cdecl, importc: "TCOD_map_is_walkable", dynlib: LIB_NAME.}

proc mapGetWidth(map: Map): cint {...}{.cdecl, importc: "TCOD_map_get_width", dynlib: LIB_NAME.}

proc mapGetHeight(map: Map): cint {...}{.cdecl, importc: "TCOD_map_get_height", dynlib: LIB_NAME.}

proc mapGetNbCells(map: Map): cint {...}{.cdecl, importc: "TCOD_map_get_nb_cells", dynlib: LIB_NAME.}

proc heightmapNew(w, h: cint): Heightmap {...}{.cdecl, importc: "TCOD_heightmap_new", dynlib: LIB_NAME.}

proc heightmapDelete(hm: var Heightmap) {...}{.raises: [], tags: [].}

proc heightmapGetValue(hm: Heightmap; x, y: cint): cfloat {...}{.cdecl, importc: "TCOD_heightmap_get_value", dynlib: LIB_NAME.}

proc heightmapGetInterpolatedValue(hm: Heightmap; x, y: cfloat): cfloat {...}{.cdecl, importc: "TCOD_heightmap_get_interpolated_value", dynlib: LIB_NAME.}

proc heightmapSetValue(hm: Heightmap; x, y: cint; value: cfloat) {...}{.cdecl, importc: "TCOD_heightmap_set_value", dynlib: LIB_NAME.}

proc heightmapGetSlope(hm: Heightmap; x, y: cint): cfloat {...}{.cdecl, importc: "TCOD_heightmap_get_slope", dynlib: LIB_NAME.}

proc heightmapGetNormal(hm: Heightmap; x, y: cfloat; n: array[3, cfloat]; waterLevel: cfloat = 0.0) {...}{.cdecl, importc: "TCOD_heightmap_get_normal", dynlib: LIB_NAME.}

proc heightmapCountCells(hm: Heightmap; `min`, `max`: cfloat): cint {...}{.cdecl, importc: "TCOD_heightmap_count_cells", dynlib: LIB_NAME.}

proc heightmapHasLandOnBorder(hm: Heightmap; waterLevel: cfloat): bool {...}{.cdecl, importc: "TCOD_heightmap_has_land_on_border", dynlib: LIB_NAME.}

proc heightmapGetMinmax(hm: Heightmap; `min`, `max`: ptr cfloat) {...}{.cdecl, importc: "TCOD_heightmap_get_minmax", dynlib: LIB_NAME.}

proc heightmapCopy(hmSource: Heightmap; hmDest: Heightmap) {...}{.cdecl, importc: "TCOD_heightmap_copy", dynlib: LIB_NAME.}

proc heightmapAdd(hm: Heightmap; value: cfloat) {...}{.cdecl, importc: "TCOD_heightmap_add", dynlib: LIB_NAME.}

proc heightmapScale(hm: Heightmap; value: cfloat) {...}{.cdecl, importc: "TCOD_heightmap_scale", dynlib: LIB_NAME.}

proc heightmapClamp(hm: Heightmap; `min`, `max`: cfloat) {...}{.cdecl, importc: "TCOD_heightmap_clamp", dynlib: LIB_NAME.}

proc heightmapNormalize(hm: Heightmap; `min`: cfloat = 0.0; `max`: cfloat = 1.0) {...}{.cdecl, importc: "TCOD_heightmap_normalize", dynlib: LIB_NAME.}

proc heightmapClear(hm: Heightmap) {...}{.cdecl, importc: "TCOD_heightmap_clear", dynlib: LIB_NAME.}

proc heightmapLerpHm(hm1, hm2, hmres: Heightmap; coef: cfloat) {...}{.cdecl, importc: "TCOD_heightmap_lerp_hm", dynlib: LIB_NAME.}

proc heightmapAddHm(hm1, hm2, hmres: Heightmap) {...}{.cdecl, importc: "TCOD_heightmap_add_hm", dynlib: LIB_NAME.}

proc heightmapMultiplyHm(hm1, hm2, hmres: Heightmap) {...}{.cdecl, importc: "TCOD_heightmap_multiply_hm", dynlib: LIB_NAME.}

proc heightmapAddHill(hm: Heightmap; hx, hy, hradius, hheight: cfloat) {...}{.cdecl, importc: "TCOD_heightmap_add_hill", dynlib: LIB_NAME.}

proc heightmapDigHill(hm: Heightmap; hx, hy, hradius, hheight: cfloat) {...}{.cdecl, importc: "TCOD_heightmap_dig_hill", dynlib: LIB_NAME.}

proc heightmapDigBezier(hm: Heightmap; px, py: array[4, cint]; startRadius, startDepth, endRadius, endDepth: cfloat) {...}{.cdecl, importc: "TCOD_heightmap_dig_bezier", dynlib: LIB_NAME.}

proc heightmapRainErosion(hm: Heightmap; nbDrops: cint; erosionCoef, sedimentationCoef: cfloat; rnd: Random = nil) {...}{. cdecl, importc: "TCOD_heightmap_rain_erosion", dynlib: LIB_NAME.}

proc heightmapKernelTransform(hm: Heightmap; kernelsize: cint; dx, dy: ptr cint; weight: ptr cfloat; minLevel, maxLevel: cfloat) {...}{.cdecl, importc: "TCOD_heightmap_kernel_transform", dynlib: LIB_NAME.}

proc heightmapAddVoronoi(hm: Heightmap; nbPoints, nbCoef: cint; coef: ptr cfloat; rnd: Random = nil) {...}{.cdecl, importc: "TCOD_heightmap_add_voronoi", dynlib: LIB_NAME.}

proc heightmapMidPointDisplacement(hm: Heightmap; rnd: Random = nil; roughness: cfloat = 0.45) {...}{.cdecl, importc: "TCOD_heightmap_mid_point_displacement", dynlib: LIB_NAME.}

proc heightmapAddFbm(hm: Heightmap; noise: Noise; mulx, muly, addx, addy, octaves, delta, scale: cfloat) {...}{.cdecl, importc: "TCOD_heightmap_add_fbm", dynlib: LIB_NAME.}

proc heightmapScaleFbm(hm: Heightmap; noise: Noise; mulx, muly, addx, addy, octaves, delta, scale: cfloat) {...}{.cdecl, importc: "TCOD_heightmap_scale_fbm", dynlib: LIB_NAME.}

proc heightmapIslandify(hm: Heightmap; seaLevel: cfloat; rnd: Random = nil) {...}{.cdecl, importc: "TCOD_heightmap_islandify", dynlib: LIB_NAME.}

proc randomGetInstance(): Random {...}{.cdecl, importc: "TCOD_random_get_instance", dynlib: LIB_NAME.}

proc randomNew(algo: RandomAlgo = RNG_CMWC): Random {...}{.cdecl, importc: "TCOD_random_new", dynlib: LIB_NAME.}

proc randomSave(mersenne: Random): Random {...}{.cdecl, importc: "TCOD_random_save", dynlib: LIB_NAME.}

proc randomRestore(mersenne: Random; backup: Random) {...}{.cdecl, importc: "TCOD_random_restore", dynlib: LIB_NAME.}

proc randomNewFromSeed(algo: RandomAlgo = RNG_CMWC; seed: uint32 = 0): Random {...}{.cdecl, importc: "TCOD_random_new_from_seed", dynlib: LIB_NAME.}

proc randomDelete(mersenne: var Random) {...}{.raises: [], tags: [].}

proc randomSetDistribution(mersenne: Random; distribution: Distribution) {...}{.cdecl, importc: "TCOD_random_set_distribution", dynlib: LIB_NAME.}

proc randomGetInt(mersenne: Random; `min`, `max`: cint): cint {...}{.cdecl, importc: "TCOD_random_get_int", dynlib: LIB_NAME.}

proc randomGetFloat(mersenne: Random; `min`, `max`: cfloat): cfloat {...}{.cdecl, importc: "TCOD_random_get_float", dynlib: LIB_NAME.}

proc randomGetDouble(mersenne: Random; `min`, `max`: cdouble): cdouble {...}{.cdecl, importc: "TCOD_random_get_double", dynlib: LIB_NAME.}

proc randomGetIntMean(mersenne: Random; `min`, `max`, mean: cint = 0): cint {...}{.cdecl, importc: "TCOD_random_get_int_mean", dynlib: LIB_NAME.}

proc randomGetFloatMean(mersenne: Random; `min`, `max`, mean: cfloat = 0.0): cfloat {...}{. cdecl, importc: "TCOD_random_get_float_mean", dynlib: LIB_NAME.}

proc randomGetDoubleMean(mersenne: Random; `min`, `max`, mean: cdouble = 0.0): cdouble {...}{. cdecl, importc: "TCOD_random_get_double_mean", dynlib: LIB_NAME.}

proc randomDiceNew(s: cstring): Dice {...}{.cdecl, importc: "TCOD_random_dice_new", dynlib: LIB_NAME.}

proc randomDiceRoll(mersenne: Random; dice: Dice): cint {...}{.cdecl, importc: "TCOD_random_dice_roll", dynlib: LIB_NAME.}

proc randomDiceRollS(mersenne: Random; s: cstring): cint {...}{.cdecl, importc: "TCOD_random_dice_roll_s", dynlib: LIB_NAME.}

proc mouseShowCursor(visible: bool) {...}{.cdecl, importc: "TCOD_mouse_show_cursor", dynlib: LIB_NAME.}

proc mouseGetStatus(): Mouse {...}{.cdecl, importc: "TCOD_mouse_get_status", dynlib: LIB_NAME.}

proc mouseIsCursorVisible(): bool {...}{.cdecl, importc: "TCOD_mouse_is_cursor_visible", dynlib: LIB_NAME.}

proc mouseMove(x, y: cint) {...}{.cdecl, importc: "TCOD_mouse_move", dynlib: LIB_NAME.}

proc mouseIncludesTouch(enable: bool) {...}{.cdecl, importc: "TCOD_mouse_includes_touch", dynlib: LIB_NAME.}

proc namegenParse(filename: cstring; random: Random = nil) {...}{.cdecl, importc: "TCOD_namegen_parse", dynlib: LIB_NAME.}

Parse a file with syllable sets.

proc namegenGenerate(name: cstring; allocate: bool = false): cstring {...}{.cdecl, importc: "TCOD_namegen_generate", dynlib: LIB_NAME.}

Generate a name.

proc namegenGenerateCustom(name, rule: cstring; allocate: bool = false): cstring {...}{.cdecl, importc: "TCOD_namegen_generate_custom", dynlib: LIB_NAME.}

Generate a name using a custom generation rule.

proc namegenGetSetsList(): List {...}{.cdecl, importc: "TCOD_namegen_get_sets", dynlib: LIB_NAME.}

Retrieve the list of all available syllable set names.

proc namegenGetSets(): seq[string] {...}{.raises: [], tags: [].}

Retrieve the list of all available syllable set names.

proc namegenDestroy() {...}{.cdecl, importc: "TCOD_namegen_destroy", dynlib: LIB_NAME.}

Delete a generator.

proc structGetName(def: ParserStruct): cstring {...}{.cdecl, importc: "TCOD_struct_get_name", dynlib: LIB_NAME.}

proc structAddProperty(def: ParserStruct; name: cstring; kind: ValueKind; mandatory: bool) {...}{.cdecl, importc: "TCOD_struct_add_property", dynlib: LIB_NAME.}

proc structAddListProperty(def: ParserStruct; name: cstring; kind: ValueKind; mandatory: bool) {...}{.cdecl, importc: "TCOD_struct_add_list_property", dynlib: LIB_NAME.}

proc structAddValueList(def: ParserStruct; name: cstring; valueList: cstringArray; mandatory: bool) {...}{.cdecl, importc: "TCOD_struct_add_value_list", dynlib: LIB_NAME.}

proc structAddValueListSized(def: ParserStruct; name: cstring; valueList: cstringArray; size: cint; mandatory: bool) {...}{. cdecl, importc: "TCOD_struct_add_value_list_sized", dynlib: LIB_NAME.}

proc structAddFlag(def: ParserStruct; propname: cstring) {...}{.cdecl, importc: "TCOD_struct_add_flag", dynlib: LIB_NAME.}

proc structAddStructure(def: ParserStruct; subStructure: ParserStruct) {...}{.cdecl, importc: "TCOD_struct_add_structure", dynlib: LIB_NAME.}

proc structIsMandatory(def: ParserStruct; propname: cstring): bool {...}{.cdecl, importc: "TCOD_struct_is_mandatory", dynlib: LIB_NAME.}

proc structGetKind(def: ParserStruct; propname: cstring): ValueKind {...}{.cdecl, importc: "TCOD_struct_get_type", dynlib: LIB_NAME.}

proc parserNew(): Parser {...}{.cdecl, importc: "TCOD_parser_new", dynlib: LIB_NAME.}

proc parserNewStruct(parser: Parser; name: cstring): ParserStruct {...}{.cdecl, importc: "TCOD_parser_new_struct", dynlib: LIB_NAME.}

proc parserNewCustomType(parser: Parser; customTypeParser: ParserCustom): ValueKind {...}{. cdecl, importc: "TCOD_parser_new_custom_type", dynlib: LIB_NAME.}

proc parserRun(parser: Parser; filename: cstring; listener: ParserListener) {...}{.cdecl, importc: "TCOD_parser_run", dynlib: LIB_NAME.}

proc parserDelete(parser: Parser) {...}{.cdecl, importc: "TCOD_parser_delete", dynlib: LIB_NAME.}

proc parserError(msg: cstring) {...}{.varargs, cdecl, importc: "TCOD_parser_error", dynlib: LIB_NAME.}

Error during parsing. can be called by the parser listener.

proc parserHasProperty(parser: Parser; name: cstring): bool {...}{.cdecl, importc: "TCOD_parser_has_property", dynlib: LIB_NAME.}

proc parserGetBoolProperty(parser: Parser; name: cstring): bool {...}{.cdecl, importc: "TCOD_parser_get_bool_property", dynlib: LIB_NAME.}

proc parserGetCharProperty(parser: Parser; name: cstring): cint {...}{.cdecl, importc: "TCOD_parser_get_char_property", dynlib: LIB_NAME.}

proc parserGetIntProperty(parser: Parser; name: cstring): cint {...}{.cdecl, importc: "TCOD_parser_get_int_property", dynlib: LIB_NAME.}

proc parserGetFloatProperty(parser: Parser; name: cstring): cfloat {...}{.cdecl, importc: "TCOD_parser_get_float_property", dynlib: LIB_NAME.}

proc parserGetStringProperty(parser: Parser; name: cstring): cstring {...}{.cdecl, importc: "TCOD_parser_get_string_property", dynlib: LIB_NAME.}

proc parserGetColorProperty(parser: Parser; name: cstring): Color {...}{.cdecl, importc: "TCOD_parser_get_color_property", dynlib: LIB_NAME.}

proc parserGetDiceProperty(parser: Parser; name: cstring): Dice {...}{.cdecl, importc: "TCOD_parser_get_dice_property", dynlib: LIB_NAME.}

proc parserGetDicePropertyPy(parser: Parser; name: cstring; dice: ptr Dice) {...}{.cdecl, importc: "TCOD_parser_get_dice_property_py", dynlib: LIB_NAME.}

proc parserGetCustomProperty(parser: Parser; name: cstring): pointer {...}{.cdecl, importc: "TCOD_parser_get_custom_property", dynlib: LIB_NAME.}

proc parserGetListProperty(parser: Parser; name: cstring; kind: ValueKind): List {...}{. cdecl, importc: "TCOD_parser_get_list_property", dynlib: LIB_NAME.}

proc parseBoolValue(): Value {...}{.cdecl, importc: "TCOD_parse_bool_value", dynlib: LIB_NAME.}

proc parseCharValue(): Value {...}{.cdecl, importc: "TCOD_parse_char_value", dynlib: LIB_NAME.}

proc parseIntegerValue(): Value {...}{.cdecl, importc: "TCOD_parse_integer_value", dynlib: LIB_NAME.}

proc parseFloatValue(): Value {...}{.cdecl, importc: "TCOD_parse_float_value", dynlib: LIB_NAME.}

proc parseStringValue(): Value {...}{.cdecl, importc: "TCOD_parse_string_value", dynlib: LIB_NAME.}

proc parseColorValue(): Value {...}{.cdecl, importc: "TCOD_parse_color_value", dynlib: LIB_NAME.}

proc parseDiceValue(): Value {...}{.cdecl, importc: "TCOD_parse_dice_value", dynlib: LIB_NAME.}

proc parseValueListValue(def: ptr StructInt; listnum: cint): Value {...}{.cdecl, importc: "TCOD_parse_value_list_value", dynlib: LIB_NAME.}

proc parsePropertyValue(parser: ptr ParserInt; def: ParserStruct; propname: cstring; list: bool): Value {...}{.cdecl, importc: "TCOD_parse_property_value", dynlib: LIB_NAME.}

proc pathNewUsingMap(map: Map; diagonalCost: cfloat = DEFAULT_DIAGONAL_COST): Path {...}{. cdecl, importc: "TCOD_path_new_using_map", dynlib: LIB_NAME.}

proc pathNewUsingProcedure(mapWidth, mapHeight: cint; procedure: PathProc; userData: pointer; diagonalCost: cfloat = DEFAULT_DIAGONAL_COST): Path {...}{. cdecl, importc: "TCOD_path_new_using_function", dynlib: LIB_NAME.}

proc pathCompute(path: Path; ox, oy, dx, dy: cint): bool {...}{.cdecl, importc: "TCOD_path_compute", dynlib: LIB_NAME.}

proc pathWalk(path: Path; x, y: ptr cint; recalculateWhenNeeded: bool): bool {...}{.cdecl, importc: "TCOD_path_walk", dynlib: LIB_NAME.}

proc pathIsEmpty(path: Path): bool {...}{.cdecl, importc: "TCOD_path_is_empty", dynlib: LIB_NAME.}

proc pathSize(path: Path): cint {...}{.cdecl, importc: "TCOD_path_size", dynlib: LIB_NAME.}

proc pathReverse(path: Path) {...}{.cdecl, importc: "TCOD_path_reverse", dynlib: LIB_NAME.}

proc pathGet(path: Path; index: cint; x, y: ptr cint) {...}{.cdecl, importc: "TCOD_path_get", dynlib: LIB_NAME.}

proc pathGetOrigin(path: Path; x, y: ptr cint) {...}{.cdecl, importc: "TCOD_path_get_origin", dynlib: LIB_NAME.}

proc pathGetDestination(path: Path; x, y: ptr cint) {...}{.cdecl, importc: "TCOD_path_get_destination", dynlib: LIB_NAME.}

proc pathDelete(path: var Path) {...}{.raises: [], tags: [].}

proc dijkstraNew(map: Map; diagonalCost: cfloat = DEFAULT_DIAGONAL_COST): Dijkstra {...}{. cdecl, importc: "TCOD_dijkstra_new", dynlib: LIB_NAME.}

proc dijkstraNewUsingProcedure(mapWidth, mapHeight: cint; procedure: PathProc; userData: pointer; diagonalCost: cfloat = DEFAULT_DIAGONAL_COST): Dijkstra {...}{. cdecl, importc: "TCOD_dijkstra_new_using_function", dynlib: LIB_NAME.}

proc dijkstraCompute(dijkstra: Dijkstra; rootX, rootY: cint) {...}{.cdecl, importc: "TCOD_dijkstra_compute", dynlib: LIB_NAME.}

proc dijkstraGetDistance(dijkstra: Dijkstra; x, y: cint): cfloat {...}{.cdecl, importc: "TCOD_dijkstra_get_distance", dynlib: LIB_NAME.}

proc dijkstraPathSet(dijkstra: Dijkstra; x, y: cint): bool {...}{.cdecl, importc: "TCOD_dijkstra_path_set", dynlib: LIB_NAME.}

proc dijkstraIsEmpty(path: Dijkstra): bool {...}{.cdecl, importc: "TCOD_dijkstra_is_empty", dynlib: LIB_NAME.}

proc dijkstraSize(path: Dijkstra): cint {...}{.cdecl, importc: "TCOD_dijkstra_size", dynlib: LIB_NAME.}

proc dijkstraReverse(path: Dijkstra) {...}{.cdecl, importc: "TCOD_dijkstra_reverse", dynlib: LIB_NAME.}

proc dijkstraGet(path: Dijkstra; index: cint; x, y: ptr cint) {...}{.cdecl, importc: "TCOD_dijkstra_get", dynlib: LIB_NAME.}

proc dijkstraPathWalk(dijkstra: Dijkstra; x, y: ptr cint): bool {...}{.cdecl, importc: "TCOD_dijkstra_path_walk", dynlib: LIB_NAME.}

proc dijkstraDelete(dijkstra: var Dijkstra) {...}{.raises: [], tags: [].}

proc sysStartup() {...}{.cdecl, importc: "TCOD_sys_startup", dynlib: LIB_NAME.}

proc sysShutdown() {...}{.cdecl, importc: "TCOD_sys_shutdown", dynlib: LIB_NAME.}

proc sysElapsedMilli(): uint32 {...}{.cdecl, importc: "TCOD_sys_elapsed_milli", dynlib: LIB_NAME.}

proc sysElapsedSeconds(): cfloat {...}{.cdecl, importc: "TCOD_sys_elapsed_seconds", dynlib: LIB_NAME.}

proc sysSleepMilli(val: uint32) {...}{.cdecl, importc: "TCOD_sys_sleep_milli", dynlib: LIB_NAME.}

proc sysSetFps(val: cint) {...}{.cdecl, importc: "TCOD_sys_set_fps", dynlib: LIB_NAME.}

proc sysGetFps(): cint {...}{.cdecl, importc: "TCOD_sys_get_fps", dynlib: LIB_NAME.}

proc sysGetLastFrameLength(): cfloat {...}{.cdecl, importc: "TCOD_sys_get_last_frame_length", dynlib: LIB_NAME.}

proc sysSaveScreenshot(filename: cstring) {...}{.cdecl, importc: "TCOD_sys_save_screenshot", dynlib: LIB_NAME.}

proc sysForceFullscreenResolution(width, height: cint) {...}{.cdecl, importc: "TCOD_sys_force_fullscreen_resolution", dynlib: LIB_NAME.}

proc sysSetRenderer(renderer: Renderer) {...}{.cdecl, importc: "TCOD_sys_set_renderer", dynlib: LIB_NAME.}

proc sysGetRenderer(): Renderer {...}{.cdecl, importc: "TCOD_sys_get_renderer", dynlib: LIB_NAME.}

proc sysGetCurrentResolution(w, h: ptr cint) {...}{.cdecl, importc: "TCOD_sys_get_current_resolution", dynlib: LIB_NAME.}

proc sysGetFullscreenOffsets(offx, offy: ptr cint) {...}{.cdecl, importc: "TCOD_sys_get_fullscreen_offsets", dynlib: LIB_NAME.}

proc sysGetCharSize(w, h: ptr cint) {...}{.cdecl, importc: "TCOD_sys_get_char_size", dynlib: LIB_NAME.}

proc sysUpdateChar(asciiCode, fontx, fonty: cint; img: Image; x, y: cint) {...}{.cdecl, importc: "TCOD_sys_update_char", dynlib: LIB_NAME.}

proc sysGetSDL_window(): pointer {...}{.cdecl, importc: "TCOD_sys_get_SDL_window", dynlib: LIB_NAME.}

proc sysGetSDL_renderer(): pointer {...}{.cdecl, importc: "TCOD_sys_get_SDL_renderer", dynlib: LIB_NAME.}

proc sysWaitForEvent(eventMask: cint; key: ptr Key; mouse: ptr Mouse; flush: bool): Event {...}{. cdecl, importc: "TCOD_sys_wait_for_event", dynlib: LIB_NAME.}

proc sysCheckForEvent(eventMask: cint; key: ptr Key; mouse: ptr Mouse): Event {...}{.cdecl, importc: "TCOD_sys_check_for_event", dynlib: LIB_NAME.}

proc sysCreateDirectory(path: cstring): bool {...}{.cdecl, importc: "TCOD_sys_create_directory", dynlib: LIB_NAME.}

proc sysDeleteFile(path: cstring): bool {...}{.cdecl, importc: "TCOD_sys_delete_file", dynlib: LIB_NAME.}

proc sysDeleteDirectory(path: cstring): bool {...}{.cdecl, importc: "TCOD_sys_delete_directory", dynlib: LIB_NAME.}

proc sysIsDirectory(path: cstring): bool {...}{.cdecl, importc: "TCOD_sys_is_directory", dynlib: LIB_NAME.}

proc sysGetDirectoryContent(path: cstring; pattern: cstring): List {...}{.cdecl, importc: "TCOD_sys_get_directory_content", dynlib: LIB_NAME.}

proc sysGetDirectoryContentSeq(path, pattern: string): seq[string] {...}{.raises: [], tags: [ReadDirEffect].}

proc sysFileExists(filename: cstring): bool {...}{.varargs, cdecl, importc: "TCOD_sys_file_exists", dynlib: LIB_NAME.}

proc sysReadFile(filename: cstring; buf: ptr ptr cuchar; size: ptr csize): bool {...}{.cdecl, importc: "TCOD_sys_read_file", dynlib: LIB_NAME.}

proc sysWriteFile(filename: cstring; buf: ptr cuchar; size: uint32): bool {...}{.cdecl, importc: "TCOD_sys_write_file", dynlib: LIB_NAME.}

proc sysClipboardSet(value: cstring): bool {...}{.cdecl, importc: "TCOD_sys_clipboard_set", dynlib: LIB_NAME.}

proc sysClipboardGet(): cstring {...}{.cdecl, importc: "TCOD_sys_clipboard_get", dynlib: LIB_NAME.}

proc threadNew(procedure: proc (a1: pointer): cint {...}{.cdecl.}; data: pointer): Thread {...}{. cdecl, importc: "TCOD_thread_new", dynlib: LIB_NAME.}

proc threadDelete(th: var Thread) {...}{.raises: [], tags: [].}

proc sysGetNumCores(): cint {...}{.cdecl, importc: "TCOD_sys_get_num_cores", dynlib: LIB_NAME.}

proc threadWait(th: Thread) {...}{.cdecl, importc: "TCOD_thread_wait", dynlib: LIB_NAME.}

proc mutexNew(): Mutex {...}{.cdecl, importc: "TCOD_mutex_new", dynlib: LIB_NAME.}

proc mutexIn(mut: Mutex) {...}{.cdecl, importc: "TCOD_mutex_in", dynlib: LIB_NAME.}

proc mutexOut(mut: Mutex) {...}{.cdecl, importc: "TCOD_mutex_out", dynlib: LIB_NAME.}

proc mutexDelete(mut: var Mutex) {...}{.raises: [], tags: [].}

proc semaphoreNew(initVal: cint): Semaphore {...}{.cdecl, importc: "TCOD_semaphore_new", dynlib: LIB_NAME.}

proc semaphoreLock(sem: Semaphore) {...}{.cdecl, importc: "TCOD_semaphore_lock", dynlib: LIB_NAME.}

proc semaphoreUnlock(sem: Semaphore) {...}{.cdecl, importc: "TCOD_semaphore_unlock", dynlib: LIB_NAME.}

proc semaphoreDelete(sem: var Semaphore) {...}{.raises: [], tags: [].}

proc conditionNew(): Cond {...}{.cdecl, importc: "TCOD_condition_new", dynlib: LIB_NAME.}

proc conditionSignal(sem: Cond) {...}{.cdecl, importc: "TCOD_condition_signal", dynlib: LIB_NAME.}

proc conditionBroadcast(sem: Cond) {...}{.cdecl, importc: "TCOD_condition_broadcast", dynlib: LIB_NAME.}

proc conditionWait(sem: Cond; mut: Mutex) {...}{.cdecl, importc: "TCOD_condition_wait", dynlib: LIB_NAME.}

proc conditionDelete(sem: var Cond) {...}{.raises: [], tags: [].}

proc loadLibrary(path: cstring): Library {...}{.cdecl, importc: "TCOD_load_library", dynlib: LIB_NAME.}

proc getProcedureAddress(library: Library; procedureName: cstring): pointer {...}{.cdecl, importc: "TCOD_get_function_address", dynlib: LIB_NAME.}

proc closeLibrary(a1: var Library) {...}{.raises: [], tags: [].}

proc sysRegisterSDL_Renderer(renderer: SDL_Renderer) {...}{.cdecl, importc: "TCOD_sys_register_SDL_renderer", dynlib: LIB_NAME.}

proc textInit(x, y, w, h, maxChars: cint): Text {...}{.cdecl, importc: "TCOD_text_init", dynlib: LIB_NAME.}

proc textInit2(w, h, maxChars: cint): Text {...}{.cdecl, importc: "TCOD_text_init2", dynlib: LIB_NAME.}

proc textSetPos(txt: Text; x, y: cint) {...}{.cdecl, importc: "TCOD_text_set_pos", dynlib: LIB_NAME.}

proc textSetProperties(txt: Text; cursorChar, blinkInterval: cint; prompt: cstring; tabSize: cint) {...}{.cdecl, importc: "TCOD_text_set_properties", dynlib: LIB_NAME.}

proc textSetColors(txt: Text; fore, back: Color; backTransparency: cfloat) {...}{.cdecl, importc: "TCOD_text_set_colors", dynlib: LIB_NAME.}

proc textUpdate(txt: Text; key: Key): bool {...}{.cdecl, importc: "TCOD_text_update", dynlib: LIB_NAME.}

proc textRender(txt: Text; con: Console) {...}{.cdecl, importc: "TCOD_text_render", dynlib: LIB_NAME.}

proc textGet(txt: Text): cstring {...}{.cdecl, importc: "TCOD_text_get", dynlib: LIB_NAME.}

proc textReset(txt: Text) {...}{.cdecl, importc: "TCOD_text_reset", dynlib: LIB_NAME.}

proc textDelete(txt: var Text) {...}{.raises: [], tags: [].}

proc zipNew(): Zip {...}{.cdecl, importc: "TCOD_zip_new", dynlib: LIB_NAME.}

proc zipDelete(zip: var Zip) {...}{.raises: [], tags: [].}

proc zipPutChar(zip: Zip; val: char) {...}{.cdecl, importc: "TCOD_zip_put_char", dynlib: LIB_NAME.}

output interface

proc zipPutInt(zip: Zip; val: cint) {...}{.cdecl, importc: "TCOD_zip_put_int", dynlib: LIB_NAME.}

proc zipPutFloat(zip: Zip; val: cfloat) {...}{.cdecl, importc: "TCOD_zip_put_float", dynlib: LIB_NAME.}

proc zipPutString(zip: Zip; val: cstring) {...}{.cdecl, importc: "TCOD_zip_put_string", dynlib: LIB_NAME.}

proc zipPutColor(zip: Zip; val: Color) {...}{.cdecl, importc: "TCOD_zip_put_color", dynlib: LIB_NAME.}

proc zipPutImage(zip: Zip; val: Image) {...}{.cdecl, importc: "TCOD_zip_put_image", dynlib: LIB_NAME.}

proc zipPutConsole(zip: Zip; val: Console) {...}{.cdecl, importc: "TCOD_zip_put_console", dynlib: LIB_NAME.}

proc zipPutData(zip: Zip; nbBytes: cint; data: pointer) {...}{.cdecl, importc: "TCOD_zip_put_data", dynlib: LIB_NAME.}

proc zipGetCurrentBytes(zip: Zip): uint32 {...}{.cdecl, importc: "TCOD_zip_get_current_bytes", dynlib: LIB_NAME.}

proc zipSaveToFile(zip: Zip; filename: cstring): cint {...}{.cdecl, importc: "TCOD_zip_save_to_file", dynlib: LIB_NAME.}

proc zipLoadFromFile(zip: Zip; filename: cstring): cint {...}{.cdecl, importc: "TCOD_zip_load_from_file", dynlib: LIB_NAME.}

input interface

proc zipGetChar(zip: Zip): char {...}{.cdecl, importc: "TCOD_zip_get_char", dynlib: LIB_NAME.}

proc zipGetInt(zip: Zip): cint {...}{.cdecl, importc: "TCOD_zip_get_int", dynlib: LIB_NAME.}

proc zipGetFloat(zip: Zip): cfloat {...}{.cdecl, importc: "TCOD_zip_get_float", dynlib: LIB_NAME.}

proc zipGetString(zip: Zip): cstring {...}{.cdecl, importc: "TCOD_zip_get_string", dynlib: LIB_NAME.}

proc zipGetColor(zip: Zip): Color {...}{.cdecl, importc: "TCOD_zip_get_color", dynlib: LIB_NAME.}

proc zipGetImage(zip: Zip): Image {...}{.cdecl, importc: "TCOD_zip_get_image", dynlib: LIB_NAME.}

proc zipGetConsole(zip: Zip): Console {...}{.cdecl, importc: "TCOD_zip_get_console", dynlib: LIB_NAME.}

proc zipGetData(zip: Zip; nbBytes: cint; data: pointer): cint {...}{.cdecl, importc: "TCOD_zip_get_data", dynlib: LIB_NAME.}

proc zipGetRemainingBytes(zip: Zip): uint32 {...}{.cdecl, importc: "TCOD_zip_get_remaining_bytes", dynlib: LIB_NAME.}

proc zipSkipBytes(zip: Zip; nbBytes: uint32) {...}{.cdecl, importc: "TCOD_zip_skip_bytes", dynlib: LIB_NAME.}

Templates

template colorRGB(r, g, b: int): Color
template fov_Permissive(x: untyped): untyped
template floatArrayToPtr(f: var openArray[cfloat]): ptr cfloat
template bkgndAlpha(alpha: untyped): untyped
template bkgndAddalpha(alpha: untyped): untyped
template consoleSetChar(con: Console; x, y: cint; c: char)
template consolePutChar(con: Console; x, y: cint; c: char; flag: BkgndFlag = BKGND_DEFAULT)
template consolePutCharEx(con: Console; x, y: cint; c: char; fore, back: Color)
template randomGetChar(mersenne: Random; `min`, `max`: char): char