/* NetHack 5.0 nhlua.c $NHDT-Date: 1781973059 2026/06/20 16:30:59 $ $NHDT-Branch: NetHack-5.0 $:$NHDT-Revision: 1.168 $ */

/* Copyright (c) 2018 by Pasi Kallinen */

/* NetHack may be freely redistributed. See license for details. */

#include "hack.h"

#include "dlb.h"

/* Sanity check: sandbox may be version specific. Minimum and maximum LUA_VERSION_NUM

* expected by this version of NetHack. */

#define NHL_MIN_VERSION_NUM_EXPECTED 505

#define NHL_MAX_VERSION_NUM_EXPECTED 505

#ifdef NHL_SANDBOX

#include <setjmp.h>

#endif

/* */

struct e;

#ifndef SFCTOOL

/* lua_CFunction prototypes */

#ifdef DUMPLOG

staticfn int nhl_dump_fmtstr(lua_State *);

#endif /* DUMPLOG */

staticfn int nhl_dnum_name(lua_State *);

staticfn int nhl_int_to_pm_name(lua_State *);

staticfn int nhl_int_to_obj_name(lua_State *);

staticfn int nhl_stairways(lua_State *);

staticfn int nhl_pushkey(lua_State *);

staticfn int nhl_doturn(lua_State *);

staticfn int nhl_debug_flags(lua_State *);

staticfn int nhl_flip_level(lua_State *);

staticfn int nhl_timer_has_at(lua_State *);

staticfn int nhl_timer_peek_at(lua_State *);

staticfn int nhl_timer_stop_at(lua_State *);

staticfn int nhl_timer_start_at(lua_State *);

staticfn int nhl_get_cmd_key(lua_State *);

staticfn int nhl_callback(lua_State *);

staticfn int nhl_gamestate(lua_State *);

staticfn int nhl_test(lua_State *);

staticfn int nhl_getmap(lua_State *);

staticfn char splev_typ2chr(schar);

staticfn int nhl_gettrap(lua_State *);

staticfn int nhl_deltrap(lua_State *);

#if 0

staticfn int nhl_setmap(lua_State *);

#endif

staticfn int nhl_impossible(lua_State *);

staticfn int nhl_pline(lua_State *);

staticfn int nhl_verbalize(lua_State *);

staticfn int nhl_parse_config(lua_State *);

staticfn int nhl_menu(lua_State *);

staticfn int nhl_text(lua_State *);

staticfn int nhl_getlin(lua_State *);

staticfn int nhl_makeplural(lua_State *);

staticfn int nhl_makesingular(lua_State *);

staticfn int nhl_s_suffix(lua_State *);

staticfn int nhl_ing_suffix(lua_State *);

staticfn int nhl_an(lua_State *);

staticfn int nhl_rn2(lua_State *);

staticfn int nhl_random(lua_State *);

staticfn int nhl_level_difficulty(lua_State *);

staticfn int nhl_is_genocided(lua_State *);

staticfn int nhl_get_debug_themerm_name(lua_State *);

staticfn void init_nhc_data(lua_State *);

staticfn int nhl_push_anything(lua_State *, int, void *);

staticfn int nhl_meta_u_index(lua_State *);

staticfn int nhl_meta_u_newindex(lua_State *);

staticfn int nhl_u_clear_inventory(lua_State *);

staticfn int nhl_u_giveobj(lua_State *);

staticfn void init_u_data(lua_State *);

#ifdef notyet

staticfn int nhl_set_package_path(lua_State *, const char *);

#endif

staticfn int traceback_handler(lua_State *);

staticfn uint32_t nhl_getmeminuse(lua_State *);

#ifdef NHL_SANDBOX

staticfn void nhlL_openlibs(lua_State *, uint32_t);

#endif

staticfn void *nhl_alloc(void *, void *, size_t, size_t);

staticfn lua_State *nhlL_newstate (nhl_sandbox_info *, const char *);

staticfn void end_luapat(void);

staticfn int nhl_get_config(lua_State *);

staticfn int nhl_variable(lua_State *);

staticfn void nhl_clearfromtable(lua_State *, int, int, struct e *);

staticfn void nhl_warn(void *, const char *, int);

staticfn void nhl_clearfromtable(lua_State *, int, int, struct e *);

staticfn int nhl_panic(lua_State *);

