/*

https://github.com/peterix/dfhack

Copyright (c) 2009-2012 Petr Mrázek (peterix@gmail.com)

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any

damages arising from the use of this software.

Permission is granted to anyone to use this software for any

purpose, including commercial applications, and to alter it and

redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must

not claim that you wrote the original software. If you use this

software in a product, an acknowledgment in the product documentation

would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and

must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source

distribution.

*/

#include "Core.h"

#include "Error.h"

#include "Internal.h"

#include "MemAccess.h"

#include "VersionInfo.h"

// must be last due to MS stupidity

#include "DataDefs.h"

#include "DataFuncs.h"

#include "DataIdentity.h"

#include "Debug.h"

#include "DFHackVersion.h"

#include "LuaTools.h"

#include "LuaWrapper.h"

#include "md5wrapper.h"

#include "MiscUtils.h"

#include "PluginManager.h"

#include "modules/Buildings.h"

#include "modules/Burrows.h"

#include "modules/Constructions.h"

#include "modules/Designations.h"

#include "modules/DFSDL.h"

#include "modules/EventManager.h"

#include "modules/Filesystem.h"

#include "modules/Gui.h"

#include "modules/Items.h"

#include "modules/Job.h"

#include "modules/Kitchen.h"

#include "modules/Maps.h"

#include "modules/Materials.h"

#include "modules/Military.h"

#include "modules/Random.h"

#include "modules/Screen.h"

#include "modules/Textures.h"

#include "modules/Translation.h"

#include "modules/Units.h"

#include "modules/World.h"

#include "df/activity_entry.h"

#include "df/activity_event.h"

#include "df/announcement_flags.h"

#include "df/announcement_infost.h"

#include "df/building.h"

#include "df/building_cagest.h"

#include "df/building_civzonest.h"

#include "df/building_stockpilest.h"

#include "df/building_tradedepotst.h"

#include "df/building_workshopst.h"

#include "df/burrow.h"

#include "df/caravan_state.h"

#include "df/construction.h"

#include "df/creature_raw.h"

#include "df/dfhack_material_category.h"

#include "df/enabler.h"

#include "df/feature_init.h"

#include "df/flow_info.h"

#include "df/general_ref.h"

#include "df/histfig_entity_link_positionst.h"

#include "df/historical_figure.h"

#include "df/identity.h"

#include "df/inorganic_raw.h"

#include "df/item.h"

#include "df/itemdef.h"

#include "df/item_type.h"

#include "df/job.h"

#include "df/job_item.h"

#include "df/job_material_category.h"

#include "df/language_word_table.h"

#include "df/material.h"

#include "df/map_block.h"

#include "df/nemesis_record.h"

#include "df/plant.h"

#include "df/plant_raw.h"

#include "df/proj_itemst.h"

#include "df/region_map_entry.h"

#include "df/report_zoom_type.h"

#include "df/specific_ref.h"

#include "df/specific_ref_type.h"

#include "df/squad_use_flags.h"

#include "df/squad.h"

#include "df/unit.h"

#include "df/unit_misc_trait.h"

#include "df/vermin.h"

#include "df/viewscreen.h"

#include <lua.h>

#include <lualib.h>

#include <lauxlib.h>

#include <cstring>

#include <map>

#include <numeric>

#include <string>

#include <vector>

#include <filesystem>

#include <stdexcept>

namespace DFHack {

DBG_DECLARE(core, luaapi, DebugCategory::LINFO);

}

using namespace DFHack;

using namespace df::enums;

using namespace DFHack::LuaWrapper;

using std::string;

using std::vector;

using Screen::Pen;

using Random::MersenneRNG;

using Random::PerlinNoise1D;

using Random::PerlinNoise2D;

using Random::PerlinNoise3D;

void dfhack_printerr(lua_State *S, const string &str);

static df::coord2d CheckCoordXY(lua_State *state, int base, bool vararg = false)

{

df::coord2d p;

if (vararg && lua_gettop(state) <= base)

Lua::CheckDFAssign(state, &p, base);

else

{

p = df::coord2d(

luaL_checkint(state, base),

luaL_checkint(state, base+1)

);

}

return p;

}

