/* NetHack 5.0 cmd.c $NHDT-Date: 1781973043 2026/06/20 16:30:43 $ $NHDT-Branch: NetHack-5.0 $:$NHDT-Revision: 1.772 $ */

/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */

/*-Copyright (c) Robert Patrick Rankin, 2013. */

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

#include "hack.h"

#include "func_tab.h"

#ifdef UNIX

/*

* Some systems may have getchar() return EOF for various reasons, and

* we should not quit before seeing at least NR_OF_EOFS consecutive EOFs.

*/

#if defined(SYSV) || defined(DGUX) || defined(HPUX)

#define NR_OF_EOFS 20

#endif

#endif

#ifdef DUMB /* stuff commented out in extern.h, but needed here */

extern int doapply(void); /**/

extern int dorub(void); /**/

extern int dojump(void); /**/

extern int doextlist(void); /**/

extern int enter_explore_mode(void); /**/

extern int dodrop(void); /**/

extern int doddrop(void); /**/

extern int dodown(void); /**/

extern int doup(void); /**/

extern int donull(void); /**/

extern int dowipe(void); /**/

extern int docallcnd(void); /**/

extern int dotakeoff(void); /**/

extern int doremring(void); /**/

extern int dowear(void); /**/

extern int doputon(void); /**/

extern int doddoremarm(void); /**/

extern int dokick(void); /**/

extern int dofire(void); /**/

extern int dothrow(void); /**/

extern int doeat(void); /**/

extern int done2(void); /**/

extern int dovanquished(void); /**/

extern int doengrave(void); /**/

extern int dopickup(void); /**/

extern int ddoinv(void); /**/

extern int dotypeinv(void); /**/

extern int dolook(void); /**/

extern int doprgold(void); /**/

extern int doprwep(void); /**/

extern int doprarm(void); /**/

extern int doprring(void); /**/

extern int dopramulet(void); /**/

extern int doprtool(void); /**/

extern int dosuspend(void); /**/

extern int doforce(void); /**/

extern int doopen(void); /**/

extern int doclose(void); /**/

extern int dosh(void); /**/

extern int dodiscovered(void); /**/

extern int doclassdisco(void); /**/

extern int doset_simple(void); /**/

extern int doset(void); /**/

extern int dotogglepickup(void); /**/

extern int dowhatis(void); /**/

extern int doquickwhatis(void); /**/

extern int dowhatdoes(void); /**/

extern int dohelp(void); /**/

extern int dohistory(void); /**/

extern int doloot(void); /**/

extern int dodrink(void); /**/

extern int dodip(void); /**/

extern int dosacrifice(void); /**/

extern int dopray(void); /**/

extern int dotip(void); /**/

extern int doturn(void); /**/

extern int doredraw(void); /**/

extern int doread(void); /**/

extern int dosave(void); /**/

extern int dosearch(void); /**/

extern int doidtrap(void); /**/

extern int dopay(void); /**/

extern int dosit(void); /**/

extern int dotalk(void); /**/

extern int docast(void); /**/

extern int dovspell(void); /**/

extern int dotelecmd(void); /**/

extern int dountrap(void); /**/

extern int doversion(void); /**/

extern int doextversion(void); /**/

extern int doswapweapon(void); /**/

extern int dowield(void); /**/

extern int dowieldquiver(void); /**/

extern int dozap(void); /**/

extern int doorganize(void); /**/

#endif /* DUMB */

staticfn struct Cmd_bind *cmdbind_get(uchar);

staticfn void cmdbind_add(uchar, const struct ext_func_tab *, boolean);

staticfn void cmdbind_remove(uchar);

staticfn void cmdbind_swapkeys(uchar, uchar);

staticfn int dosuspend_core(void);

staticfn int dosh_core(void);

staticfn int doherecmdmenu(void);

staticfn int dotherecmdmenu(void);

staticfn int doprev_message(void);

staticfn int timed_occupation(void);

staticfn boolean can_do_extcmd(const struct ext_func_tab *);

staticfn int dotravel(void);

staticfn int dotravel_target(void);

staticfn int doclicklook(void);