staticfn void nhl_hookfn(lua_State *, lua_Debug *);

#endif /* !SFCTOOL */

#ifndef SFCTOOL

static const char *const nhcore_call_names[NUM_NHCORE_CALLS] = {

"start_new_game",

"restore_old_game",

"moveloop_turn",

"game_exit",

"getpos_tip",

"enter_tutorial",

"leave_tutorial",

};

static boolean nhcore_call_available[NUM_NHCORE_CALLS];

#endif

/* internal structure that hangs off L->ud (but use lua_getallocf() )

* Note that we use it for both memory use tracking and instruction counting.

*/

typedef struct nhl_user_data {

lua_State *L; /* because the allocator needs it */

uint32_t flags; /* from nhl_sandbox_info */

uint32_t memlimit;

uint32_t steps; /* current counter */

uint32_t osteps; /* original steps value */

uint32_t perpcall; /* per pcall steps value */

/* stats */

uint32_t statctr; /* stats step reload count */

int sid; /* id number (per state) */

const char *name; /* for stats logging (per pcall) */

#ifdef NHL_SANDBOX

jmp_buf jb;

#endif

} nhl_user_data;

#ifndef SFCTOOL

static lua_State *luapat; /* instance for file pattern matching */

void

l_nhcore_init(void)

{

nhl_sandbox_info sbi = { NHL_SB_SAFE, 1 * 1024 * 1024, 0,

1 * 1024 * 1024 };

if ((gl.luacore = nhl_init(&sbi)) != 0) {

if (!nhl_loadlua(gl.luacore, "nhcore.lua")) {

gl.luacore = (lua_State *) 0;

} else {

int i;

for (i = 0; i < NUM_NHCORE_CALLS; i++)

nhcore_call_available[i] = TRUE;

}

} else

impossible("l_nhcore_init failed");

}

void

l_nhcore_done(void)

{

if (gl.luacore) {

nhl_done(gl.luacore);

gl.luacore = 0;

}

end_luapat();

free_questpager();

}

void

l_nhcore_call(int callidx)

{

int ltyp;

if (callidx < 0 || callidx >= NUM_NHCORE_CALLS || !gl.luacore

|| !nhcore_call_available[callidx])

return;

lua_getglobal(gl.luacore, "nhcore");

if (!lua_istable(gl.luacore, -1)) {

/*impossible("nhcore is not a lua table");*/

nhl_done(gl.luacore);

gl.luacore = 0;

return;

}

lua_getfield(gl.luacore, -1, nhcore_call_names[callidx]);

ltyp = lua_type(gl.luacore, -1);

if (ltyp == LUA_TFUNCTION) {

nhl_pcall_handle(gl.luacore, 0, 1, "l_nhcore_call", NHLpa_panic);

} else {

/*impossible("nhcore.%s is not a lua function",

nhcore_call_names[callidx]);*/

nhcore_call_available[callidx] = FALSE;

}

}

DISABLE_WARNING_UNREACHABLE_CODE

ATTRNORETURN void

nhl_error(lua_State *L, const char *msg)

{

lua_Debug ar;

char buf[BUFSZ * 2];

lua_getstack(L, 1, &ar);

lua_getinfo(L, "lS", &ar);

Sprintf(buf, "%s (line %d ", msg, ar.currentline);

Sprintf(eos(buf), "%.*s)",

/* (max length of ar.short_src is actually LUA_IDSIZE

so this is overkill for it, but crucial for ar.source) */

(int) (sizeof buf - (strlen(buf) + sizeof ")")),

ar.short_src); /* (used to be 'ar.source' here) */

lua_pushstring(L, buf);

#if 0 /* defined(PANICTRACE) && !defined(NO_SIGNALS) */

panictrace_setsignals(FALSE);

#endif

(void) lua_error(L);

/*NOTREACHED*/

}

RESTORE_WARNING_UNREACHABLE_CODE

/* Check that parameters are nothing but single table,

or if no parameters given, put empty table there */

void

lcheck_param_table(lua_State *L)

{

int argc = lua_gettop(L);

if (argc < 1)

lua_createtable(L, 0, 0);

/* discard any extra arguments passed in */

lua_settop(L, 1);

luaL_checktype(L, 1, LUA_TTABLE);

}

DISABLE_WARNING_UNREACHABLE_CODE

schar