static df::coord CheckCoordXYZ(lua_State *state, int base, bool vararg = false)

{

df::coord p;

if (vararg && lua_gettop(state) <= base)

Lua::CheckDFAssign(state, &p, base);

else

{

p = df::coord(

luaL_checkint(state, base),

luaL_checkint(state, base+1),

luaL_checkint(state, base+2)

);

}

return p;

}

template<class T>

static bool get_int_field(lua_State *L, T *pf, int idx, const char *name, int defval)

{

lua_getfield(L, idx, name);

bool nil = lua_isnil(L, -1);

if (nil) *pf = T(defval);

else if (lua_isnumber(L, -1)) *pf = T(lua_tointeger(L, -1));

else luaL_error(L, "Field %s is not a number.", name);

lua_pop(L, 1);

return !nil;

}

template<class T>

static bool get_int_or_closure_field(lua_State *L, T *pf, int idx, const char *name, int defval)

{

lua_getfield(L, idx, name);

bool nil = lua_isnil(L, -1);

if (nil) {

*pf = T(defval);

} else if (lua_isnumber(L, -1)) {

*pf = T(lua_tointeger(L, -1));

} else if (lua_isfunction(L, -1)) {

lua_call(L, 0, 1);

*pf = T(lua_tointeger(L, -1));

lua_pop(L, 1);

} else {

luaL_error(L, "Field %s is not a number or closure function.", name);

}

lua_pop(L, 1);

return !nil;

}

static bool get_char_field(lua_State *L, char *pf, int idx, const char *name, char defval)

{

lua_getfield(L, idx, name);

if (lua_type(L, -1) == LUA_TSTRING)

{

*pf = lua_tostring(L, -1)[0];

lua_pop(L, 1);

return true;

}

else

{

lua_pop(L, 1);

return get_int_field(L, pf, idx, name, defval);

}

}

static bool get_bool_field(lua_State *L, bool *pf, int idx, const char *name, bool defval) {

lua_getfield(L, idx, name);

bool nil = lua_isnil(L, -1);

if (nil)

*pf = defval;

else

*pf = lua_toboolean(L, -1);

lua_pop(L, 1);

return !nil;

}

static void decode_pen(lua_State *L, Pen &pen, int idx)

{

idx = lua_absindex(L, idx);

get_char_field(L, &pen.ch, idx, "ch", 0);

get_int_field(L, &pen.fg, idx, "fg", 7);

get_int_field(L, &pen.bg, idx, "bg", 0);

lua_getfield(L, idx, "bold");

if (lua_isnil(L, -1))

{

pen.bold = (pen.fg & 8) != 0;

pen.fg &= 7;

}

else pen.bold = lua_toboolean(L, -1);

lua_pop(L, 1);

get_int_or_closure_field(L, &pen.tile, idx, "tile", 0);

bool tcolor = get_int_field(L, &pen.tile_fg, idx, "tile_fg", 7);

tcolor = get_int_field(L, &pen.tile_bg, idx, "tile_bg", 0) || tcolor;

if (tcolor)

pen.tile_mode = Pen::TileColor;

else

{

lua_getfield(L, idx, "tile_color");

pen.tile_mode = (lua_toboolean(L, -1) ? Pen::CharColor : Pen::AsIs);

lua_pop(L, 1);

}

get_bool_field(L, &pen.keep_lower, idx, "keep_lower", false);

get_bool_field(L, &pen.write_to_lower, idx, "write_to_lower", false);

get_bool_field(L, &pen.top_of_text, idx, "top_of_text", false);

get_bool_field(L, &pen.bottom_of_text, idx, "bottom_of_text", false);

}

/**************************************************

* Per-world persistent configuration storage API *

**************************************************/

typedef PersistentDataItem (*get_data_fn)(lua_State *);

static PersistentDataItem get_site_data(lua_State *L) {

const char *key = lua_tostring(L, 1);

if (!key)

luaL_argerror(L, 1, "no key specified");

return World::GetPersistentSiteData(key);

}

static PersistentDataItem get_world_data(lua_State *L) {

const char *key = lua_tostring(L, 1);

if (!key)

luaL_argerror(L, 1, "no key specified");

return World::GetPersistentWorldData(key);

}