staticfn boolean yn_menuable_resp(const char *);

staticfn void yn_func_menu_opt(winid, char, const char *, char);

staticfn boolean yn_function_menu(const char *, const char *, char, char *);

staticfn int domouseaction(void);

staticfn int doterrain(void);

staticfn boolean u_have_seen_whole_selection(struct selectionvar *);

staticfn boolean u_have_seen_bounds_selection(struct selectionvar *);

staticfn boolean u_can_see_whole_selection(struct selectionvar *);

staticfn int dolookaround_floodfill_findroom(coordxy, coordxy);

staticfn void lookaround_known_room(coordxy, coordxy);

#if defined(__BORLANDC__) && !defined(_WIN32)

extern void show_borlandc_stats(winid);

#endif

staticfn boolean accept_menu_prefix(const struct ext_func_tab *);

staticfn void reset_cmd_vars(boolean);

staticfn void mcmd_addmenu(winid, int, const char *);

staticfn int there_cmd_menu_self(winid, coordxy, coordxy, int *);

staticfn int there_cmd_menu_next2u(winid, coordxy, coordxy, int, int *);

staticfn int there_cmd_menu_far(winid, coordxy, coordxy, int);

staticfn int there_cmd_menu_common(winid, coordxy, coordxy, int, int *);

staticfn void act_on_act(int, coordxy, coordxy);

staticfn char there_cmd_menu(coordxy, coordxy, int);

staticfn char here_cmd_menu(void);

staticfn char readchar_core(coordxy *, coordxy *, int *);

staticfn int parse(void);

staticfn void show_direction_keys(winid, char, boolean);

staticfn boolean help_dir(char, uchar, const char *);

staticfn void handler_rebind_keys_add(boolean);

staticfn boolean bind_key_fn(uchar, int (*)(void));

staticfn void commands_init(void);

staticfn boolean keylist_func_has_key(const struct ext_func_tab *, boolean *);

staticfn int keylist_putcmds(winid, boolean, int, int, boolean *);

staticfn const char *spkey_name(int);

staticfn int (*timed_occ_fn)(void);

staticfn char *doc_extcmd_flagstr(winid, const struct ext_func_tab *);

staticfn int dummyfunction(void);

static const char *readchar_queue = "";

/* for rejecting attempts to use wizard mode commands

* Also used in wizcmds.c */

const char unavailcmd[] = "Unavailable command '%s'.";

/* for rejecting #if !SHELL, !SUSPEND */

static const char cmdnotavail[] = "'%s' command not available.";

/* the #prevmsg command */

staticfn int

doprev_message(void)

{

(void) nh_doprev_message();

return ECMD_OK;

}

/* Count down by decrementing multi */

staticfn int

timed_occupation(void)

{

(*timed_occ_fn)();

if (gm.multi > 0)

gm.multi--;

return gm.multi > 0;

}

/* If you have moved since initially setting some occupations, they

* now shouldn't be able to restart.

*

* The basic rule is that if you are carrying it, you can continue

* since it is with you. If you are acting on something at a distance,

* your orientation to it must have changed when you moved.

*

* The exception to this is taking off items, since they can be taken

* off in a number of ways in the intervening time, screwing up ordering.

*

* Currently: Take off all armor.

* Picking Locks / Forcing Chests.

* Setting traps.

*/

void

reset_occupations(void)

{

reset_remarm();

reset_pick();

reset_trapset();

}

/* If a time is given, use it to timeout this function, otherwise the

* function times out by its own means.

*/

void

set_occupation(int (*fn)(void), const char *txt, cmdcount_nht xtime)

{

if (xtime) {

go.occupation = timed_occupation;

timed_occ_fn = fn;

} else

go.occupation = fn;

go.occtxt = txt;

go.occtime = 0;

return;

}