get_table_mapchr(lua_State *L, const char *name)

{

char *ter;

xint8 typ;

ter = get_table_str(L, name);

typ = check_mapchr(ter);

if (typ == INVALID_TYPE)

nhl_error(L, "Erroneous map char");

if (ter)

free(ter);

return typ;

}

schar

get_table_mapchr_opt(lua_State *L, const char *name, schar defval)

{

char *ter;

xint8 typ;

ter = get_table_str_opt(L, name, emptystr);

if (ter && *ter) {

typ = (xint8) check_mapchr(ter);

if (typ == INVALID_TYPE)

nhl_error(L, "Erroneous map char");

} else

typ = (xint8) defval;

if (ter)

free(ter);

return typ;

}

short

nhl_get_timertype(lua_State *L, int idx)

{

/* these are in the same order as enum timeout_types in timeout.h and

ttable timeout_funcs[] in timeout.c, although not spelled the same */

static const char *const timerstr[NUM_TIME_FUNCS + 1] = {

"rot-organic", "rot-corpse", "revive-mon", "zombify-mon",

"burn-obj", "hatch-egg", "fig-transform", "shrink-glob",

"melt-ice", NULL

};

short ret = luaL_checkoption(L, idx, NULL, timerstr);

if (ret < 0 || ret >= NUM_TIME_FUNCS)

nhl_error(L, "Unknown timer type");

return ret;

}

RESTORE_WARNING_UNREACHABLE_CODE

void

nhl_add_table_entry_int(lua_State *L, const char *name, lua_Integer value)

{

lua_pushstring(L, name);

lua_pushinteger(L, value);

lua_rawset(L, -3);

}

void

nhl_add_table_entry_char(lua_State *L, const char *name, char value)

{

char buf[2];

Sprintf(buf, "%c", value);

lua_pushstring(L, name);

lua_pushstring(L, buf);

lua_rawset(L, -3);

}

void

nhl_add_table_entry_str(lua_State *L, const char *name, const char *value)

{

lua_pushstring(L, name);

lua_pushstring(L, value);

lua_rawset(L, -3);

}

void

nhl_add_table_entry_bool(lua_State *L, const char *name, boolean value)

{

lua_pushstring(L, name);

lua_pushboolean(L, value);

lua_rawset(L, -3);

}

void

nhl_add_table_entry_region(lua_State *L, const char *name, coordxy x1,

coordxy y1, coordxy x2, coordxy y2)

{

lua_pushstring(L, name);

lua_newtable(L);

nhl_add_table_entry_int(L, "x1", x1);

nhl_add_table_entry_int(L, "y1", y1);

nhl_add_table_entry_int(L, "x2", x2);

nhl_add_table_entry_int(L, "y2", y2);

lua_rawset(L, -3);

}

/* converting from special level "map character" to levl location type

and back. order here is important. */

static const struct {

char ch;

schar typ;

} char2typ[] = {

{ ' ', STONE },

{ '#', CORR },

{ '.', ROOM },

{ '-', HWALL },

{ '-', TLCORNER },

{ '-', TRCORNER },

{ '-', BLCORNER },

{ '-', BRCORNER },

{ '-', CROSSWALL },

{ '-', TUWALL },

{ '-', TDWALL },

{ '-', TLWALL },

{ '-', TRWALL },

{ '-', DBWALL },

{ '|', VWALL },

{ '+', DOOR },

{ 'A', AIR },

{ 'C', CLOUD },

{ 'S', SDOOR },

{ 'H', SCORR },

{ '{', FOUNTAIN },

{ '\\', THRONE },

{ 'K', SINK },

{ '}', MOAT },

{ 'P', POOL },

{ 'L', LAVAPOOL },

{ 'Z', LAVAWALL },

{ 'I', ICE },

{ 'W', WATER },

{ 'T', TREE },

{ 'F', IRONBARS }, /* Fe = iron */

{ 'x', MAX_TYPE }, /* "see-through" */

{ 'B', CROSSWALL }, /* hack: boundary location */

{ 'w', MATCH_WALL }, /* IS_STWALL() */

{ '\0', STONE },

};

schar

splev_chr2typ(char c)

{

int i;

for (i = 0; char2typ[i].ch; i++)

if (c == char2typ[i].ch)

return char2typ[i].typ;

return (INVALID_TYPE);

}