static int dfhack_persistent_get_data_string(lua_State *L, get_data_fn get_data) {

CoreSuspender suspend;

PersistentDataItem data = get_data(L);

if (!data.isValid())

lua_pushnil(L);

else

Lua::Push(L, data.val());

return 1;

}

typedef PersistentDataItem (*raw_get_data_fn)(const string &, bool);

static int dfhack_persistent_save_data_string(lua_State *L, raw_get_data_fn get_data) {

CoreSuspender suspend;

const char *key = lua_tostring(L, 1);

if (!key)

luaL_argerror(L, 1, "no key specified");

const char *str = lua_tostring(L, 2);

if (!str)

luaL_argerror(L, 2, "no data string specified");

PersistentDataItem data = get_data(key, true);

if (!data.isValid())

luaL_error(L, "unable to save data in key '%s'", key);

data.val() = str;

return 0;

}

static int delete_site_data(lua_State *L, get_data_fn get_data) {

CoreSuspender suspend;

PersistentDataItem data = get_data(L);

bool ok = World::DeletePersistentData(data);

lua_pushboolean(L, ok);

return 1;

}

static int dfhack_persistent_get_site_data_string(lua_State *L) {

return dfhack_persistent_get_data_string(L, get_site_data);

}

static int dfhack_persistent_save_site_data_string(lua_State *L) {

return dfhack_persistent_save_data_string(L, World::GetPersistentSiteData);

}

static int dfhack_persistent_delete_site_data(lua_State *L) {

return delete_site_data(L, get_site_data);

}

static int dfhack_persistent_get_world_data_string(lua_State *L) {

return dfhack_persistent_get_data_string(L, get_world_data);

}

static int dfhack_persistent_save_world_data_string(lua_State *L) {

return dfhack_persistent_save_data_string(L, World::GetPersistentWorldData);

}

static int dfhack_persistent_delete_world_data(lua_State *L) {

return delete_site_data(L, get_world_data);

}

static int dfhack_persistent_get_unsaved_seconds(lua_State *L) {

lua_pushinteger(L, Persistence::getUnsavedSeconds());

return 1;

}

static const luaL_Reg dfhack_persistent_funcs[] = {

{ "getSiteDataString", dfhack_persistent_get_site_data_string },

{ "saveSiteDataString", dfhack_persistent_save_site_data_string },

{ "deleteSiteData", dfhack_persistent_delete_site_data },

{ "getWorldDataString", dfhack_persistent_get_world_data_string },

{ "saveWorldDataString", dfhack_persistent_save_world_data_string },

{ "deleteWorldData", dfhack_persistent_delete_world_data },

{ "getUnsavedSeconds", dfhack_persistent_get_unsaved_seconds },

{ NULL, NULL }

};

static void OpenPersistent(lua_State *state)

{

luaL_getsubtable(state, lua_gettop(state), "persistent");

lua_dup(state);

luaL_setfuncs(state, dfhack_persistent_funcs, 1);

lua_dup(state);

lua_setfield(state, -2, "__index");

lua_pop(state, 1);

}

/************************

* Material info lookup *

************************/

static int DFHACK_MATINFO_TOKEN = 0;

void Lua::Push(lua_State *state, const MaterialInfo &info)

{

if (!info.isValid())

{

lua_pushnil(state);

return;

}

lua_newtable(state);

lua_rawgetp(state, LUA_REGISTRYINDEX, &DFHACK_MATINFO_TOKEN);

lua_setmetatable(state, -2);

lua_pushinteger(state, info.type);

lua_setfield(state, -2, "type");

lua_pushinteger(state, info.index);

lua_setfield(state, -2, "index");

#define SETOBJ(name) { \

Lua::PushDFObject(state, info.name); \

lua_setfield(state, -2, #name); \

}

SETOBJ(material);

if (info.plant) SETOBJ(plant);

if (info.creature) SETOBJ(creature);

if (info.inorganic) SETOBJ(inorganic);

if (info.figure) SETOBJ(figure);

#undef SETOBJ

if (info.mode != MaterialInfo::Builtin)

{

lua_pushinteger(state, info.subtype);

lua_setfield(state, -2, "subtype");

}

const char *id = "builtin";

switch (info.mode)

{

case MaterialInfo::Plant: id = "plant"; break;

case MaterialInfo::Creature: id = "creature"; break;

case MaterialInfo::Inorganic: id = "inorganic"; break;

default: break;

}

lua_pushstring(state, id);

lua_setfield(state, -2, "mode");

}