/*

void

cmdq_print(int q)

{

char buf[QBUFSZ];

struct _cmd_queue *cq = gc.command_queue[q];

pline("CQ:%i", q);

while (cq) {

switch (cq->typ) {

case CMDQ_KEY:

pline("(key:%s)", key2txt(cq->key, buf));

break;

case CMDQ_EXTCMD:

pline("(extcmd:#%s)", cq->ec_entry->ef_txt);

break;

case CMDQ_DIR:

pline("(dir:%i,%i,%i)", cq->dirx, cq->diry, cq->dirz);

break;

case CMDQ_USER_INPUT:

pline("(userinput)");

break;

case CMDQ_INT:

pline("(int:%i)", cq->intval);

break;

default:

pline("(ERROR:%i)",cq->typ);

break;

}

cq = cq->next;

}

}

*/

/* add extended command function to the command queue */

void

cmdq_add_ec(int q, int (*fn)(void))

{

struct _cmd_queue *tmp = (struct _cmd_queue *) alloc(sizeof *tmp);

struct _cmd_queue *cq = gc.command_queue[q];

tmp->typ = CMDQ_EXTCMD;

tmp->ec_entry = ext_func_tab_from_func(fn);

tmp->next = NULL;

while (cq && cq->next)

cq = cq->next;

if (cq)

cq->next = tmp;

else

gc.command_queue[q] = tmp;

}

/* add a key to the command queue */

void

cmdq_add_key(int q, char key)

{

struct _cmd_queue *tmp = (struct _cmd_queue *) alloc(sizeof *tmp);

struct _cmd_queue *cq = gc.command_queue[q];

tmp->typ = CMDQ_KEY;

tmp->key = key;

tmp->next = NULL;

while (cq && cq->next)

cq = cq->next;

if (cq)

cq->next = tmp;

else

gc.command_queue[q] = tmp;

}

/* add a direction to the command queue */

void

cmdq_add_dir(int q, schar dx, schar dy, schar dz)

{

struct _cmd_queue *tmp = (struct _cmd_queue *) alloc(sizeof *tmp);

struct _cmd_queue *cq = gc.command_queue[q];

tmp->typ = CMDQ_DIR;

tmp->dirx = dx;

tmp->diry = dy;

tmp->dirz = dz;

tmp->next = NULL;

while (cq && cq->next)

cq = cq->next;

if (cq)

cq->next = tmp;

else

gc.command_queue[q] = tmp;

}

/* add placeholder to the command queue, allows user input there */

void

cmdq_add_userinput(int q)

{

struct _cmd_queue *tmp = (struct _cmd_queue *) alloc(sizeof *tmp);

struct _cmd_queue *cq = gc.command_queue[q];

tmp->typ = CMDQ_USER_INPUT;

tmp->next = NULL;

while (cq && cq->next)

cq = cq->next;

if (cq)

cq->next = tmp;

else

gc.command_queue[q] = tmp;

}

/* add integer to the command queue */

void

cmdq_add_int(int q, int val)

{

struct _cmd_queue *tmp = (struct _cmd_queue *) alloc(sizeof *tmp);

struct _cmd_queue *cq = gc.command_queue[q];

tmp->typ = CMDQ_INT;

tmp->intval = val;

tmp->next = NULL;

while (cq && cq->next)

cq = cq->next;

if (cq)

cq->next = tmp;

else

gc.command_queue[q] = tmp;

}

/* shift the last entry in command queue to first */

void

cmdq_shift(int q)

{

struct _cmd_queue *tmp = NULL;

struct _cmd_queue *cq = gc.command_queue[q];

while (cq && cq->next && cq->next->next)

cq = cq->next;

if (cq)

tmp = cq->next;

if (tmp) {

tmp->next = gc.command_queue[q];

gc.command_queue[q] = tmp;

cq->next = NULL;

}

}

struct _cmd_queue *

cmdq_reverse(struct _cmd_queue *head)

{

struct _cmd_queue *prev = NULL, *curr = head, *next;

while (curr) {

next = curr->next;

curr->next = prev;

prev = curr;

curr = next;

}

return prev;

}

struct _cmd_queue *

cmdq_copy(int q)

{

struct _cmd_queue *tmp = NULL;

struct _cmd_queue *cq = gc.command_queue[q];

while (cq) {

struct _cmd_queue *tmp2 = (struct _cmd_queue *) alloc(sizeof *tmp2);

*tmp2 = *cq;

tmp2->next = tmp;

tmp = tmp2;

cq = cq->next;

}

tmp = cmdq_reverse(tmp);

return tmp;

}