schar

check_mapchr(const char *s)

{

if (s && strlen(s) == 1)

return splev_chr2typ(s[0]);

return INVALID_TYPE;

}

staticfn char

splev_typ2chr(schar typ)

{

int i;

for (i = 0; char2typ[i].typ < MAX_TYPE; i++)

if (typ == char2typ[i].typ)

return char2typ[i].ch;

return 'x';

}

DISABLE_WARNING_UNREACHABLE_CODE

/* local t = nh.gettrap(x,y); */

/* local t = nh.gettrap({ x = 10, y = 10 }); */

staticfn int

nhl_gettrap(lua_State *L)

{

lua_Integer lx, ly;

coordxy x, y;

if (!nhl_get_xy_params(L, &lx, &ly)) {

nhl_error(L, "Incorrect arguments");

/*NOTREACHED*/

return 0;

}

x = (coordxy) lx;

y = (coordxy) ly;

cvt_to_abscoord(&x, &y);

if (isok(x, y)) {

struct trap *ttmp = t_at(x, y);

if (ttmp) {

lua_newtable(L);

nhl_add_table_entry_int(L, "tx", ttmp->tx);

nhl_add_table_entry_int(L, "ty", ttmp->ty);

nhl_add_table_entry_int(L, "ttyp", ttmp->ttyp);

nhl_add_table_entry_str(L, "ttyp_name",

get_trapname_bytype(ttmp->ttyp));

nhl_add_table_entry_bool(L, "tseen", ttmp->tseen);

nhl_add_table_entry_bool(L, "madeby_u", ttmp->madeby_u);

nhl_add_table_entry_bool(L, "once", ttmp->once);

switch (ttmp->ttyp) {

case SQKY_BOARD:

nhl_add_table_entry_int(L, "tnote", ttmp->tnote);

break;

case ROLLING_BOULDER_TRAP:

nhl_add_table_entry_int(L, "launchx", ttmp->launch.x);

nhl_add_table_entry_int(L, "launchy", ttmp->launch.y);

nhl_add_table_entry_int(L, "launch2x", ttmp->launch2.x);

nhl_add_table_entry_int(L, "launch2y", ttmp->launch2.y);

break;

case PIT:

case SPIKED_PIT:

nhl_add_table_entry_int(L, "conjoined", ttmp->conjoined);

break;

}

return 1;

} else {

nhl_error(L, "No trap at location");

}

} else {

nhl_error(L, "Coordinates out of range");

}

return 0;

}

/* nh.deltrap(x,y); nh.deltrap({ x = 10, y = 15 }); */

staticfn int

nhl_deltrap(lua_State *L)

{

lua_Integer lx, ly;

coordxy x, y;

if (!nhl_get_xy_params(L, &lx, &ly)) {

nhl_error(L, "Incorrect arguments");

/*NOTREACHED*/

return 0;

}

x = (coordxy) lx;

y = (coordxy) ly;

cvt_to_abscoord(&x, &y);

if (isok(x, y)) {

struct trap *ttmp = t_at(x, y);

if (ttmp)

deltrap(ttmp);

}

return 0;

}

RESTORE_WARNING_UNREACHABLE_CODE

/* get parameters (XX,YY) or ({ x = XX, y = YY }) or ({ XX, YY }),

and set the x and y values.

return TRUE if there are such params in the stack.

Note that this does not adjust the values of x and y at all from what is

specified in the level file; so, it returns absolute coordinates rather

than map-relative coordinates. Callers of this function must decide if

they want to interpret the values as absolute or as map-relative, and

adjust accordingly.

*/

boolean

nhl_get_xy_params(lua_State *L, lua_Integer *x, lua_Integer *y)

{

int argc = lua_gettop(L);

boolean ret = FALSE;

if (argc == 2) {

*x = lua_tointeger(L, 1);

*y = lua_tointeger(L, 2);

ret = TRUE;

} else if (argc == 1 && lua_type(L, 1) == LUA_TTABLE) {

lua_Integer ax, ay;

ret = get_coord(L, 1, &ax, &ay);

*x = ax;

*y = ay;

}

return ret;

}

DISABLE_WARNING_UNREACHABLE_CODE

/* local loc = nh.getmap(x,y); */

/* local loc = nh.getmap({ x = 10, y = 35 }); */

staticfn int