static int dfhack_matinfo_find(lua_State *state)

{

MaterialInfo info;

int argc = lua_gettop(state);

if (argc == 1)

info.find(luaL_checkstring(state, 1));

else

{

vector<string> tokens;

for (int i = 1; i <= argc; i++)

tokens.push_back(luaL_checkstring(state, i));

info.find(tokens);

}

Lua::Push(state, info);

return 1;

}

static bool decode_matinfo(lua_State *state, MaterialInfo *info, bool numpair = false)

{

int curtop = lua_gettop(state);

luaL_checkany(state, 1);

if (!lua_isnumber(state, 1))

{

if (lua_isnil(state, 1))

return false;

if (lua_getmetatable(state, 1))

{

if (lua_rawequal(state, -1, lua_upvalueindex(1)))

{

lua_getfield(state, 1, "type");

lua_getfield(state, 1, "index");

goto int_pair;

}

lua_pop(state, 1);

}

if (lua_isuserdata(state, 1))

{

if (auto item = Lua::GetDFObject<df::item>(state, 1))

return info->decode(item);

if (auto plant = Lua::GetDFObject<df::plant>(state, 1))

return info->decode(MaterialInfo::PLANT_BASE, plant->material);

if (auto mvec = Lua::GetDFObject<df::material_vec_ref>(state, 1))

return info->decode(*mvec, luaL_checkint(state, 2));

}

lua_getfield(state, 1, "mat_type");

lua_getfield(state, 1, "mat_index");

goto int_pair;

}

else

{

if (!numpair)

luaL_argerror(state, 1, "material info object expected");

if (curtop < 2)

lua_settop(state, 2);

}

int_pair:

{

int ok;

int type = lua_tointegerx(state, -2, &ok);

if (!ok)

luaL_argerror(state, 1, "material id is not a number");

int index = lua_tointegerx(state, -1, &ok);

if (!ok)

index = -1;

lua_settop(state, curtop);

return info->decode(type, index);

}

}

static int dfhack_matinfo_decode(lua_State *state)

{

MaterialInfo info;

decode_matinfo(state, &info, true);

Lua::Push(state, info);

return 1;

}

static int dfhack_matinfo_getToken(lua_State *state)

{

MaterialInfo info;

decode_matinfo(state, &info, true);

auto str = info.getToken();

lua_pushstring(state, str.c_str());

return 1;

}

static int dfhack_matinfo_toString(lua_State *state)

{

MaterialInfo info;

decode_matinfo(state, &info);

lua_settop(state, 3);

auto str = info.toString(luaL_optint(state, 2, 10015), lua_toboolean(state, 3));

lua_pushstring(state, str.c_str());

return 1;

}

static int dfhack_matinfo_getCraftClass(lua_State *state)

{

MaterialInfo info;

if (decode_matinfo(state, &info, true))

lua_pushinteger(state, info.getCraftClass());

else

lua_pushnil(state);

return 1;

}

static int dfhack_matinfo_matches(lua_State *state)

{

MaterialInfo info;

if (!decode_matinfo(state, &info))

luaL_argerror(state, 1, "material info object expected");

luaL_checkany(state, 2);

if (lua_isuserdata(state, 2))

{

if (auto mc = Lua::GetDFObject<df::job_material_category>(state, 2))

lua_pushboolean(state, info.matches(*mc));

else if (auto mc = Lua::GetDFObject<df::dfhack_material_category>(state, 2))

lua_pushboolean(state, info.matches(*mc));

else if (auto mc = Lua::GetDFObject<df::job_item>(state, 2))

lua_pushboolean(state, info.matches(*mc));

else

luaL_argerror(state, 2, "material category object expected");

}

else if (lua_istable(state, 2))

{

df::dfhack_material_category tmp;

Lua::CheckDFAssign(state, &tmp, 2, false);

lua_pushboolean(state, info.matches(tmp));

}

else

luaL_argerror(state, 2, "material category object expected");

return 1;

}