/* pop off the topmost command from the command queue.

* caller is responsible for freeing the returned _cmd_queue.

*/

struct _cmd_queue *

cmdq_pop(void)

{

int q = (gi.in_doagain) ? CQ_REPEAT : CQ_CANNED;

struct _cmd_queue *tmp = gc.command_queue[q];

if (tmp) {

gc.command_queue[q] = tmp->next;

tmp->next = NULL;

}

return tmp;

}

/* get the top entry without popping it */

struct _cmd_queue *

cmdq_peek(int q)

{

return gc.command_queue[q];

}

/* clear all commands from the command queue */

void

cmdq_clear(int q)

{

struct _cmd_queue *tmp = gc.command_queue[q];

struct _cmd_queue *tmp2;

while (tmp) {

tmp2 = tmp->next;

free(tmp);

tmp = tmp2;

}

gc.command_queue[q] = NULL;

}

char

pgetchar(void) /* courtesy of aeb@cwi.nl */

{

int ch = '\0';

if (iflags.debug_fuzzer)

return randomkey();

ch = nhgetch();

return (char) ch;

}

/* '#' or whatever has been bound to doextcmd() in its place */

char

extcmd_initiator(void)

{

return gc.Cmd.extcmd_char;

}

staticfn boolean

can_do_extcmd(const struct ext_func_tab *extcmd)

{

int ecflags = extcmd->flags;

if (gl.luacore && nhcb_counts[NHCB_CMD_BEFORE]) {

lua_getglobal(gl.luacore, "nh_callback_run");

lua_pushstring(gl.luacore, nhcb_name[NHCB_CMD_BEFORE]);

lua_pushstring(gl.luacore, extcmd->ef_txt);

nhl_pcall_handle(gl.luacore, 2, 1, "can_do_extcmd", NHLpa_panic);

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

lua_settop(gl.luacore, 0);

return FALSE;

}

lua_settop(gl.luacore, 0);

}

if (!wizard && (ecflags & WIZMODECMD)) {

pline(unavailcmd, extcmd->ef_txt);

return FALSE;

} else if (u.uburied && !(ecflags & IFBURIED)) {

You_cant("do that while you are buried!");

return FALSE;

} else if (iflags.debug_fuzzer && (ecflags & NOFUZZERCMD)) {

return FALSE;

}

return TRUE;

}

/* here after # - now read a full-word command */

int

doextcmd(void)

{

int idx, retval;

int (*func)(void);

/* keep repeating until we don't run help or quit */

do {

idx = get_ext_cmd();

if (idx < 0)

return ECMD_OK; /* quit */

func = extcmdlist[idx].ef_funct;

if (!can_do_extcmd(&extcmdlist[idx]))

return ECMD_OK;

if (iflags.menu_requested && !accept_menu_prefix(&extcmdlist[idx])) {

pline("'%s' prefix has no effect for the %s command.",

visctrl(cmd_from_func(do_reqmenu)),

extcmdlist[idx].ef_txt);

iflags.menu_requested = FALSE;

}

/* tell rhack() what command is actually executing */

ge.ext_tlist = &extcmdlist[idx];

retval = (*func)();

} while (func == doextlist);

return retval;

}

/* format extended command flags for display */

staticfn char *

doc_extcmd_flagstr(

winid menuwin,

const struct ext_func_tab *efp) /* if Null, add a footnote to the menu */

{

static char Abuf[10]; /* 5 would suffice: {'[','m','A',']','\0'} */

/* note: tag shown for menu prefix is 'm' even if m-prefix action

has been bound to some other key */

if (!efp) {

char qbuf[QBUFSZ];

add_menu_str(menuwin, "[A] Command autocompletes");

Sprintf(qbuf, "[m] Command accepts '%s' prefix",

visctrl(cmd_from_func(do_reqmenu)));

add_menu_str(menuwin, qbuf);

return (char *) 0;

} else {

boolean mprefix = accept_menu_prefix(efp),

autocomplete = (efp->flags & AUTOCOMPLETE) != 0;

char *p = Abuf;

/* "" or "[m]" or "[A]" or "[mA]" */

if (mprefix || autocomplete) {

*p++ = '[';

if (mprefix)

*p++ = 'm';

if (autocomplete)

*p++ = 'A';

*p++ = ']';

}

*p = '\0';

return Abuf;

}

}