nhl_getmap(lua_State *L)

{

lua_Integer lx, ly;

coordxy x, y;

if (!nhl_get_xy_params(L, &lx, &ly)) {

nhl_error(L, "Incorrect arguments");

return 0;

}

x = (coordxy) lx;

y = (coordxy) ly;

cvt_to_abscoord(&x, &y);

if (isok(x, y)) {

char buf[BUFSZ];

lua_newtable(L);

/* FIXME: some should be boolean values */

nhl_add_table_entry_int(L, "glyph", levl[x][y].glyph);

nhl_add_table_entry_int(L, "typ", levl[x][y].typ);

nhl_add_table_entry_str(L, "typ_name",

levltyp_to_name(levl[x][y].typ));

Sprintf(buf, "%c", splev_typ2chr(levl[x][y].typ));

nhl_add_table_entry_str(L, "mapchr", buf);

nhl_add_table_entry_int(L, "seenv", levl[x][y].seenv);

nhl_add_table_entry_bool(L, "horizontal", levl[x][y].horizontal);

nhl_add_table_entry_bool(L, "lit", levl[x][y].lit);

nhl_add_table_entry_bool(L, "waslit", levl[x][y].waslit);

nhl_add_table_entry_int(L, "roomno", levl[x][y].roomno);

nhl_add_table_entry_bool(L, "edge", levl[x][y].edge);

nhl_add_table_entry_bool(L, "candig", levl[x][y].candig);

nhl_add_table_entry_bool(L, "has_trap", t_at(x, y) ? 1 : 0);

/* TODO: FIXME: levl[x][y].flags */

lua_pushliteral(L, "flags");

lua_newtable(L);

if (IS_DOOR(levl[x][y].typ)) {

nhl_add_table_entry_bool(L, "nodoor",

(levl[x][y].flags == D_NODOOR));

nhl_add_table_entry_bool(L, "broken",

(levl[x][y].flags & D_BROKEN));

nhl_add_table_entry_bool(L, "isopen",

(levl[x][y].flags & D_ISOPEN));

nhl_add_table_entry_bool(L, "closed",

(levl[x][y].flags & D_CLOSED));

nhl_add_table_entry_bool(L, "locked",

(levl[x][y].flags & D_LOCKED));

nhl_add_table_entry_bool(L, "trapped",

(levl[x][y].flags & D_TRAPPED));

} else if (IS_ALTAR(levl[x][y].typ)) {

/* TODO: bits 0, 1, 2 */

nhl_add_table_entry_bool(L, "shrine",

(levl[x][y].flags & AM_SHRINE));

} else if (IS_THRONE(levl[x][y].typ)) {

nhl_add_table_entry_bool(L, "looted",

(levl[x][y].flags & T_LOOTED));

} else if (levl[x][y].typ == TREE) {

nhl_add_table_entry_bool(L, "looted",

(levl[x][y].flags & TREE_LOOTED));

nhl_add_table_entry_bool(L, "swarm",

(levl[x][y].flags & TREE_SWARM));

} else if (IS_FOUNTAIN(levl[x][y].typ)) {

nhl_add_table_entry_bool(L, "looted",

(levl[x][y].flags & F_LOOTED));

nhl_add_table_entry_bool(L, "warned",

(levl[x][y].flags & F_WARNED));

} else if (IS_SINK(levl[x][y].typ)) {

nhl_add_table_entry_bool(L, "pudding",

(levl[x][y].flags & S_LPUDDING));

nhl_add_table_entry_bool(L, "dishwasher",

(levl[x][y].flags & S_LDWASHER));

nhl_add_table_entry_bool(L, "ring", (levl[x][y].flags & S_LRING));

}

/* TODO: drawbridges, walls, ladders, room=>ICED_xxx */

lua_settable(L, -3);

return 1;

} else {

/* TODO: return zerorm instead? */

nhl_error(L, "Coordinates out of range");

return 0;

}

}

/* impossible("Error!") */

staticfn int

nhl_impossible(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1)

impossible("%s", luaL_checkstring(L, 1));

else

nhl_error(L, "Wrong args");

return 0;

}

/* pline("It hits!") */

/* pline("It hits!", true) */

staticfn int

nhl_pline(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1 || argc == 2) {

pline("%s", luaL_checkstring(L, 1));

if (lua_toboolean(L, 2))

display_nhwindow(WIN_MESSAGE, TRUE); /* --more-- */

} else