static const luaL_Reg dfhack_matinfo_funcs[] = {

{ "find", dfhack_matinfo_find },

{ "decode", dfhack_matinfo_decode },

{ "getToken", dfhack_matinfo_getToken },

{ "toString", dfhack_matinfo_toString },

{ "getCraftClass", dfhack_matinfo_getCraftClass },

{ "matches", dfhack_matinfo_matches },

{ NULL, NULL }

};

static void OpenMatinfo(lua_State *state)

{

luaL_getsubtable(state, lua_gettop(state), "matinfo");

lua_dup(state);

lua_rawsetp(state, LUA_REGISTRYINDEX, &DFHACK_MATINFO_TOKEN);

lua_dup(state);

luaL_setfuncs(state, dfhack_matinfo_funcs, 1);

lua_dup(state);

lua_setfield(state, -2, "__index");

lua_pop(state, 1);

}

/**************

* Pen object *

**************/

static int DFHACK_PEN_TOKEN = 0;

void Lua::Push(lua_State *L, const Screen::Pen &info)

{

if (!info.valid())

{

lua_pushnil(L);

return;

}

Lua::make_lua_userdata<Pen>(L, info);

lua_rawgetp(L, LUA_REGISTRYINDEX, &DFHACK_PEN_TOKEN);

lua_setmetatable(L, -2);

}

static Pen *check_pen_native(lua_State *L, int index)

{

lua_rawgetp(L, LUA_REGISTRYINDEX, &DFHACK_PEN_TOKEN);

if (!lua_getmetatable(L, index) || !lua_rawequal(L, -1, -2))

luaL_argerror(L, index, "not a pen object");

lua_pop(L, 2);

return (Pen*)lua_touserdata(L, index);

}

void Lua::CheckPen(lua_State *L, Screen::Pen *pen, int index, bool allow_nil, bool allow_color)

{

index = lua_absindex(L, index);

luaL_checkany(L, index);

if (lua_isnil(L, index))

{

if (!allow_nil)

luaL_argerror(L, index, "nil pen not allowed");

*pen = Pen(0,0,0,-1);

}

else if (lua_isuserdata(L, index))

{

*pen = *check_pen_native(L, index);

}

else if (allow_color && lua_isnumber(L, index))

{

*pen = Pen(0, lua_tointeger(L, index)&15, 0);

}

else

{

luaL_checktype(L, index, LUA_TTABLE);

decode_pen(L, *pen, index);

}

}

static int adjust_pen(lua_State *L, bool no_copy)

{

lua_settop(L, 4);

Pen pen;

int iidx = 1;

Lua::CheckPen(L, &pen, 1, true, true);

if (!lua_isnil(L, 2) || !lua_isnil(L, 3) || !lua_isnil(L, 4))

{

if (lua_isnumber(L, 2) || lua_isnil(L, 2))

{

if (!pen.valid())

pen = Pen();

iidx = -1;

pen.fg = luaL_optint(L, 2, pen.fg) & 15;

pen.bg = luaL_optint(L, 3, pen.bg);

if (!lua_isnil(L, 4))

pen.bold = lua_toboolean(L, 4);

else if (!lua_isnil(L, 2))

{

pen.bold = !!(pen.fg & 8);

pen.fg &= 7;

}

}

else

{

iidx = 2;

Lua::CheckPen(L, &pen, 2, false, false);

}

}

if (no_copy && iidx > 0 && lua_isuserdata(L, iidx))

lua_pushvalue(L, iidx);

else

Lua::Push(L, pen);

return 1;

}

static int dfhack_pen_parse(lua_State *L)

{

return adjust_pen(L, true);

}

static int dfhack_pen_make(lua_State *L)

{

return adjust_pen(L, false);

}

static void make_pen_table(lua_State *L, Pen &pen)