/* here after #? - now list all full-word commands and provide

some navigation capability through the long list */

int

doextlist(void)

{

const struct ext_func_tab *efp = (struct ext_func_tab *) 0;

char buf[BUFSZ], searchbuf[BUFSZ], descbuf[BUFSZ], promptbuf[QBUFSZ];

const char *cmd_desc;

winid menuwin;

anything any;

menu_item *selected;

int n, pass;

int menumode = 0, menushown[2], onelist = 0;

boolean redisplay = TRUE, search = FALSE;

static const char *const headings[] = { "Extended commands",

"Debugging Extended Commands" };

int clr = NO_COLOR;

searchbuf[0] = '\0';

menuwin = create_nhwindow(NHW_MENU);

while (redisplay) {

redisplay = FALSE;

any = cg.zeroany;

start_menu(menuwin, MENU_BEHAVE_STANDARD);

add_menu_str(menuwin, "Extended Commands List");

add_menu_str(menuwin, "");

Sprintf(buf, "Switch to %s commands that don't autocomplete",

menumode ? "including" : "excluding");

any.a_int = 1;

add_menu(menuwin, &nul_glyphinfo, &any, 'a', 0, ATR_NONE, clr, buf,

MENU_ITEMFLAGS_NONE);

if (!*searchbuf) {

any.a_int = 2;

/* was 's', but then using ':' handling within the interface

would only examine the two or three meta entries, not the

actual list of extended commands shown via separator lines;

having ':' as an explicit selector overrides the default

menu behavior for it; we retain 's' as a group accelerator */

add_menu(menuwin, &nul_glyphinfo, &any, ':', 's', ATR_NONE,

clr, "Search extended commands",

MENU_ITEMFLAGS_NONE);

} else {

Strcpy(buf, "Switch back from search");

if (strlen(buf) + strlen(searchbuf) + strlen(" (\"\")") < QBUFSZ)

Sprintf(eos(buf), " (\"%s\")", searchbuf);

any.a_int = 3;

/* specifying ':' as a group accelerator here is mostly a

statement of intent (we'd like to accept it as a synonym but

also want to hide it from general menu use) because it won't

work for interfaces which support ':' to search; use as a

general menu command takes precedence over group accelerator */

add_menu(menuwin, &nul_glyphinfo, &any, 's', ':', ATR_NONE,

clr, buf, MENU_ITEMFLAGS_NONE);

}

if (wizard) {

any.a_int = 4;

add_menu(menuwin, &nul_glyphinfo, &any, 'z', 0, ATR_NONE, clr,

onelist ? "Switch to showing debugging commands in separate section"

: "Switch to showing all alphabetically, including debugging commands",

MENU_ITEMFLAGS_NONE);

}

add_menu_str(menuwin, "");

menushown[0] = menushown[1] = 0;

n = 0;

for (pass = 0; pass <= 1; ++pass) {

/* skip second pass if not in wizard mode or wizard mode

commands are being integrated into a single list */

if (pass == 1 && (onelist || !wizard))

break;

for (efp = extcmdlist; efp->ef_txt; efp++) {

int wizc;

if ((efp->flags & (CMD_NOT_AVAILABLE | INTERNALCMD)) != 0)

continue;

/* if hiding non-autocomplete commands, skip such */

if (menumode == 1 && (efp->flags & AUTOCOMPLETE) == 0)

continue;

/* skip wizard mode commands if not in wizard mode;

when showing two sections, skip wizard mode commands

in pass==0 and skip other commands in pass==1 */

wizc = (efp->flags & WIZMODECMD) != 0;

if (wizc && !wizard)

continue;

if (!onelist && pass != wizc)

continue;

/* command description might get modified on the fly */

cmd_desc = efp->ef_desc;

/* suppress part of the description for #genocided if it

doesn't apply during the current game */

if (!wizard && !discover

&& (efp->flags & GENERALCMD) != 0 /* minor optimization */

&& strstri(cmd_desc, "extinct"))

cmd_desc = strsubst(strcpy(descbuf, cmd_desc),

" been genocided or become extinct",

" been genocided");

/* if searching, skip this command if it doesn't match */

if (*searchbuf

/* first try case-insensitive substring match */

&& !strstri(efp->ef_txt, searchbuf)

&& !strstri(cmd_desc, searchbuf)

/* wildcard support; most interfaces use case-insensitive

pmatch rather than regexp for menu searching */

&& !pmatchi(searchbuf, efp->ef_txt)

&& !pmatchi(searchbuf, cmd_desc))

continue;

/* We're about to show an item, have we shown the menu yet?

Doing menu in inner loop like this on demand avoids a

heading with no subordinate entries on the search

results menu. */

if (!menushown[pass]) {

Strcpy(buf, headings[pass]);

add_menu_heading(menuwin, buf);

menushown[pass] = 1;

}

if (iflags.menu_tab_sep) {

Sprintf(buf, " %s\t%s\t%s", efp->ef_txt,

doc_extcmd_flagstr(menuwin, efp), cmd_desc);

} else {

/* longest ef_txt at present is "wizrumorcheck" (13 chars);

2nd field will be " " or " [A]" or " [m]" or "[mA]" */

Sprintf(buf, " %-14s %4s %s", efp->ef_txt,

doc_extcmd_flagstr(menuwin, efp), cmd_desc);

}

add_menu_str(menuwin, buf);

++n;

}

if (n)

add_menu_str(menuwin, "");

}

if (*searchbuf && !n)

add_menu_str(menuwin, "no matches");

else

(void) doc_extcmd_flagstr(menuwin, (struct ext_func_tab *) 0);

end_menu(menuwin, (char *) 0);

n = select_menu(menuwin, PICK_ONE, &selected);

if (n > 0) {

switch (selected[0].item.a_int) {

case 1: /* 'a': toggle show/hide non-autocomplete */

menumode = 1 - menumode; /* toggle 0 -> 1, 1 -> 0 */

redisplay = TRUE;

break;

case 2: /* ':' when not searching yet: enable search */

search = TRUE;

break;

case 3: /* 's' when already searching: disable search */

search = FALSE;

searchbuf[0] = '\0';

redisplay = TRUE;

break;

case 4: /* 'z': toggle showing wizard mode commands separately */

search = FALSE;

searchbuf[0] = '\0';

onelist = 1 - onelist; /* toggle 0 -> 1, 1 -> 0 */

redisplay = TRUE;

break;

}

free((genericptr_t) selected);

} else {

search = FALSE;

searchbuf[0] = '\0';

}

if (search) {

Strcpy(promptbuf, "Extended command list search phrase");

Strcat(promptbuf, "?");

getlin(promptbuf, searchbuf);

(void) mungspaces(searchbuf);

if (searchbuf[0] == '\033')

searchbuf[0] = '\0';

if (*searchbuf)

redisplay = TRUE;

search = FALSE;

}

}

destroy_nhwindow(menuwin);

return ECMD_OK;

}