nhl_error(L, "Wrong args");

return 0;

}

/* verbalize("Fool!") */

staticfn int

nhl_verbalize(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1)

verbalize("%s", luaL_checkstring(L, 1));

else

nhl_error(L, "Wrong args");

return 0;

}

/* parse_config("OPTIONS=!color") */

staticfn int

nhl_parse_config(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1)

parse_conf_str(luaL_checkstring(L, 1), parse_config_line);

else

nhl_error(L, "Wrong args");

return 0;

}

/* local windowtype = get_config("windowtype"); */

staticfn int

nhl_get_config(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1) {

lua_pushstring(L, get_option_value(luaL_checkstring(L, 1), TRUE));

return 1;

} else

nhl_error(L, "Wrong args");

return 0;

}

/*

str = getlin("What do you want to call this dungeon level?");

*/

staticfn int

nhl_getlin(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1) {

const char *prompt = luaL_checkstring(L, 1);

char buf[BUFSZ];

getlin(prompt, buf);

lua_pushstring(L, buf);

return 1;

}

nhl_error(L, "Wrong args");

/*NOTREACHED*/

return 0;

}

/*

selected = menu("prompt",default,pickX,{"a"="option a", "b"="option b",...})

pickX = 0,1,2, or "none", "one", "any" (PICK_X in code)

selected = menu("prompt", default, pickX,

{{key:"a", text:"option a"},{key:"b", text:"option b"},... })

*/

staticfn int

nhl_menu(lua_State *L)

{

static const char *const pickX[] = { "none", "one", "any" }; /* PICK_x */

int argc = lua_gettop(L);

const char *prompt;

const char *defval = "";

int pick = PICK_ONE, pick_cnt;

winid tmpwin;

anything any;

menu_item *picks = (menu_item *) 0;

int clr = NO_COLOR;

if (argc < 2 || argc > 4) {

nhl_error(L, "Wrong args");

/*NOTREACHED*/

return 0;

}

prompt = luaL_checkstring(L, 1);

if (lua_isstring(L, 2))

defval = luaL_checkstring(L, 2);

if (lua_isstring(L, 3))

pick = luaL_checkoption(L, 3, "one", pickX);

luaL_checktype(L, argc, LUA_TTABLE);

tmpwin = create_nhwindow(NHW_MENU);

start_menu(tmpwin, MENU_BEHAVE_STANDARD);

lua_pushnil(L); /* first key */

while (lua_next(L, argc) != 0) {

const char *str = "";

const char *key = "";

/* key @ index -2, value @ index -1 */

if (lua_istable(L, -1)) {

lua_pushliteral(L, "key");

lua_gettable(L, -2);

key = lua_tostring(L, -1);

lua_pop(L, 1);

lua_pushliteral(L, "text");

lua_gettable(L, -2);

str = lua_tostring(L, -1);

lua_pop(L, 1);

/* TODO: glyph, attr, accel, group accel (all optional) */

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

str = luaL_checkstring(L, -1);

key = luaL_checkstring(L, -2);

}

any = cg.zeroany;

if (*key)

any.a_char = key[0];

add_menu(tmpwin, &nul_glyphinfo, &any, 0, 0, ATR_NONE, clr, str,

(*defval && *key && defval[0] == key[0])

? MENU_ITEMFLAGS_SELECTED

: MENU_ITEMFLAGS_NONE);

lua_pop(L, 1); /* removes 'value'; keeps 'key' for next iteration */

}

end_menu(tmpwin, prompt);

pick_cnt = select_menu(tmpwin, pick, &picks);

destroy_nhwindow(tmpwin);

if (pick_cnt > 0) {

char buf[2];

buf[0] = picks[0].item.a_char;

if (pick == PICK_ONE && pick_cnt > 1 && *defval

&& defval[0] == picks[0].item.a_char)

buf[0] = picks[1].item.a_char;

buf[1] = '\0';

lua_pushstring(L, buf);

/* TODO: pick any */

} else {

char buf[2];

buf[0] = defval[0];

buf[1] = '\0';

lua_pushstring(L, buf);

}

return 1;

}

/* text("foo\nbar\nbaz") */

staticfn int

nhl_text(lua_State *L)