{

if (!pen.valid())

luaL_error(L, "invalid pen state");

else

{

lua_newtable(L);

lua_pushinteger(L, (unsigned char)pen.ch); lua_setfield(L, -2, "ch");

lua_pushinteger(L, pen.fg); lua_setfield(L, -2, "fg");

lua_pushinteger(L, pen.bg); lua_setfield(L, -2, "bg");

lua_pushboolean(L, pen.bold); lua_setfield(L, -2, "bold");

if (pen.tile)

{

lua_pushinteger(L, pen.tile); lua_setfield(L, -2, "tile");

}

switch (pen.tile_mode) {

case Pen::CharColor:

lua_pushboolean(L, true); lua_setfield(L, -2, "tile_color");

break;

case Pen::TileColor:

lua_pushinteger(L, pen.tile_fg); lua_setfield(L, -2, "tile_fg");

lua_pushinteger(L, pen.tile_bg); lua_setfield(L, -2, "tile_bg");

break;

default:

lua_pushboolean(L, false); lua_setfield(L, -2, "tile_color");

break;

}

if (pen.keep_lower) {

lua_pushboolean(L, true);

lua_setfield(L, -2, "keep_lower");

}

if (pen.write_to_lower) {

lua_pushboolean(L, true);

lua_setfield(L, -2, "write_to_lower");

}

if (pen.top_of_text) {

lua_pushboolean(L, true);

lua_setfield(L, -2, "top_of_text");

}

if (pen.bottom_of_text) {

lua_pushboolean(L, true);

lua_setfield(L, -2, "bottom_of_text");

}

}

}

static void get_pen_mirror(lua_State *L, int idx)

{

lua_getuservalue(L, idx);

if (lua_isnil(L, -1))

{

lua_pop(L, 1);

Pen pen;

Lua::CheckPen(L, &pen, idx, false, false);

make_pen_table(L, pen);

lua_dup(L);

lua_setuservalue(L, idx);

}

}

static int dfhack_pen_index(lua_State *L)

{

lua_settop(L, 2);

luaL_checktype(L, 1, LUA_TUSERDATA);

// check metatable

if (!lua_getmetatable(L, 1))

luaL_argerror(L, 1, "must be a pen");

lua_pushvalue(L, 2);

lua_rawget(L, -2);

if (!lua_isnil(L, -1))

return 1;

// otherwise read from the mirror table, creating it if necessary

lua_settop(L, 2);

get_pen_mirror(L, 1);

lua_pushvalue(L, 2);

lua_rawget(L, -2);

return 1;

}

static int pen_pnext(lua_State *L)

{

lua_settop(L, 2); /* create a 2nd argument if there isn't one */

if (lua_next(L, lua_upvalueindex(1)))

return 2;

lua_pushnil(L);

return 1;

}

static int dfhack_pen_pairs(lua_State *L)

{

luaL_checktype(L, 1, LUA_TUSERDATA);

get_pen_mirror(L, 1);

lua_pushcclosure(L, pen_pnext, 1);

lua_pushnil(L);

lua_pushnil(L);

return 3;

}

const char *const pen_fields[] = {

"ch", "fg", "bold", "bg", "tile", "tile_color", "tile_fg", "tile_bg",

"keep_lower", "write_to_lower", "top_of_text", "bottom_of_text", NULL

};

static int dfhack_pen_newindex(lua_State *L)