#if defined(TTY_GRAPHICS) || defined(CURSES_GRAPHICS) \

|| defined(AMIGA_INTUITION)

#define MAX_EXT_CMD 200 /* Change if we ever have more ext cmds */

DISABLE_WARNING_FORMAT_NONLITERAL

/*

* This is currently used only by the tty interface and is

* controlled via runtime option 'extmenu'. (Most other interfaces

* already use a menu all the time for extended commands.)

*

* ``# ?'' is counted towards the limit of the number of commands,

* so we actually support MAX_EXT_CMD-1 "real" extended commands.

*

* Here after # - now show pick-list of possible commands.

*/

int

extcmd_via_menu(void)

{

const struct ext_func_tab *efp;

menu_item *pick_list = (menu_item *) 0;

winid win;

anything any;

const struct ext_func_tab *choices[MAX_EXT_CMD + 1];

char buf[BUFSZ];

char cbuf[QBUFSZ], prompt[QBUFSZ], fmtstr[20];

int i, n, nchoices, acount;

int ret, len, biggest;

int accelerator, prevaccelerator;

int matchlevel = 0;

boolean wastoolong, one_per_line;

int clr = NO_COLOR;

ret = 0;

cbuf[0] = '\0';

biggest = 0;

while (!ret) {

i = n = 0;

any = cg.zeroany;

/* populate choices */

for (efp = extcmdlist; efp->ef_txt; efp++) {

if ((efp->flags & (CMD_NOT_AVAILABLE|INTERNALCMD))

|| !(efp->flags & AUTOCOMPLETE)

|| (!wizard && (efp->flags & WIZMODECMD)))

continue;

if (!matchlevel || !strncmp(efp->ef_txt, cbuf, matchlevel)) {

choices[i] = efp;

if ((len = (int) strlen(efp->ef_desc)) > biggest)

biggest = len;

if (++i > MAX_EXT_CMD) {

#if (NH_DEVEL_STATUS != NH_STATUS_RELEASED)

impossible(

"Exceeded %d extended commands in doextcmd() menu; 'extmenu' disabled.",

MAX_EXT_CMD);

#endif /* NH_DEVEL_STATUS != NH_STATUS_RELEASED */

iflags.extmenu = FALSE;

return -1;

}

}

}

choices[i] = (struct ext_func_tab *) 0;

nchoices = i;

/* if we're down to one, we have our selection so get out of here */

if (nchoices <= 1) {

ret = (nchoices == 1) ? (int) (choices[0] - extcmdlist) : -1;

break;

}

/* otherwise... */

win = create_nhwindow(NHW_MENU);

start_menu(win, MENU_BEHAVE_STANDARD);

Sprintf(fmtstr, "%%-%ds", biggest + 15);

prompt[0] = '\0';

wastoolong = FALSE; /* True => had to wrap due to line width

* ('w' in wizard mode) */

/* -3: two line menu header, 1 line menu footer (for prompt) */

one_per_line = (nchoices < ROWNO - 3);

prevaccelerator = 0;

acount = 0;

for (i = 0; choices[i]; ++i) {

accelerator = choices[i]->ef_txt[matchlevel];

if (accelerator != prevaccelerator || one_per_line)

wastoolong = FALSE;

if (accelerator != prevaccelerator || one_per_line

|| (acount >= 2

/* +4: + sizeof " or " - sizeof "" */

&& (strlen(prompt) + 4 + strlen(choices[i]->ef_txt)

/* -6: enough room for 1 space left margin

* + "%c - " menu selector + 1 space right margin */

>= min(sizeof prompt, COLNO - 6)))) {

if (acount) {

/* flush extended cmds for that letter already in buf */

Sprintf(buf, fmtstr, prompt);

any.a_char = prevaccelerator;

add_menu(win, &nul_glyphinfo, &any, any.a_char,

0, ATR_NONE, clr, buf, MENU_ITEMFLAGS_NONE);

acount = 0;

if (!(accelerator != prevaccelerator || one_per_line))

wastoolong = TRUE;

}

}

prevaccelerator = accelerator;

if (!acount || one_per_line) {

Sprintf(prompt, "%s%s [%s]", wastoolong ? "or " : "",

choices[i]->ef_txt, choices[i]->ef_desc);

} else if (acount == 1) {

Sprintf(prompt, "%s%s or %s", wastoolong ? "or " : "",

choices[i - 1]->ef_txt, choices[i]->ef_txt);

} else {

Strcat(prompt, " or ");

Strcat(prompt, choices[i]->ef_txt);

}

++acount;

}

if (acount) {

/* flush buf */

Sprintf(buf, fmtstr, prompt);

any.a_char = prevaccelerator;

add_menu(win, &nul_glyphinfo, &any, any.a_char, 0,

ATR_NONE, clr, buf, MENU_ITEMFLAGS_NONE);

}

Snprintf(prompt, sizeof(prompt), "Extended Command: %s", cbuf);

end_menu(win, prompt);

n = select_menu(win, PICK_ONE, &pick_list);

destroy_nhwindow(win);

if (n == 1) {

if (matchlevel > (QBUFSZ - 2)) {

free((genericptr_t) pick_list);

#if (NH_DEVEL_STATUS != NH_STATUS_RELEASED)

impossible("Too many chars (%d) entered in extcmd_via_menu()",

matchlevel);

#endif

ret = -1;

} else {

cbuf[matchlevel++] = pick_list[0].item.a_char;

cbuf[matchlevel] = '\0';

free((genericptr_t) pick_list);

}

} else {

if (matchlevel) {

ret = 0;

matchlevel = 0;

} else

ret = -1;

}

}

return ret;

}