{

int argc = lua_gettop(L);

if (argc > 0) {

menu_item *picks = (menu_item *) 0;

winid tmpwin;

tmpwin = create_nhwindow(NHW_MENU);

start_menu(tmpwin, MENU_BEHAVE_STANDARD);

while (lua_gettop(L) > 0) {

char *ostr = dupstr(luaL_checkstring(L, 1));

char *ptr, *str = ostr;

char *lstr = str + strlen(str) - 1;

do {

char *nlp = strchr(str, '\n');

if (nlp && (nlp - str) <= 76) {

ptr = nlp;

} else {

ptr = str + 76;

if (ptr > lstr)

ptr = lstr;

}

while ((ptr > str) && !(*ptr == ' ' || *ptr == '\n'))

ptr--;

*ptr = '\0';

add_menu_str(tmpwin, str);

str = ptr + 1;

} while (*str && str <= lstr);

lua_pop(L, 1);

free(ostr);

}

end_menu(tmpwin, (char *) 0);

(void) select_menu(tmpwin, PICK_NONE, &picks);

destroy_nhwindow(tmpwin);

}

return 0;

}

/* makeplural("zorkmid") */

staticfn int

nhl_makeplural(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1)

lua_pushstring(L, makeplural(luaL_checkstring(L, 1)));

else

nhl_error(L, "Wrong args");

return 1;

}

/* makesingular("zorkmids") */

staticfn int

nhl_makesingular(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1)

lua_pushstring(L, makesingular(luaL_checkstring(L, 1)));

else

nhl_error(L, "Wrong args");

return 1;

}

/* s_suffix("foo") */

staticfn int

nhl_s_suffix(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1)

lua_pushstring(L, s_suffix(luaL_checkstring(L, 1)));

else

nhl_error(L, "Wrong args");

return 1;

}

/* ing_suffix("foo") */

staticfn int

nhl_ing_suffix(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1)

lua_pushstring(L, ing_suffix(luaL_checkstring(L, 1)));

else

nhl_error(L, "Wrong args");

return 1;

}

/* an("foo") */

staticfn int

nhl_an(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1)

lua_pushstring(L, an(luaL_checkstring(L, 1)));

else

nhl_error(L, "Wrong args");

return 1;

}

/* rn2(10) */

staticfn int

nhl_rn2(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1)

lua_pushinteger(L, rn2((int) luaL_checkinteger(L, 1)));

else

nhl_error(L, "Wrong args");

return 1;

}

/* random(10); -- is the same as rn2(10); */

/* random(5,8); -- same as 5 + rn2(8); */

staticfn int

nhl_random(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1)

lua_pushinteger(L, rn2((int) luaL_checkinteger(L, 1)));

else if (argc == 2)

lua_pushinteger(L, luaL_checkinteger(L, 1)

+ rn2((int) luaL_checkinteger(L, 2)));

else

nhl_error(L, "Wrong args");

return 1;

}

/* level_difficulty() */

staticfn int

nhl_level_difficulty(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 0) {

lua_pushinteger(L, level_difficulty());

} else {

nhl_error(L, "level_difficulty should not have any args");

}

return 1;

}

/* local x = nh.is_genocided("vampire") */

staticfn int

nhl_is_genocided(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1) {

const char *paramstr = luaL_checkstring(L, 1);

int mgend;

int i = name_to_mon(paramstr, &mgend);

lua_pushboolean(L, (i != NON_PM)

&& (svm.mvitals[i].mvflags & G_GENOD)

? TRUE : FALSE);

} else {

nhl_error(L, "Wrong args");

}

return 1;

}

/* local debug_themerm = nh.debug_themerm(isfill)

* if isfill is false, returns value of env variable THEMERM

* if isfill is true, returns value of env variable THEMERMFILL

* return nil if not in wizard mode or the variable isn't set */

staticfn int

nhl_get_debug_themerm_name(lua_State *L)

{

int argc = lua_gettop(L);

if (argc == 1) {

char *dbg_themerm = (char *) 0;

boolean is_fill = lua_toboolean(L, 1);

lua_pop(L, 1);

if (wizard)

dbg_themerm = getenv(is_fill ? "THEMERMFILL" : "THEMERM");

if (!dbg_themerm || !*dbg_themerm) {

lua_pushnil(L);

} else {

lua_pushstring(L, dbg_themerm);

}