{

lua_settop(L, 3);

luaL_checktype(L, 1, LUA_TUSERDATA);

int id = luaL_checkoption(L, 2, NULL, pen_fields);

int arg = 0;

Pen &pen = *check_pen_native(L, 1);

bool wipe_tile = false, wipe_tc = false;

switch (id) {

case 0:

if (lua_type(L, 3) != LUA_TNUMBER)

arg = (unsigned char)*luaL_checkstring(L, 3);

else

arg = luaL_checkint(L, 3);

pen.ch = arg;

lua_pushinteger(L, (unsigned char)pen.ch);

break;

case 1:

pen.fg = luaL_checkint(L, 3) & 15;

lua_pushinteger(L, pen.fg);

break;

case 2:

pen.bold = lua_toboolean(L, 3);

lua_pushboolean(L, pen.bold);

break;

case 3:

pen.bg = luaL_checkint(L, 3) & 15;

lua_pushinteger(L, pen.bg);

break;

case 4:

arg = lua_isnil(L, 3) ? 0 : luaL_checkint(L, 3);

if (arg < 0)

luaL_argerror(L, 3, "invalid tile index");

pen.tile = arg;

if (pen.tile)

lua_pushinteger(L, pen.tile);

else

lua_pushnil(L);

break;

case 5:

wipe_tile = (pen.tile_mode == Pen::TileColor);

pen.tile_mode = lua_toboolean(L, 3) ? Pen::CharColor : Pen::AsIs;

lua_pushboolean(L, pen.tile_mode == Pen::CharColor);

break;

case 6:

if (pen.tile_mode != Pen::TileColor) { wipe_tc = true; pen.tile_bg = 0; }

pen.tile_fg = luaL_checkint(L, 3) & 15;

pen.tile_mode = Pen::TileColor;

lua_pushinteger(L, pen.tile_fg);

break;

case 7:

if (pen.tile_mode != Pen::TileColor) { wipe_tc = true; pen.tile_fg = 7; }

pen.tile_bg = luaL_checkint(L, 3) & 15;

pen.tile_mode = Pen::TileColor;

lua_pushinteger(L, pen.tile_bg);

break;

case 8:

pen.keep_lower = lua_toboolean(L, 3);

lua_pushboolean(L, pen.keep_lower);

break;

case 9:

pen.write_to_lower = lua_toboolean(L, 3);

lua_pushboolean(L, pen.write_to_lower);

break;

case 10:

pen.top_of_text = lua_toboolean(L, 3);

lua_pushboolean(L, pen.top_of_text);

break;

case 11:

pen.bottom_of_text = lua_toboolean(L, 3);

lua_pushboolean(L, pen.bottom_of_text);

break;

}

lua_getuservalue(L, 1);

if (!lua_isnil(L, -1))

{

lua_remove(L, 3);

lua_insert(L, 2);

lua_rawset(L, 2);

if (wipe_tc) {

lua_pushnil(L); lua_setfield(L, 2, "tile_color");

lua_pushinteger(L, pen.tile_fg); lua_setfield(L, 2, "tile_fg");

lua_pushinteger(L, pen.tile_bg); lua_setfield(L, 2, "tile_bg");

}

if (wipe_tile) {

lua_pushnil(L); lua_setfield(L, 2, "tile_fg");

lua_pushnil(L); lua_setfield(L, 2, "tile_bg");

}

}

return 0;

}

static const luaL_Reg dfhack_pen_funcs[] = {

{ "parse", dfhack_pen_parse },

{ "make", dfhack_pen_make },

{ "__index", dfhack_pen_index },

{ "__pairs", dfhack_pen_pairs },

{ "__newindex", dfhack_pen_newindex },

{ NULL, NULL }

};

static void OpenPen(lua_State *state)

{

luaL_getsubtable(state, lua_gettop(state), "pen");

lua_dup(state);

lua_rawsetp(state, LUA_REGISTRYINDEX, &DFHACK_PEN_TOKEN);

luaL_setfuncs(state, dfhack_pen_funcs, 0);

lua_pop(state, 1);

}

/******************

* PenArray object *

******************/

static int DFHACK_PENARRAY_TOKEN = 0;

using Screen::PenArray;

static PenArray *check_penarray_native(lua_State *L, int index)

{

lua_rawgetp(L, LUA_REGISTRYINDEX, &DFHACK_PENARRAY_TOKEN);

if (!lua_getmetatable(L, index) || !lua_rawequal(L, -1, -2))

luaL_argerror(L, index, "not a penarray object");

lua_pop(L, 2);

return (PenArray*)lua_touserdata(L, index);

}

static int dfhack_penarray_new(lua_State *L)

{

int bufwidth = luaL_checkint(L, 1);

int bufheight = luaL_checkint(L, 2);

void *buf = lua_newuserdata(L, sizeof(PenArray) + (sizeof(Pen) * bufwidth * bufheight));

new (buf) PenArray(bufwidth, bufheight, buf);

lua_rawgetp(L, LUA_REGISTRYINDEX, &DFHACK_PENARRAY_TOKEN);

lua_setmetatable(L, -2);

return 1;

}

static int dfhack_penarray_clear(lua_State *L)

{

PenArray *parr = check_penarray_native(L, 1);

parr->clear();

return 0;

}