RESTORE_WARNING_FORMAT_NONLITERAL

#endif /* TTY_GRAPHICS */

/* #monster command - use special monster ability while polymorphed */

int

domonability(void)

{

struct permonst *uptr = gy.youmonst.data;

boolean might_hide = (is_hider(uptr) || hides_under(uptr));

char c = '\0';

if (might_hide && webmaker(uptr)) {

c = yn_function("Hide [h] or spin a web [s]?",

hidespinchars, 'q', TRUE);

if (c == 'q' || c == '\033')

return ECMD_OK;

}

if (can_breathe(uptr))

return dobreathe();

else if (attacktype(uptr, AT_SPIT))

return dospit();

else if (uptr->mlet == S_NYMPH)

return doremove();

else if (attacktype(uptr, AT_GAZE))

return dogaze();

else if (is_were(uptr))

return dosummon();

else if (c ? c == 'h' : might_hide)

return dohide();

else if (c ? c == 's' : webmaker(uptr))

return dospinweb();

else if (is_mind_flayer(uptr))

return domindblast();

else if (u.umonnum == PM_GREMLIN) {

if (IS_FOUNTAIN(levl[u.ux][u.uy].typ)) {

if (split_mon(&gy.youmonst, (struct monst *) 0))

dryup(u.ux, u.uy, TRUE);

} else if (is_pool(u.ux, u.uy)) {

/* is_pool: might be wearing water walking boots or amulet of

magical breathing */

(void) split_mon(&gy.youmonst, (struct monst *) 0);

} else {

There("is no fountain here.");

}

} else if (is_unicorn(uptr)) {

use_unicorn_horn((struct obj **) 0);

return ECMD_TIME;

} else if (uptr->msound == MS_SHRIEK) {

You("shriek.");

if (u.uburied)

pline("Unfortunately sound does not carry well through rock.");

else

aggravate();

} else if (is_vampire(uptr) || is_vampshifter(&gy.youmonst)) {

return dopoly();

} else if (u.usteed && can_breathe(u.usteed->data)) {

(void) pet_ranged_attk(u.usteed, TRUE);

return ECMD_TIME;

} else if (Upolyd) {

pline("Any special ability you may have is purely reflexive.");

} else {

You("don't have a special ability in your normal form!");

}

return ECMD_OK;

}

int

enter_explore_mode(void)

{

if (discover) {

You("are already in explore mode.");

} else {

const char *oldmode = !wizard ? "normal game" : "debug mode";

if (!authorize_explore_mode()) {

if (!wizard) {

You("cannot access explore mode.");

return ECMD_OK;

} else {

pline(

"Note: normally you wouldn't be allowed into explore mode.");

/* keep going */

}

}

pline("Beware! From explore mode there will be no return to %s,",

oldmode);

if (paranoid_query(ParanoidQuit,

"Do you want to enter explore mode?")) {

discover = TRUE;

wizard = FALSE;

clear_nhwindow(WIN_MESSAGE);

You("are now in non-scoring explore mode.");

} else {

clear_nhwindow(WIN_MESSAGE);

pline("Continuing with %s.", oldmode);

}

}

return ECMD_OK;

}

void

makemap_prepost(boolean pre, boolean wiztower)

{

NHFILE *tmpnhfp;

struct monst *mtmp;

if (pre) {

makemap_remove_mons();

rm_mapseen(ledger_no(&u.uz)); /* discard overview info for level */

{